Annotation of embedaddon/php/ext/bcmath/libbcmath/src/doaddsub.c, revision 1.1.1.1
1.1 misho 1: /* doaddsub.c: bcmath library file. */
2: /*
3: Copyright (C) 1991, 1992, 1993, 1994, 1997 Free Software Foundation, Inc.
4: Copyright (C) 2000 Philip A. Nelson
5:
6: This library is free software; you can redistribute it and/or
7: modify it under the terms of the GNU Lesser General Public
8: License as published by the Free Software Foundation; either
9: version 2 of the License, or (at your option) any later version.
10:
11: This library is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14: Lesser General Public License for more details. (COPYING.LIB)
15:
16: You should have received a copy of the GNU Lesser General Public
17: License along with this library; if not, write to:
18:
19: The Free Software Foundation, Inc.
20: 59 Temple Place, Suite 330
21: Boston, MA 02111-1307 USA.
22:
23: You may contact the author by:
24: e-mail: philnelson@acm.org
25: us-mail: Philip A. Nelson
26: Computer Science Department, 9062
27: Western Washington University
28: Bellingham, WA 98226-9062
29:
30: *************************************************************************/
31:
32: #include <config.h>
33: #include <stdio.h>
34: #include <assert.h>
35: #include <stdlib.h>
36: #include <ctype.h>
37: #include <stdarg.h>
38: #include "bcmath.h"
39: #include "private.h"
40:
41:
42: /* Perform addition: N1 is added to N2 and the value is
43: returned. The signs of N1 and N2 are ignored.
44: SCALE_MIN is to set the minimum scale of the result. */
45:
46: bc_num
47: _bc_do_add (n1, n2, scale_min)
48: bc_num n1, n2;
49: int scale_min;
50: {
51: bc_num sum;
52: int sum_scale, sum_digits;
53: char *n1ptr, *n2ptr, *sumptr;
54: int carry, n1bytes, n2bytes;
55: int count;
56:
57: /* Prepare sum. */
58: sum_scale = MAX (n1->n_scale, n2->n_scale);
59: sum_digits = MAX (n1->n_len, n2->n_len) + 1;
60: sum = bc_new_num (sum_digits, MAX(sum_scale, scale_min));
61:
62: /* Zero extra digits made by scale_min. */
63: if (scale_min > sum_scale)
64: {
65: sumptr = (char *) (sum->n_value + sum_scale + sum_digits);
66: for (count = scale_min - sum_scale; count > 0; count--)
67: *sumptr++ = 0;
68: }
69:
70: /* Start with the fraction part. Initialize the pointers. */
71: n1bytes = n1->n_scale;
72: n2bytes = n2->n_scale;
73: n1ptr = (char *) (n1->n_value + n1->n_len + n1bytes - 1);
74: n2ptr = (char *) (n2->n_value + n2->n_len + n2bytes - 1);
75: sumptr = (char *) (sum->n_value + sum_scale + sum_digits - 1);
76:
77: /* Add the fraction part. First copy the longer fraction.*/
78: if (n1bytes != n2bytes)
79: {
80: if (n1bytes > n2bytes)
81: while (n1bytes>n2bytes)
82: { *sumptr-- = *n1ptr--; n1bytes--;}
83: else
84: while (n2bytes>n1bytes)
85: { *sumptr-- = *n2ptr--; n2bytes--;}
86: }
87:
88: /* Now add the remaining fraction part and equal size integer parts. */
89: n1bytes += n1->n_len;
90: n2bytes += n2->n_len;
91: carry = 0;
92: while ((n1bytes > 0) && (n2bytes > 0))
93: {
94: *sumptr = *n1ptr-- + *n2ptr-- + carry;
95: if (*sumptr > (BASE-1))
96: {
97: carry = 1;
98: *sumptr -= BASE;
99: }
100: else
101: carry = 0;
102: sumptr--;
103: n1bytes--;
104: n2bytes--;
105: }
106:
107: /* Now add carry the longer integer part. */
108: if (n1bytes == 0)
109: { n1bytes = n2bytes; n1ptr = n2ptr; }
110: while (n1bytes-- > 0)
111: {
112: *sumptr = *n1ptr-- + carry;
113: if (*sumptr > (BASE-1))
114: {
115: carry = 1;
116: *sumptr -= BASE;
117: }
118: else
119: carry = 0;
120: sumptr--;
121: }
122:
123: /* Set final carry. */
124: if (carry == 1)
125: *sumptr += 1;
126:
127: /* Adjust sum and return. */
128: _bc_rm_leading_zeros (sum);
129: return sum;
130: }
131:
132:
133: /* Perform subtraction: N2 is subtracted from N1 and the value is
134: returned. The signs of N1 and N2 are ignored. Also, N1 is
135: assumed to be larger than N2. SCALE_MIN is the minimum scale
136: of the result. */
137:
138: bc_num
139: _bc_do_sub (n1, n2, scale_min)
140: bc_num n1, n2;
141: int scale_min;
142: {
143: bc_num diff;
144: int diff_scale, diff_len;
145: int min_scale, min_len;
146: char *n1ptr, *n2ptr, *diffptr;
147: int borrow, count, val;
148:
149: /* Allocate temporary storage. */
150: diff_len = MAX (n1->n_len, n2->n_len);
151: diff_scale = MAX (n1->n_scale, n2->n_scale);
152: min_len = MIN (n1->n_len, n2->n_len);
153: min_scale = MIN (n1->n_scale, n2->n_scale);
154: diff = bc_new_num (diff_len, MAX(diff_scale, scale_min));
155:
156: /* Zero extra digits made by scale_min. */
157: if (scale_min > diff_scale)
158: {
159: diffptr = (char *) (diff->n_value + diff_len + diff_scale);
160: for (count = scale_min - diff_scale; count > 0; count--)
161: *diffptr++ = 0;
162: }
163:
164: /* Initialize the subtract. */
165: n1ptr = (char *) (n1->n_value + n1->n_len + n1->n_scale -1);
166: n2ptr = (char *) (n2->n_value + n2->n_len + n2->n_scale -1);
167: diffptr = (char *) (diff->n_value + diff_len + diff_scale -1);
168:
169: /* Subtract the numbers. */
170: borrow = 0;
171:
172: /* Take care of the longer scaled number. */
173: if (n1->n_scale != min_scale)
174: {
175: /* n1 has the longer scale */
176: for (count = n1->n_scale - min_scale; count > 0; count--)
177: *diffptr-- = *n1ptr--;
178: }
179: else
180: {
181: /* n2 has the longer scale */
182: for (count = n2->n_scale - min_scale; count > 0; count--)
183: {
184: val = - *n2ptr-- - borrow;
185: if (val < 0)
186: {
187: val += BASE;
188: borrow = 1;
189: }
190: else
191: borrow = 0;
192: *diffptr-- = val;
193: }
194: }
195:
196: /* Now do the equal length scale and integer parts. */
197:
198: for (count = 0; count < min_len + min_scale; count++)
199: {
200: val = *n1ptr-- - *n2ptr-- - borrow;
201: if (val < 0)
202: {
203: val += BASE;
204: borrow = 1;
205: }
206: else
207: borrow = 0;
208: *diffptr-- = val;
209: }
210:
211: /* If n1 has more digits then n2, we now do that subtract. */
212: if (diff_len != min_len)
213: {
214: for (count = diff_len - min_len; count > 0; count--)
215: {
216: val = *n1ptr-- - borrow;
217: if (val < 0)
218: {
219: val += BASE;
220: borrow = 1;
221: }
222: else
223: borrow = 0;
224: *diffptr-- = val;
225: }
226: }
227:
228: /* Clean up and return. */
229: _bc_rm_leading_zeros (diff);
230: return diff;
231: }
232:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to doaddsub.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / bcmath / libbcmath / src