1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047 |
- /* -*-C-*-
- $Id: bignum.c,v 9.41 1994/02/09 00:53:27 cph Exp $
- Copyright 1986,1987,1988,1989,1990,1991 Massachusetts Institute of Technology
- Copyright 1992,1993,1994,2004 Massachusetts Institute of Technology
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are
- met:
- 1. Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following
- disclaimer in the documentation and/or other materials provided
- with the distribution.
- 3. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior
- written permission.
- THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
- INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
- IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- POSSIBILITY OF SUCH DAMAGE.
- */
- /* License changed to modified BSD by cph on 2004-11-08. */
- /* Changes for Scheme 48:
- * - Converted to ANSI.
- * - Added bitwise operations.
- * - Added s48_ to the beginning of all externally visible names.
- * - Cached the bignum representations of -1, 0, and 1.
- */
- #include "bignum.h"
- #include "bignumint.h"
- #include <limits.h>
- #include <stdio.h>
- #include <stdlib.h> /* abort */
- #include <math.h>
- /* Forward references */
- static int bignum_equal_p_unsigned(bignum_type, bignum_type);
- static enum bignum_comparison bignum_compare_unsigned(bignum_type, bignum_type);
- static bignum_type bignum_add_unsigned(bignum_type, bignum_type, int);
- static bignum_type bignum_subtract_unsigned(bignum_type, bignum_type);
- static bignum_type bignum_multiply_unsigned(bignum_type, bignum_type, int);
- static bignum_type bignum_multiply_unsigned_small_factor
- (bignum_type, bignum_digit_type, int);
- static void bignum_destructive_scale_up(bignum_type, bignum_digit_type);
- static void bignum_destructive_add(bignum_type, bignum_digit_type);
- static void bignum_divide_unsigned_large_denominator
- (bignum_type, bignum_type, bignum_type *, bignum_type *, int, int);
- static void bignum_destructive_normalization(bignum_type, bignum_type, int);
- static void bignum_destructive_unnormalization(bignum_type, int);
- static void bignum_divide_unsigned_normalized(bignum_type, bignum_type, bignum_type);
- static bignum_digit_type bignum_divide_subtract
- (bignum_digit_type *, bignum_digit_type *, bignum_digit_type,
- bignum_digit_type *);
- static void bignum_divide_unsigned_medium_denominator
- (bignum_type, bignum_digit_type, bignum_type *, bignum_type *, int, int);
- static bignum_digit_type bignum_digit_divide
- (bignum_digit_type, bignum_digit_type, bignum_digit_type, bignum_digit_type *);
- static bignum_digit_type bignum_digit_divide_subtract
- (bignum_digit_type, bignum_digit_type, bignum_digit_type, bignum_digit_type *);
- static void bignum_divide_unsigned_small_denominator
- (bignum_type, bignum_digit_type, bignum_type *, bignum_type *, int, int);
- static bignum_digit_type bignum_destructive_scale_down
- (bignum_type, bignum_digit_type);
- static bignum_type bignum_remainder_unsigned_small_denominator
- (bignum_type, bignum_digit_type, int);
- static bignum_type bignum_digit_to_bignum(bignum_digit_type, int);
- static bignum_type bignum_allocate(bignum_length_type, int);
- static bignum_type bignum_allocate_zeroed(bignum_length_type, int);
- static bignum_type bignum_shorten_length(bignum_type, bignum_length_type);
- static bignum_type bignum_trim(bignum_type);
- static bignum_type bignum_copy(bignum_type);
- static bignum_type bignum_new_sign(bignum_type, int);
- static bignum_type bignum_maybe_new_sign(bignum_type, int);
- static void bignum_destructive_copy(bignum_type, bignum_type);
- /* Unused
- static void bignum_destructive_zero(bignum_type);
- */
- /* Added for bitwise operations. */
- static bignum_type bignum_magnitude_ash(bignum_type arg1, long n);
- static bignum_type bignum_pospos_bitwise_op(int op, bignum_type, bignum_type);
- static bignum_type bignum_posneg_bitwise_op(int op, bignum_type, bignum_type);
- static bignum_type bignum_negneg_bitwise_op(int op, bignum_type, bignum_type);
- static void bignum_negate_magnitude(bignum_type);
- static long bignum_unsigned_logcount(bignum_type arg);
- static int bignum_unsigned_logbitp(int shift, bignum_type bignum);
- static s48_ref_t s48_bignum_zero = NULL;
- static s48_ref_t s48_bignum_pos_one = NULL;
- static s48_ref_t s48_bignum_neg_one = NULL;
- /* Exports */
- /*
- * We have to allocate the cached constants slightly differently because
- * they have to be registered with the GC, which requires that we have
- * tagged pointers to them.
- */
- void
- s48_bignum_make_cached_constants(void)
- {
- if (s48_bignum_zero == NULL) {
- bignum_type temp;
-
- s48_bignum_zero = s48_make_global_ref((s48_value) BIGNUM_ALLOCATE_TAGGED(0));
- temp = S48_ADDRESS_AFTER_HEADER(s48_deref(s48_bignum_zero), long);
- BIGNUM_SET_HEADER (temp, 0, 0);
-
- s48_bignum_pos_one = s48_make_global_ref((s48_value) BIGNUM_ALLOCATE_TAGGED(1));
- temp = S48_ADDRESS_AFTER_HEADER(s48_deref(s48_bignum_pos_one), long);
- BIGNUM_SET_HEADER (temp, 1, 0);
- (BIGNUM_REF (temp, 0)) = 1;
-
- s48_bignum_neg_one = s48_make_global_ref ((s48_value) BIGNUM_ALLOCATE_TAGGED(1));
- temp = S48_ADDRESS_AFTER_HEADER(s48_deref(s48_bignum_neg_one), long);
- BIGNUM_SET_HEADER (temp, 1, 1);
- (BIGNUM_REF (temp, 0)) = 1;
- }
- }
- int
- s48_bignum_equal_p(bignum_type x, bignum_type y)
- {
- return
- ((BIGNUM_ZERO_P (x))
- ? (BIGNUM_ZERO_P (y))
- : ((! (BIGNUM_ZERO_P (y)))
- && ((BIGNUM_NEGATIVE_P (x))
- ? (BIGNUM_NEGATIVE_P (y))
- : (! (BIGNUM_NEGATIVE_P (y))))
- && (bignum_equal_p_unsigned (x, y))));
- }
- enum bignum_comparison
- s48_bignum_test(bignum_type bignum)
- {
- return
- ((BIGNUM_ZERO_P (bignum))
- ? bignum_comparison_equal
- : (BIGNUM_NEGATIVE_P (bignum))
- ? bignum_comparison_less
- : bignum_comparison_greater);
- }
- enum bignum_comparison
- s48_bignum_compare(bignum_type x, bignum_type y)
- {
- return
- ((BIGNUM_ZERO_P (x))
- ? ((BIGNUM_ZERO_P (y))
- ? bignum_comparison_equal
- : (BIGNUM_NEGATIVE_P (y))
- ? bignum_comparison_greater
- : bignum_comparison_less)
- : (BIGNUM_ZERO_P (y))
- ? ((BIGNUM_NEGATIVE_P (x))
- ? bignum_comparison_less
- : bignum_comparison_greater)
- : (BIGNUM_NEGATIVE_P (x))
- ? ((BIGNUM_NEGATIVE_P (y))
- ? (bignum_compare_unsigned (y, x))
- : (bignum_comparison_less))
- : ((BIGNUM_NEGATIVE_P (y))
- ? (bignum_comparison_greater)
- : (bignum_compare_unsigned (x, y))));
- }
- bignum_type
- s48_bignum_add(bignum_type x, bignum_type y)
- {
- return
- ((BIGNUM_ZERO_P (x))
- ? (BIGNUM_MAYBE_COPY (y))
- : (BIGNUM_ZERO_P (y))
- ? (BIGNUM_MAYBE_COPY (x))
- : ((BIGNUM_NEGATIVE_P (x))
- ? ((BIGNUM_NEGATIVE_P (y))
- ? (bignum_add_unsigned (x, y, 1))
- : (bignum_subtract_unsigned (y, x)))
- : ((BIGNUM_NEGATIVE_P (y))
- ? (bignum_subtract_unsigned (x, y))
- : (bignum_add_unsigned (x, y, 0)))));
- }
- bignum_type
- s48_bignum_subtract(bignum_type x, bignum_type y)
- {
- return
- ((BIGNUM_ZERO_P (x))
- ? ((BIGNUM_ZERO_P (y))
- ? (BIGNUM_MAYBE_COPY (y))
- : (bignum_new_sign (y, (! (BIGNUM_NEGATIVE_P (y))))))
- : ((BIGNUM_ZERO_P (y))
- ? (BIGNUM_MAYBE_COPY (x))
- : ((BIGNUM_NEGATIVE_P (x))
- ? ((BIGNUM_NEGATIVE_P (y))
- ? (bignum_subtract_unsigned (y, x))
- : (bignum_add_unsigned (x, y, 1)))
- : ((BIGNUM_NEGATIVE_P (y))
- ? (bignum_add_unsigned (x, y, 0))
- : (bignum_subtract_unsigned (x, y))))));
- }
- bignum_type
- s48_bignum_negate(bignum_type x)
- {
- return
- ((BIGNUM_ZERO_P (x))
- ? (BIGNUM_MAYBE_COPY (x))
- : (bignum_new_sign (x, (! (BIGNUM_NEGATIVE_P (x))))));
- }
- bignum_type
- s48_bignum_multiply(bignum_type x, bignum_type y)
- {
- bignum_length_type x_length = (BIGNUM_LENGTH (x));
- bignum_length_type y_length = (BIGNUM_LENGTH (y));
- int negative_p =
- ((BIGNUM_NEGATIVE_P (x))
- ? (! (BIGNUM_NEGATIVE_P (y)))
- : (BIGNUM_NEGATIVE_P (y)));
- if (BIGNUM_ZERO_P (x))
- return (BIGNUM_MAYBE_COPY (x));
- if (BIGNUM_ZERO_P (y))
- return (BIGNUM_MAYBE_COPY (y));
- if (x_length == 1)
- {
- bignum_digit_type digit = (BIGNUM_REF (x, 0));
- if (digit == 1)
- return (bignum_maybe_new_sign (y, negative_p));
- if (digit < BIGNUM_RADIX_ROOT)
- return (bignum_multiply_unsigned_small_factor (y, digit, negative_p));
- }
- if (y_length == 1)
- {
- bignum_digit_type digit = (BIGNUM_REF (y, 0));
- if (digit == 1)
- return (bignum_maybe_new_sign (x, negative_p));
- if (digit < BIGNUM_RADIX_ROOT)
- return (bignum_multiply_unsigned_small_factor (x, digit, negative_p));
- }
- return (bignum_multiply_unsigned (x, y, negative_p));
- }
- static int
- bignum_divide(bignum_type numerator, bignum_type denominator,
- bignum_type * quotient, bignum_type * remainder)
- {
- if (BIGNUM_ZERO_P (denominator))
- return (1);
- if (BIGNUM_ZERO_P (numerator))
- {
- (*quotient) = (BIGNUM_MAYBE_COPY (numerator));
- (*remainder) = (BIGNUM_MAYBE_COPY (numerator));
- }
- else
- {
- int r_negative_p = (BIGNUM_NEGATIVE_P (numerator));
- int q_negative_p =
- ((BIGNUM_NEGATIVE_P (denominator)) ? (! r_negative_p) : r_negative_p);
- switch (bignum_compare_unsigned (numerator, denominator))
- {
- case bignum_comparison_equal:
- {
- (*quotient) = (BIGNUM_ONE (q_negative_p));
- (*remainder) = (BIGNUM_ZERO ());
- break;
- }
- case bignum_comparison_less:
- {
- (*quotient) = (BIGNUM_ZERO ());
- (*remainder) = (BIGNUM_MAYBE_COPY (numerator));
- break;
- }
- case bignum_comparison_greater:
- {
- if ((BIGNUM_LENGTH (denominator)) == 1)
- {
- bignum_digit_type digit = (BIGNUM_REF (denominator, 0));
- if (digit == 1)
- {
- (*quotient) =
- (bignum_maybe_new_sign (numerator, q_negative_p));
- (*remainder) = (BIGNUM_ZERO ());
- break;
- }
- else if (digit < BIGNUM_RADIX_ROOT)
- {
- bignum_divide_unsigned_small_denominator
- (numerator, digit,
- quotient, remainder,
- q_negative_p, r_negative_p);
- break;
- }
- else
- {
- bignum_divide_unsigned_medium_denominator
- (numerator, digit,
- quotient, remainder,
- q_negative_p, r_negative_p);
- break;
- }
- }
- bignum_divide_unsigned_large_denominator
- (numerator, denominator,
- quotient, remainder,
- q_negative_p, r_negative_p);
- break;
- }
- }
- }
- return (0);
- }
- int
- s48_bignum_divide(bignum_type numerator, bignum_type denominator,
- void* quotient, void * remainder)
- {
- return bignum_divide(numerator, denominator,
- (bignum_type *)quotient, (bignum_type *)remainder);
- }
- bignum_type
- s48_bignum_quotient(bignum_type numerator, bignum_type denominator)
- {
- if (BIGNUM_ZERO_P (denominator))
- return (BIGNUM_OUT_OF_BAND);
- if (BIGNUM_ZERO_P (numerator))
- return (BIGNUM_MAYBE_COPY (numerator));
- {
- int q_negative_p =
- ((BIGNUM_NEGATIVE_P (denominator))
- ? (! (BIGNUM_NEGATIVE_P (numerator)))
- : (BIGNUM_NEGATIVE_P (numerator)));
- switch (bignum_compare_unsigned (numerator, denominator))
- {
- case bignum_comparison_equal:
- return (BIGNUM_ONE (q_negative_p));
- case bignum_comparison_less:
- return (BIGNUM_ZERO ());
- case bignum_comparison_greater:
- default: /* to appease gcc -Wall */
- {
- bignum_type quotient;
- if ((BIGNUM_LENGTH (denominator)) == 1)
- {
- bignum_digit_type digit = (BIGNUM_REF (denominator, 0));
- if (digit == 1)
- return (bignum_maybe_new_sign (numerator, q_negative_p));
- if (digit < BIGNUM_RADIX_ROOT)
- bignum_divide_unsigned_small_denominator
- (numerator, digit,
- ("ient), ((bignum_type *) 0),
- q_negative_p, 0);
- else
- bignum_divide_unsigned_medium_denominator
- (numerator, digit,
- ("ient), ((bignum_type *) 0),
- q_negative_p, 0);
- }
- else
- bignum_divide_unsigned_large_denominator
- (numerator, denominator,
- ("ient), ((bignum_type *) 0),
- q_negative_p, 0);
- return (quotient);
- }
- }
- }
- }
- bignum_type
- s48_bignum_remainder(bignum_type numerator, bignum_type denominator)
- {
- if (BIGNUM_ZERO_P (denominator))
- return (BIGNUM_OUT_OF_BAND);
- if (BIGNUM_ZERO_P (numerator))
- return (BIGNUM_MAYBE_COPY (numerator));
- switch (bignum_compare_unsigned (numerator, denominator))
- {
- case bignum_comparison_equal:
- return (BIGNUM_ZERO ());
- case bignum_comparison_less:
- return (BIGNUM_MAYBE_COPY (numerator));
- case bignum_comparison_greater:
- default: /* to appease gcc -Wall */
- {
- bignum_type remainder;
- if ((BIGNUM_LENGTH (denominator)) == 1)
- {
- bignum_digit_type digit = (BIGNUM_REF (denominator, 0));
- if (digit == 1)
- return (BIGNUM_ZERO ());
- if (digit < BIGNUM_RADIX_ROOT)
- return
- (bignum_remainder_unsigned_small_denominator
- (numerator, digit, (BIGNUM_NEGATIVE_P (numerator))));
- bignum_divide_unsigned_medium_denominator
- (numerator, digit,
- ((bignum_type *) 0), (&remainder),
- 0, (BIGNUM_NEGATIVE_P (numerator)));
- }
- else
- bignum_divide_unsigned_large_denominator
- (numerator, denominator,
- ((bignum_type *) 0), (&remainder),
- 0, (BIGNUM_NEGATIVE_P (numerator)));
- return (remainder);
- }
- }
- }
- /* These procedures depend on the non-portable type `unsigned long'.
- If your compiler doesn't support this type, either define the
- switch `BIGNUM_NO_ULONG' to disable them (in "bignum.h"), or write
- new versions that don't use this type. */
- #ifndef BIGNUM_NO_ULONG
- bignum_type
- s48_long_to_bignum(long n)
- {
- int negative_p;
- bignum_digit_type result_digits [BIGNUM_DIGITS_FOR_LONG];
- bignum_digit_type * end_digits = result_digits;
- /* Special cases win when these small constants are cached. */
- if (n == 0) return (BIGNUM_ZERO ());
- if (n == 1) return (BIGNUM_ONE (0));
- if (n == -1) return (BIGNUM_ONE (1));
- {
- unsigned long accumulator = ((negative_p = (n < 0)) ? (-n) : n);
- do
- {
- (*end_digits++) = (accumulator & BIGNUM_DIGIT_MASK);
- accumulator >>= BIGNUM_DIGIT_LENGTH;
- }
- while (accumulator != 0);
- }
- {
- bignum_type result =
- (bignum_allocate ((end_digits - result_digits), negative_p));
- bignum_digit_type * scan_digits = result_digits;
- bignum_digit_type * scan_result = (BIGNUM_START_PTR (result));
- while (scan_digits < end_digits)
- (*scan_result++) = (*scan_digits++);
- return (result);
- }
- }
- long
- s48_bignum_to_long(bignum_type bignum)
- {
- if (BIGNUM_ZERO_P (bignum))
- return (0);
- {
- unsigned long accumulator = 0;
- bignum_digit_type * start = (BIGNUM_START_PTR (bignum));
- bignum_digit_type * scan = (start + (BIGNUM_LENGTH (bignum)));
- while (start < scan)
- accumulator = ((accumulator << BIGNUM_DIGIT_LENGTH) + (*--scan));
- return ((BIGNUM_NEGATIVE_P (bignum)) ? (-((long)accumulator)) : (long)accumulator);
- }
- }
- bignum_type
- s48_ulong_to_bignum(unsigned long n)
- {
- bignum_digit_type result_digits [BIGNUM_DIGITS_FOR_LONG];
- bignum_digit_type * end_digits = result_digits;
- /* Special cases win when these small constants are cached. */
- if (n == 0) return (BIGNUM_ZERO ());
- if (n == 1) return (BIGNUM_ONE (0));
- {
- unsigned long accumulator = n;
- do
- {
- (*end_digits++) = (accumulator & BIGNUM_DIGIT_MASK);
- accumulator >>= BIGNUM_DIGIT_LENGTH;
- }
- while (accumulator != 0);
- }
- {
- bignum_type result =
- (bignum_allocate ((end_digits - result_digits), 0));
- bignum_digit_type * scan_digits = result_digits;
- bignum_digit_type * scan_result = (BIGNUM_START_PTR (result));
- while (scan_digits < end_digits)
- (*scan_result++) = (*scan_digits++);
- return (result);
- }
- }
- unsigned long
- s48_bignum_to_ulong(bignum_type bignum)
- {
- if (BIGNUM_ZERO_P (bignum))
- return (0);
- {
- unsigned long accumulator = 0;
- bignum_digit_type * start = (BIGNUM_START_PTR (bignum));
- bignum_digit_type * scan = (start + (BIGNUM_LENGTH (bignum)));
- while (start < scan)
- accumulator = ((accumulator << BIGNUM_DIGIT_LENGTH) + (*--scan));
- return (accumulator);
- }
- }
- #endif /* not BIGNUM_NO_ULONG */
- #define DTB_WRITE_DIGIT(factor) \
- { \
- significand *= (factor); \
- digit = ((bignum_digit_type) significand); \
- (*--scan) = digit; \
- significand -= ((double) digit); \
- }
- bignum_type
- s48_double_to_bignum(double x)
- {
- int exponent;
- double significand = (frexp (x, (&exponent)));
- if (exponent <= 0) return (BIGNUM_ZERO ());
- if (exponent == 1) return (BIGNUM_ONE (x < 0));
- if (significand < 0) significand = (-significand);
- {
- bignum_length_type length = (BIGNUM_BITS_TO_DIGITS (exponent));
- bignum_type result = (bignum_allocate (length, (x < 0)));
- bignum_digit_type * start = (BIGNUM_START_PTR (result));
- bignum_digit_type * scan = (start + length);
- bignum_digit_type digit;
- int odd_bits = (exponent % BIGNUM_DIGIT_LENGTH);
- if (odd_bits > 0)
- DTB_WRITE_DIGIT (1L << odd_bits);
- while (start < scan)
- {
- if (significand == 0)
- {
- while (start < scan)
- (*--scan) = 0;
- break;
- }
- DTB_WRITE_DIGIT (BIGNUM_RADIX);
- }
- return (result);
- }
- }
- #undef DTB_WRITE_DIGIT
- double
- s48_bignum_to_double(bignum_type bignum)
- {
- if (BIGNUM_ZERO_P (bignum))
- return (0);
- {
- double accumulator = 0;
- bignum_digit_type * start = (BIGNUM_START_PTR (bignum));
- bignum_digit_type * scan = (start + (BIGNUM_LENGTH (bignum)));
- while (start < scan)
- accumulator = ((accumulator * BIGNUM_RADIX) + (*--scan));
- return ((BIGNUM_NEGATIVE_P (bignum)) ? (-accumulator) : accumulator);
- }
- }
- int
- s48_bignum_fits_in_word_p(bignum_type bignum, long word_length,
- int twos_complement_p)
- {
- unsigned int n_bits = (twos_complement_p ? (word_length - 1) : word_length);
- BIGNUM_ASSERT (n_bits > 0);
- {
- bignum_length_type length = (BIGNUM_LENGTH (bignum));
- bignum_length_type max_digits = (BIGNUM_BITS_TO_DIGITS (n_bits));
- bignum_digit_type msd, max;
- return
- ((length < max_digits) ||
- ((length == max_digits) &&
- ((((msd = (BIGNUM_REF (bignum, (length - 1)))) <
- (max = (1L << (n_bits - ((length - 1) * BIGNUM_DIGIT_LENGTH))))) ||
- (twos_complement_p &&
- (msd == max) &&
- (BIGNUM_NEGATIVE_P (bignum)))))));
- }
- }
- bignum_type
- s48_bignum_length_in_bits(bignum_type bignum)
- {
- if (BIGNUM_ZERO_P (bignum))
- return (BIGNUM_ZERO ());
- {
- bignum_length_type index = ((BIGNUM_LENGTH (bignum)) - 1);
- bignum_digit_type digit = (BIGNUM_REF (bignum, index));
- bignum_type result = (bignum_allocate (2, 0));
- (BIGNUM_REF (result, 0)) = index;
- (BIGNUM_REF (result, 1)) = 0;
- bignum_destructive_scale_up (result, BIGNUM_DIGIT_LENGTH);
- while (digit > 0)
- {
- bignum_destructive_add (result, ((bignum_digit_type) 1));
- digit >>= 1;
- }
- return (bignum_trim (result));
- }
- }
- bignum_type
- s48_bignum_length_upper_limit(void)
- {
- bignum_type result = (bignum_allocate (2, 0));
- (BIGNUM_REF (result, 0)) = 0;
- (BIGNUM_REF (result, 1)) = BIGNUM_DIGIT_LENGTH;
- return (result);
- }
- bignum_type
- s48_digit_stream_to_bignum(unsigned int n_digits,
- unsigned int (*producer)(bignum_procedure_context),
- bignum_procedure_context context,
- unsigned int radix,
- int negative_p)
- {
- BIGNUM_ASSERT ((radix > 1) && (radix <= BIGNUM_RADIX_ROOT));
- if (n_digits == 0)
- return (BIGNUM_ZERO ());
- if (n_digits == 1)
- {
- long digit = ((long) ((*producer) (context)));
- return (s48_long_to_bignum (negative_p ? (- digit) : digit));
- }
- {
- bignum_length_type length;
- {
- unsigned int radix_copy = radix;
- unsigned int log_radix = 0;
- while (radix_copy > 0)
- {
- radix_copy >>= 1;
- log_radix += 1;
- }
- /* This length will be at least as large as needed. */
- length = (BIGNUM_BITS_TO_DIGITS (n_digits * log_radix));
- }
- {
- bignum_type result = (bignum_allocate_zeroed (length, negative_p));
- while ((n_digits--) > 0)
- {
- bignum_destructive_scale_up (result, ((bignum_digit_type) radix));
- bignum_destructive_add
- (result, ((bignum_digit_type) ((*producer) (context))));
- }
- return (bignum_trim (result));
- }
- }
- }
- void
- s48_bignum_to_digit_stream(bignum_type bignum,
- unsigned int radix,
- void (*consumer)(bignum_procedure_context,
- bignum_digit_type),
- bignum_procedure_context context)
- {
- BIGNUM_ASSERT ((radix > 1) && (radix <= BIGNUM_RADIX_ROOT));
- if (! (BIGNUM_ZERO_P (bignum)))
- {
- bignum_type working_copy = (bignum_copy (bignum));
- bignum_digit_type * start = (BIGNUM_START_PTR (working_copy));
- bignum_digit_type * scan = (start + (BIGNUM_LENGTH (working_copy)));
- while (start < scan)
- {
- if ((scan[-1]) == 0)
- scan -= 1;
- else
- (*consumer)
- (context, (bignum_destructive_scale_down (working_copy, radix)));
- }
- BIGNUM_DEALLOCATE (working_copy);
- }
- return;
- }
- long
- s48_bignum_max_digit_stream_radix(void)
- {
- return (BIGNUM_RADIX_ROOT);
- }
- /* Comparisons */
- static int
- bignum_equal_p_unsigned(bignum_type x, bignum_type y)
- {
- bignum_length_type length = (BIGNUM_LENGTH (x));
- if (length != (BIGNUM_LENGTH (y)))
- return (0);
- else
- {
- bignum_digit_type * scan_x = (BIGNUM_START_PTR (x));
- bignum_digit_type * scan_y = (BIGNUM_START_PTR (y));
- bignum_digit_type * end_x = (scan_x + length);
- while (scan_x < end_x)
- if ((*scan_x++) != (*scan_y++))
- return (0);
- return (1);
- }
- }
- static enum bignum_comparison
- bignum_compare_unsigned(bignum_type x, bignum_type y)
- {
- bignum_length_type x_length = (BIGNUM_LENGTH (x));
- bignum_length_type y_length = (BIGNUM_LENGTH (y));
- if (x_length < y_length)
- return (bignum_comparison_less);
- if (x_length > y_length)
- return (bignum_comparison_greater);
- {
- bignum_digit_type * start_x = (BIGNUM_START_PTR (x));
- bignum_digit_type * scan_x = (start_x + x_length);
- bignum_digit_type * scan_y = ((BIGNUM_START_PTR (y)) + y_length);
- while (start_x < scan_x)
- {
- bignum_digit_type digit_x = (*--scan_x);
- bignum_digit_type digit_y = (*--scan_y);
- if (digit_x < digit_y)
- return (bignum_comparison_less);
- if (digit_x > digit_y)
- return (bignum_comparison_greater);
- }
- }
- return (bignum_comparison_equal);
- }
- /* Addition */
- static bignum_type
- bignum_add_unsigned(bignum_type x, bignum_type y, int negative_p)
- {
- if ((BIGNUM_LENGTH (y)) > (BIGNUM_LENGTH (x)))
- {
- bignum_type z = x;
- x = y;
- y = z;
- }
- {
- bignum_length_type x_length = (BIGNUM_LENGTH (x));
- bignum_type r = (bignum_allocate ((x_length + 1), negative_p));
- bignum_digit_type sum;
- bignum_digit_type carry = 0;
- bignum_digit_type * scan_x = (BIGNUM_START_PTR (x));
- bignum_digit_type * scan_r = (BIGNUM_START_PTR (r));
- {
- bignum_digit_type * scan_y = (BIGNUM_START_PTR (y));
- bignum_digit_type * end_y = (scan_y + (BIGNUM_LENGTH (y)));
- while (scan_y < end_y)
- {
- sum = ((*scan_x++) + (*scan_y++) + carry);
- if (sum < BIGNUM_RADIX)
- {
- (*scan_r++) = sum;
- carry = 0;
- }
- else
- {
- (*scan_r++) = (sum - BIGNUM_RADIX);
- carry = 1;
- }
- }
- }
- {
- bignum_digit_type * end_x = ((BIGNUM_START_PTR (x)) + x_length);
- if (carry != 0)
- while (scan_x < end_x)
- {
- sum = ((*scan_x++) + 1);
- if (sum < BIGNUM_RADIX)
- {
- (*scan_r++) = sum;
- carry = 0;
- break;
- }
- else
- (*scan_r++) = (sum - BIGNUM_RADIX);
- }
- while (scan_x < end_x)
- (*scan_r++) = (*scan_x++);
- }
- if (carry != 0)
- {
- (*scan_r) = 1;
- return (r);
- }
- return (bignum_shorten_length (r, x_length));
- }
- }
- /* Subtraction */
- static bignum_type
- bignum_subtract_unsigned(bignum_type x, bignum_type y)
- {
- int negative_p;
- switch (bignum_compare_unsigned (x, y))
- {
- case bignum_comparison_equal:
- return (BIGNUM_ZERO ());
- case bignum_comparison_less:
- {
- bignum_type z = x;
- x = y;
- y = z;
- }
- negative_p = 1;
- break;
- case bignum_comparison_greater:
- negative_p = 0;
- break;
- }
- {
- bignum_length_type x_length = (BIGNUM_LENGTH (x));
- bignum_type r = (bignum_allocate (x_length, negative_p));
- bignum_digit_type difference;
- bignum_digit_type borrow = 0;
- bignum_digit_type * scan_x = (BIGNUM_START_PTR (x));
- bignum_digit_type * scan_r = (BIGNUM_START_PTR (r));
- {
- bignum_digit_type * scan_y = (BIGNUM_START_PTR (y));
- bignum_digit_type * end_y = (scan_y + (BIGNUM_LENGTH (y)));
- while (scan_y < end_y)
- {
- difference = (((*scan_x++) - (*scan_y++)) - borrow);
- if (difference < 0)
- {
- (*scan_r++) = (difference + BIGNUM_RADIX);
- borrow = 1;
- }
- else
- {
- (*scan_r++) = difference;
- borrow = 0;
- }
- }
- }
- {
- bignum_digit_type * end_x = ((BIGNUM_START_PTR (x)) + x_length);
- if (borrow != 0)
- while (scan_x < end_x)
- {
- difference = ((*scan_x++) - borrow);
- if (difference < 0)
- (*scan_r++) = (difference + BIGNUM_RADIX);
- else
- {
- (*scan_r++) = difference;
- borrow = 0;
- break;
- }
- }
- BIGNUM_ASSERT (borrow == 0);
- while (scan_x < end_x)
- (*scan_r++) = (*scan_x++);
- }
- return (bignum_trim (r));
- }
- }
- /* Multiplication
- Maximum value for product_low or product_high:
- ((R * R) + (R * (R - 2)) + (R - 1))
- Maximum value for carry: ((R * (R - 1)) + (R - 1))
- where R == BIGNUM_RADIX_ROOT */
- static bignum_type
- bignum_multiply_unsigned(bignum_type x, bignum_type y, int negative_p)
- {
- if ((BIGNUM_LENGTH (y)) > (BIGNUM_LENGTH (x)))
- {
- bignum_type z = x;
- x = y;
- y = z;
- }
- {
- bignum_digit_type carry;
- bignum_digit_type y_digit_low;
- bignum_digit_type y_digit_high;
- bignum_digit_type x_digit_low;
- bignum_digit_type x_digit_high;
- bignum_digit_type product_low;
- bignum_digit_type * scan_r;
- bignum_digit_type * scan_y;
- bignum_length_type x_length = (BIGNUM_LENGTH (x));
- bignum_length_type y_length = (BIGNUM_LENGTH (y));
- bignum_type r =
- (bignum_allocate_zeroed ((x_length + y_length), negative_p));
- bignum_digit_type * scan_x = (BIGNUM_START_PTR (x));
- bignum_digit_type * end_x = (scan_x + x_length);
- bignum_digit_type * start_y = (BIGNUM_START_PTR (y));
- bignum_digit_type * end_y = (start_y + y_length);
- bignum_digit_type * start_r = (BIGNUM_START_PTR (r));
- #define x_digit x_digit_high
- #define y_digit y_digit_high
- #define product_high carry
- while (scan_x < end_x)
- {
- x_digit = (*scan_x++);
- x_digit_low = (HD_LOW (x_digit));
- x_digit_high = (HD_HIGH (x_digit));
- carry = 0;
- scan_y = start_y;
- scan_r = (start_r++);
- while (scan_y < end_y)
- {
- y_digit = (*scan_y++);
- y_digit_low = (HD_LOW (y_digit));
- y_digit_high = (HD_HIGH (y_digit));
- product_low =
- ((*scan_r) +
- (x_digit_low * y_digit_low) +
- (HD_LOW (carry)));
- product_high =
- ((x_digit_high * y_digit_low) +
- (x_digit_low * y_digit_high) +
- (HD_HIGH (product_low)) +
- (HD_HIGH (carry)));
- (*scan_r++) =
- (HD_CONS ((HD_LOW (product_high)), (HD_LOW (product_low))));
- carry =
- ((x_digit_high * y_digit_high) +
- (HD_HIGH (product_high)));
- }
- (*scan_r) += carry;
- }
- return (bignum_trim (r));
- #undef x_digit
- #undef y_digit
- #undef product_high
- }
- }
- static bignum_type
- bignum_multiply_unsigned_small_factor(bignum_type x, bignum_digit_type y,
- int negative_p)
- {
- bignum_length_type length_x = (BIGNUM_LENGTH (x));
- bignum_type p = (bignum_allocate ((length_x + 1), negative_p));
- bignum_destructive_copy (x, p);
- (BIGNUM_REF (p, length_x)) = 0;
- bignum_destructive_scale_up (p, y);
- return (bignum_trim (p));
- }
- static void
- bignum_destructive_scale_up(bignum_type bignum, bignum_digit_type factor)
- {
- bignum_digit_type carry = 0;
- bignum_digit_type * scan = (BIGNUM_START_PTR (bignum));
- bignum_digit_type two_digits;
- bignum_digit_type product_low;
- #define product_high carry
- bignum_digit_type * end = (scan + (BIGNUM_LENGTH (bignum)));
- BIGNUM_ASSERT ((factor > 1) && (factor < BIGNUM_RADIX_ROOT));
- while (scan < end)
- {
- two_digits = (*scan);
- product_low = ((factor * (HD_LOW (two_digits))) + (HD_LOW (carry)));
- product_high =
- ((factor * (HD_HIGH (two_digits))) +
- (HD_HIGH (product_low)) +
- (HD_HIGH (carry)));
- (*scan++) = (HD_CONS ((HD_LOW (product_high)), (HD_LOW (product_low))));
- carry = (HD_HIGH (product_high));
- }
- /* A carry here would be an overflow, i.e. it would not fit.
- Hopefully the callers allocate enough space that this will
- never happen.
- */
- BIGNUM_ASSERT (carry == 0);
- return;
- #undef product_high
- }
- static void
- bignum_destructive_add(bignum_type bignum, bignum_digit_type n)
- {
- bignum_digit_type * scan = (BIGNUM_START_PTR (bignum));
- bignum_digit_type digit;
- digit = ((*scan) + n);
- if (digit < BIGNUM_RADIX)
- {
- (*scan) = digit;
- return;
- }
- (*scan++) = (digit - BIGNUM_RADIX);
- while (1)
- {
- digit = ((*scan) + 1);
- if (digit < BIGNUM_RADIX)
- {
- (*scan) = digit;
- return;
- }
- (*scan++) = (digit - BIGNUM_RADIX);
- }
- }
- /* Division */
- /* For help understanding this algorithm, see:
- Knuth, Donald E., "The Art of Computer Programming",
- volume 2, "Seminumerical Algorithms"
- section 4.3.1, "Multiple-Precision Arithmetic". */
- static void
- bignum_divide_unsigned_large_denominator(bignum_type numerator,
- bignum_type denominator,
- bignum_type * quotient,
- bignum_type * remainder,
- int q_negative_p,
- int r_negative_p)
- {
- bignum_length_type length_n = ((BIGNUM_LENGTH (numerator)) + 1);
- bignum_length_type length_d = (BIGNUM_LENGTH (denominator));
- bignum_type q =
- ((quotient != ((bignum_type *) 0))
- ? (bignum_allocate ((length_n - length_d), q_negative_p))
- : BIGNUM_OUT_OF_BAND);
- bignum_type u = (bignum_allocate (length_n, r_negative_p));
- int shift = 0;
- BIGNUM_ASSERT (length_d > 1);
- {
- bignum_digit_type v1 = (BIGNUM_REF ((denominator), (length_d - 1)));
- while (v1 < (BIGNUM_RADIX / 2))
- {
- v1 <<= 1;
- shift += 1;
- }
- }
- if (shift == 0)
- {
- bignum_destructive_copy (numerator, u);
- (BIGNUM_REF (u, (length_n - 1))) = 0;
- bignum_divide_unsigned_normalized (u, denominator, q);
- }
- else
- {
- bignum_type v = (bignum_allocate (length_d, 0));
- bignum_destructive_normalization (numerator, u, shift);
- bignum_destructive_normalization (denominator, v, shift);
- bignum_divide_unsigned_normalized (u, v, q);
- BIGNUM_DEALLOCATE (v);
- if (remainder != ((bignum_type *) 0))
- bignum_destructive_unnormalization (u, shift);
- }
- if (quotient != ((bignum_type *) 0))
- (*quotient) = (bignum_trim (q));
- if (remainder != ((bignum_type *) 0))
- (*remainder) = (bignum_trim (u));
- else
- BIGNUM_DEALLOCATE (u);
- return;
- }
- static void
- bignum_divide_unsigned_normalized(bignum_type u, bignum_type v, bignum_type q)
- {
- bignum_length_type u_length = (BIGNUM_LENGTH (u));
- bignum_length_type v_length = (BIGNUM_LENGTH (v));
- bignum_digit_type * u_start = (BIGNUM_START_PTR (u));
- bignum_digit_type * u_scan = (u_start + u_length);
- bignum_digit_type * u_scan_limit = (u_start + v_length);
- bignum_digit_type * u_scan_start = (u_scan - v_length);
- bignum_digit_type * v_start = (BIGNUM_START_PTR (v));
- bignum_digit_type * v_end = (v_start + v_length);
- bignum_digit_type * q_scan;
- bignum_digit_type v1 = (v_end[-1]);
- bignum_digit_type v2 = (v_end[-2]);
- bignum_digit_type ph; /* high half of double-digit product */
- bignum_digit_type pl; /* low half of double-digit product */
- bignum_digit_type guess;
- bignum_digit_type gh; /* high half-digit of guess */
- bignum_digit_type ch; /* high half of double-digit comparand */
- bignum_digit_type v2l = (HD_LOW (v2));
- bignum_digit_type v2h = (HD_HIGH (v2));
- bignum_digit_type cl; /* low half of double-digit comparand */
- #define gl ph /* low half-digit of guess */
- #define uj pl
- #define qj ph
- bignum_digit_type gm; /* memory loc for reference parameter */
- if (q != BIGNUM_OUT_OF_BAND)
- q_scan = ((BIGNUM_START_PTR (q)) + (BIGNUM_LENGTH (q)));
- while (u_scan_limit < u_scan)
- {
- uj = (*--u_scan);
- if (uj != v1)
- {
- /* comparand =
- (((((uj * BIGNUM_RADIX) + uj1) % v1) * BIGNUM_RADIX) + uj2);
- guess = (((uj * BIGNUM_RADIX) + uj1) / v1); */
- cl = (u_scan[-2]);
- ch = (bignum_digit_divide (uj, (u_scan[-1]), v1, (&gm)));
- guess = gm;
- }
- else
- {
- cl = (u_scan[-2]);
- ch = ((u_scan[-1]) + v1);
- guess = (BIGNUM_RADIX - 1);
- }
- while (1)
- {
- /* product = (guess * v2); */
- gl = (HD_LOW (guess));
- gh = (HD_HIGH (guess));
- pl = (v2l * gl);
- ph = ((v2l * gh) + (v2h * gl) + (HD_HIGH (pl)));
- pl = (HD_CONS ((HD_LOW (ph)), (HD_LOW (pl))));
- ph = ((v2h * gh) + (HD_HIGH (ph)));
- /* if (comparand >= product) */
- if ((ch > ph) || ((ch == ph) && (cl >= pl)))
- break;
- guess -= 1;
- /* comparand += (v1 << BIGNUM_DIGIT_LENGTH) */
- ch += v1;
- /* if (comparand >= (BIGNUM_RADIX * BIGNUM_RADIX)) */
- if (ch >= BIGNUM_RADIX)
- break;
- }
- qj = (bignum_divide_subtract (v_start, v_end, guess, (--u_scan_start)));
- if (q != BIGNUM_OUT_OF_BAND)
- (*--q_scan) = qj;
- }
- return;
- #undef gl
- #undef uj
- #undef qj
- }
- static bignum_digit_type
- bignum_divide_subtract(bignum_digit_type * v_start,
- bignum_digit_type * v_end,
- bignum_digit_type guess,
- bignum_digit_type * u_start)
- {
- bignum_digit_type * v_scan = v_start;
- bignum_digit_type * u_scan = u_start;
- bignum_digit_type carry = 0;
- if (guess == 0) return (0);
- {
- bignum_digit_type gl = (HD_LOW (guess));
- bignum_digit_type gh = (HD_HIGH (guess));
- bignum_digit_type v;
- bignum_digit_type pl;
- bignum_digit_type vl;
- #define vh v
- #define ph carry
- #define diff pl
- while (v_scan < v_end)
- {
- v = (*v_scan++);
- vl = (HD_LOW (v));
- vh = (HD_HIGH (v));
- pl = ((vl * gl) + (HD_LOW (carry)));
- ph = ((vl * gh) + (vh * gl) + (HD_HIGH (pl)) + (HD_HIGH (carry)));
- diff = ((*u_scan) - (HD_CONS ((HD_LOW (ph)), (HD_LOW (pl)))));
- if (diff < 0)
- {
- (*u_scan++) = (diff + BIGNUM_RADIX);
- carry = ((vh * gh) + (HD_HIGH (ph)) + 1);
- }
- else
- {
- (*u_scan++) = diff;
- carry = ((vh * gh) + (HD_HIGH (ph)));
- }
- }
- if (carry == 0)
- return (guess);
- diff = ((*u_scan) - carry);
- if (diff < 0)
- (*u_scan) = (diff + BIGNUM_RADIX);
- else
- {
- (*u_scan) = diff;
- return (guess);
- }
- #undef vh
- #undef ph
- #undef diff
- }
- /* Subtraction generated carry, implying guess is one too large.
- Add v back in to bring it back down. */
- v_scan = v_start;
- u_scan = u_start;
- carry = 0;
- while (v_scan < v_end)
- {
- bignum_digit_type sum = ((*v_scan++) + (*u_scan) + carry);
- if (sum < BIGNUM_RADIX)
- {
- (*u_scan++) = sum;
- carry = 0;
- }
- else
- {
- (*u_scan++) = (sum - BIGNUM_RADIX);
- carry = 1;
- }
- }
- if (carry == 1)
- {
- bignum_digit_type sum = ((*u_scan) + carry);
- (*u_scan) = ((sum < BIGNUM_RADIX) ? sum : (sum - BIGNUM_RADIX));
- }
- return (guess - 1);
- }
- static void
- bignum_divide_unsigned_medium_denominator(bignum_type numerator,
- bignum_digit_type denominator,
- bignum_type * quotient,
- bignum_type * remainder,
- int q_negative_p,
- int r_negative_p)
- {
- bignum_length_type length_n = (BIGNUM_LENGTH (numerator));
- bignum_length_type length_q;
- bignum_type q;
- int shift = 0;
- /* Because `bignum_digit_divide' requires a normalized denominator. */
- while (denominator < (BIGNUM_RADIX / 2))
- {
- denominator <<= 1;
- shift += 1;
- }
- if (shift == 0)
- {
- length_q = length_n;
- q = (bignum_allocate (length_q, q_negative_p));
- bignum_destructive_copy (numerator, q);
- }
- else
- {
- length_q = (length_n + 1);
- q = (bignum_allocate (length_q, q_negative_p));
- bignum_destructive_normalization (numerator, q, shift);
- }
- {
- bignum_digit_type r = 0;
- bignum_digit_type * start = (BIGNUM_START_PTR (q));
- bignum_digit_type * scan = (start + length_q);
- bignum_digit_type qj;
- if (quotient != ((bignum_type *) 0))
- {
- while (start < scan)
- {
- r = (bignum_digit_divide (r, (*--scan), denominator, (&qj)));
- (*scan) = qj;
- }
- (*quotient) = (bignum_trim (q));
- }
- else
- {
- while (start < scan)
- r = (bignum_digit_divide (r, (*--scan), denominator, (&qj)));
- BIGNUM_DEALLOCATE (q);
- }
- if (remainder != ((bignum_type *) 0))
- {
- if (shift != 0)
- r >>= shift;
- (*remainder) = (bignum_digit_to_bignum (r, r_negative_p));
- }
- }
- return;
- }
- static void
- bignum_destructive_normalization(bignum_type source, bignum_type target,
- int shift_left)
- {
- bignum_digit_type digit;
- bignum_digit_type * scan_source = (BIGNUM_START_PTR (source));
- bignum_digit_type carry = 0;
- bignum_digit_type * scan_target = (BIGNUM_START_PTR (target));
- bignum_digit_type * end_source = (scan_source + (BIGNUM_LENGTH (source)));
- bignum_digit_type * end_target = (scan_target + (BIGNUM_LENGTH (target)));
- int shift_right = (BIGNUM_DIGIT_LENGTH - shift_left);
- bignum_digit_type mask = ((1L << shift_right) - 1);
- while (scan_source < end_source)
- {
- digit = (*scan_source++);
- (*scan_target++) = (((digit & mask) << shift_left) | carry);
- carry = (digit >> shift_right);
- }
- if (scan_target < end_target)
- (*scan_target) = carry;
- else
- BIGNUM_ASSERT (carry == 0);
- return;
- }
- static void
- bignum_destructive_unnormalization(bignum_type bignum, int shift_right)
- {
- bignum_digit_type * start = (BIGNUM_START_PTR (bignum));
- bignum_digit_type * scan = (start + (BIGNUM_LENGTH (bignum)));
- bignum_digit_type digit;
- bignum_digit_type carry = 0;
- int shift_left = (BIGNUM_DIGIT_LENGTH - shift_right);
- bignum_digit_type mask = ((1L << shift_right) - 1);
- while (start < scan)
- {
- digit = (*--scan);
- (*scan) = ((digit >> shift_right) | carry);
- carry = ((digit & mask) << shift_left);
- }
- BIGNUM_ASSERT (carry == 0);
- return;
- }
- /* This is a reduced version of the division algorithm, applied to the
- case of dividing two bignum digits by one bignum digit. It is
- assumed that the numerator, denominator are normalized. */
- #define BDD_STEP(qn, j) \
- { \
- uj = (u[j]); \
- if (uj != v1) \
- { \
- uj_uj1 = (HD_CONS (uj, (u[j + 1]))); \
- guess = (uj_uj1 / v1); \
- comparand = (HD_CONS ((uj_uj1 % v1), (u[j + 2]))); \
- } \
- else \
- { \
- guess = (BIGNUM_RADIX_ROOT - 1); \
- comparand = (HD_CONS (((u[j + 1]) + v1), (u[j + 2]))); \
- } \
- while ((guess * v2) > comparand) \
- { \
- guess -= 1; \
- comparand += (v1 << BIGNUM_HALF_DIGIT_LENGTH); \
- if (comparand >= BIGNUM_RADIX) \
- break; \
- } \
- qn = (bignum_digit_divide_subtract (v1, v2, guess, (&u[j]))); \
- }
- static bignum_digit_type
- bignum_digit_divide(bignum_digit_type uh, bignum_digit_type ul,
- bignum_digit_type v,
- bignum_digit_type * q) /* return value */
- {
- bignum_digit_type guess;
- bignum_digit_type comparand;
- bignum_digit_type v1 = (HD_HIGH (v));
- bignum_digit_type v2 = (HD_LOW (v));
- bignum_digit_type uj;
- bignum_digit_type uj_uj1;
- bignum_digit_type q1;
- bignum_digit_type q2;
- bignum_digit_type u [4];
- if (uh == 0)
- {
- if (ul < v)
- {
- (*q) = 0;
- return (ul);
- }
- else if (ul == v)
- {
- (*q) = 1;
- return (0);
- }
- }
- (u[0]) = (HD_HIGH (uh));
- (u[1]) = (HD_LOW (uh));
- (u[2]) = (HD_HIGH (ul));
- (u[3]) = (HD_LOW (ul));
- v1 = (HD_HIGH (v));
- v2 = (HD_LOW (v));
- BDD_STEP (q1, 0);
- BDD_STEP (q2, 1);
- (*q) = (HD_CONS (q1, q2));
- return (HD_CONS ((u[2]), (u[3])));
- }
- #undef BDD_STEP
- #define BDDS_MULSUB(vn, un, carry_in) \
- { \
- product = ((vn * guess) + carry_in); \
- diff = (un - (HD_LOW (product))); \
- if (diff < 0) \
- { \
- un = (diff + BIGNUM_RADIX_ROOT); \
- carry = ((HD_HIGH (product)) + 1); \
- } \
- else \
- { \
- un = diff; \
- carry = (HD_HIGH (product)); \
- } \
- }
- #define BDDS_ADD(vn, un, carry_in) \
- { \
- sum = (vn + un + carry_in); \
- if (sum < BIGNUM_RADIX_ROOT) \
- { \
- un = sum; \
- carry = 0; \
- } \
- else \
- { \
- un = (sum - BIGNUM_RADIX_ROOT); \
- carry = 1; \
- } \
- }
- static bignum_digit_type
- bignum_digit_divide_subtract(bignum_digit_type v1, bignum_digit_type v2,
- bignum_digit_type guess, bignum_digit_type * u)
- {
- {
- bignum_digit_type product;
- bignum_digit_type diff;
- bignum_digit_type carry;
- BDDS_MULSUB (v2, (u[2]), 0);
- BDDS_MULSUB (v1, (u[1]), carry);
- if (carry == 0)
- return (guess);
- diff = ((u[0]) - carry);
- if (diff < 0)
- (u[0]) = (diff + BIGNUM_RADIX);
- else
- {
- (u[0]) = diff;
- return (guess);
- }
- }
- {
- bignum_digit_type sum;
- bignum_digit_type carry;
- BDDS_ADD(v2, (u[2]), 0);
- BDDS_ADD(v1, (u[1]), carry);
- if (carry == 1)
- (u[0]) += 1;
- }
- return (guess - 1);
- }
- #undef BDDS_MULSUB
- #undef BDDS_ADD
- static void
- bignum_divide_unsigned_small_denominator(bignum_type numerator,
- bignum_digit_type denominator,
- bignum_type * quotient,
- bignum_type * remainder,
- int q_negative_p,
- int r_negative_p)
- {
- bignum_type q = (bignum_new_sign (numerator, q_negative_p));
- bignum_digit_type r = (bignum_destructive_scale_down (q, denominator));
- (*quotient) = (bignum_trim (q));
- if (remainder != ((bignum_type *) 0))
- (*remainder) = (bignum_digit_to_bignum (r, r_negative_p));
- return;
- }
- /* Given (denominator > 1), it is fairly easy to show that
- (quotient_high < BIGNUM_RADIX_ROOT), after which it is easy to see
- that all digits are < BIGNUM_RADIX. */
- static bignum_digit_type
- bignum_destructive_scale_down(bignum_type bignum, bignum_digit_type denominator)
- {
- bignum_digit_type numerator;
- bignum_digit_type remainder = 0;
- bignum_digit_type two_digits;
- #define quotient_high remainder
- bignum_digit_type * start = (BIGNUM_START_PTR (bignum));
- bignum_digit_type * scan = (start + (BIGNUM_LENGTH (bignum)));
- BIGNUM_ASSERT ((denominator > 1) && (denominator < BIGNUM_RADIX_ROOT));
- while (start < scan)
- {
- two_digits = (*--scan);
- numerator = (HD_CONS (remainder, (HD_HIGH (two_digits))));
- quotient_high = (numerator / denominator);
- numerator = (HD_CONS ((numerator % denominator), (HD_LOW (two_digits))));
- (*scan) = (HD_CONS (quotient_high, (numerator / denominator)));
- remainder = (numerator % denominator);
- }
- return (remainder);
- #undef quotient_high
- }
- static bignum_type
- bignum_remainder_unsigned_small_denominator(
- bignum_type n, bignum_digit_type d, int negative_p)
- {
- bignum_digit_type two_digits;
- bignum_digit_type * start = (BIGNUM_START_PTR (n));
- bignum_digit_type * scan = (start + (BIGNUM_LENGTH (n)));
- bignum_digit_type r = 0;
- BIGNUM_ASSERT ((d > 1) && (d < BIGNUM_RADIX_ROOT));
- while (start < scan)
- {
- two_digits = (*--scan);
- r =
- ((HD_CONS (((HD_CONS (r, (HD_HIGH (two_digits)))) % d),
- (HD_LOW (two_digits))))
- % d);
- }
- return (bignum_digit_to_bignum (r, negative_p));
- }
- static bignum_type
- bignum_digit_to_bignum(bignum_digit_type digit, int negative_p)
- {
- if (digit == 0)
- return (BIGNUM_ZERO ());
- else
- {
- bignum_type result = (bignum_allocate (1, negative_p));
- (BIGNUM_REF (result, 0)) = digit;
- return (result);
- }
- }
- /* Allocation */
- static bignum_type
- bignum_allocate(bignum_length_type length, int negative_p)
- {
- BIGNUM_ASSERT ((length >= 0) || (length < BIGNUM_RADIX));
- {
- bignum_type result = (BIGNUM_ALLOCATE (length));
- BIGNUM_SET_HEADER (result, length, negative_p);
- return (result);
- }
- }
- static bignum_type
- bignum_allocate_zeroed(bignum_length_type length, int negative_p)
- {
- BIGNUM_ASSERT ((length >= 0) || (length < BIGNUM_RADIX));
- {
- bignum_type result = (BIGNUM_ALLOCATE (length));
- bignum_digit_type * scan = (BIGNUM_START_PTR (result));
- bignum_digit_type * end = (scan + length);
- BIGNUM_SET_HEADER (result, length, negative_p);
- while (scan < end)
- (*scan++) = 0;
- return (result);
- }
- }
- static bignum_type
- bignum_shorten_length(bignum_type bignum, bignum_length_type length)
- {
- bignum_length_type current_length = (BIGNUM_LENGTH (bignum));
- BIGNUM_ASSERT ((length >= 0) || (length <= current_length));
- if (length < current_length)
- {
- BIGNUM_SET_HEADER
- (bignum, length, ((length != 0) && (BIGNUM_NEGATIVE_P (bignum))));
- BIGNUM_REDUCE_LENGTH (bignum, bignum, length);
- }
- return (bignum);
- }
- static bignum_type
- bignum_trim(bignum_type bignum)
- {
- bignum_digit_type * start = (BIGNUM_START_PTR (bignum));
- bignum_digit_type * end = (start + (BIGNUM_LENGTH (bignum)));
- bignum_digit_type * scan = end;
- while ((start <= scan) && ((*--scan) == 0))
- ;
- scan += 1;
- if (scan < end)
- {
- bignum_length_type length = (scan - start);
- BIGNUM_SET_HEADER
- (bignum, length, ((length != 0) && (BIGNUM_NEGATIVE_P (bignum))));
- BIGNUM_REDUCE_LENGTH (bignum, bignum, length);
- }
- return (bignum);
- }
- /* Copying */
- static bignum_type
- bignum_copy(bignum_type source)
- {
- bignum_type target =
- (bignum_allocate ((BIGNUM_LENGTH (source)), (BIGNUM_NEGATIVE_P (source))));
- bignum_destructive_copy (source, target);
- return (target);
- }
- static bignum_type
- bignum_new_sign(bignum_type bignum, int negative_p)
- {
- bignum_type result =
- (bignum_allocate ((BIGNUM_LENGTH (bignum)), negative_p));
- bignum_destructive_copy (bignum, result);
- return (result);
- }
- static bignum_type
- bignum_maybe_new_sign(bignum_type bignum, int negative_p)
- {
- #ifndef BIGNUM_FORCE_NEW_RESULTS
- if ((BIGNUM_NEGATIVE_P (bignum)) ? negative_p : (! negative_p))
- return (bignum);
- else
- #endif /* not BIGNUM_FORCE_NEW_RESULTS */
- {
- bignum_type result =
- (bignum_allocate ((BIGNUM_LENGTH (bignum)), negative_p));
- bignum_destructive_copy (bignum, result);
- return (result);
- }
- }
- static void
- bignum_destructive_copy(bignum_type source, bignum_type target)
- {
- bignum_digit_type * scan_source = (BIGNUM_START_PTR (source));
- bignum_digit_type * end_source =
- (scan_source + (BIGNUM_LENGTH (source)));
- bignum_digit_type * scan_target = (BIGNUM_START_PTR (target));
- while (scan_source < end_source)
- (*scan_target++) = (*scan_source++);
- return;
- }
- /* Unused
- static void
- bignum_destructive_zero(bignum_type bignum)
- {
- bignum_digit_type * scan = (BIGNUM_START_PTR (bignum));
- bignum_digit_type * end = (scan + (BIGNUM_LENGTH (bignum)));
- while (scan < end)
- (*scan++) = 0;
- return;
- }
- */
- /*
- * Added bitwise operations (and oddp).
- */
- int
- s48_bignum_oddp (bignum_type bignum)
- {
- return (BIGNUM_LENGTH (bignum) > 0) && (BIGNUM_REF (bignum, 0) & 1);
- }
- bignum_type
- s48_bignum_bitwise_not(bignum_type x)
- {
- return s48_bignum_subtract(BIGNUM_ONE(1), x);
- }
- bignum_type
- s48_bignum_arithmetic_shift(bignum_type arg1, long n)
- {
- if (BIGNUM_NEGATIVE_P(arg1) && n < 0)
- return
- s48_bignum_bitwise_not(bignum_magnitude_ash(s48_bignum_bitwise_not(arg1),
- n));
- else
- return bignum_magnitude_ash(arg1, n);
- }
- /*
- * This uses a `long'-returning bignum_length_in_bits() which we don't have.
- long
- s48_bignum_integer_length(bignum_type arg1)
- {
- return((BIGNUM_NEGATIVE_P (arg1))
- ? bignum_length_in_bits (s48_bignum_bitwise_not (arg1))
- : bignum_length_in_bits (arg1));
- }
- */
- long
- s48_bignum_bit_count(bignum_type arg1)
- {
- return((BIGNUM_NEGATIVE_P (arg1))
- ? bignum_unsigned_logcount (s48_bignum_bitwise_not (arg1))
- : bignum_unsigned_logcount (arg1));
- }
- #define AND_OP 0
- #define IOR_OP 1
- #define XOR_OP 2
- bignum_type
- s48_bignum_bitwise_and(bignum_type arg1, bignum_type arg2)
- {
- return(
- (BIGNUM_NEGATIVE_P (arg1))
- ? (BIGNUM_NEGATIVE_P (arg2))
- ? bignum_negneg_bitwise_op(AND_OP, arg1, arg2)
- : bignum_posneg_bitwise_op(AND_OP, arg2, arg1)
- : (BIGNUM_NEGATIVE_P (arg2))
- ? bignum_posneg_bitwise_op(AND_OP, arg1, arg2)
- : bignum_pospos_bitwise_op(AND_OP, arg1, arg2)
- );
- }
- bignum_type
- s48_bignum_bitwise_ior(bignum_type arg1, bignum_type arg2)
- {
- return(
- (BIGNUM_NEGATIVE_P (arg1))
- ? (BIGNUM_NEGATIVE_P (arg2))
- ? bignum_negneg_bitwise_op(IOR_OP, arg1, arg2)
- : bignum_posneg_bitwise_op(IOR_OP, arg2, arg1)
- : (BIGNUM_NEGATIVE_P (arg2))
- ? bignum_posneg_bitwise_op(IOR_OP, arg1, arg2)
- : bignum_pospos_bitwise_op(IOR_OP, arg1, arg2)
- );
- }
- bignum_type
- s48_bignum_bitwise_xor(bignum_type arg1, bignum_type arg2)
- {
- return(
- (BIGNUM_NEGATIVE_P (arg1))
- ? (BIGNUM_NEGATIVE_P (arg2))
- ? bignum_negneg_bitwise_op(XOR_OP, arg1, arg2)
- : bignum_posneg_bitwise_op(XOR_OP, arg2, arg1)
- : (BIGNUM_NEGATIVE_P (arg2))
- ? bignum_posneg_bitwise_op(XOR_OP, arg1, arg2)
- : bignum_pospos_bitwise_op(XOR_OP, arg1, arg2)
- );
- }
- /* ash for the magnitude */
- /* assume arg1 is a big number, n is a long */
- static bignum_type
- bignum_magnitude_ash(bignum_type arg1, long n)
- {
- bignum_type result;
- bignum_digit_type *scan1;
- bignum_digit_type *scanr;
- bignum_digit_type *end;
- long digit_offset,bit_offset;
- if (BIGNUM_ZERO_P (arg1)) return (arg1);
- if (n > 0) {
- digit_offset = n / BIGNUM_DIGIT_LENGTH;
- bit_offset = n % BIGNUM_DIGIT_LENGTH;
-
- result = bignum_allocate_zeroed (BIGNUM_LENGTH (arg1) + digit_offset + 1,
- BIGNUM_NEGATIVE_P(arg1));
- scanr = BIGNUM_START_PTR (result) + digit_offset;
- scan1 = BIGNUM_START_PTR (arg1);
- end = scan1 + BIGNUM_LENGTH (arg1);
-
- while (scan1 < end) {
- *scanr = *scanr | (*scan1 & BIGNUM_DIGIT_MASK) << bit_offset;
- *scanr = *scanr & BIGNUM_DIGIT_MASK;
- scanr++;
- *scanr = *scan1++ >> (BIGNUM_DIGIT_LENGTH - bit_offset);
- *scanr = *scanr & BIGNUM_DIGIT_MASK;
- }
- }
- else if (n < 0
- && (-n >= (BIGNUM_LENGTH (arg1) * (bignum_length_type) BIGNUM_DIGIT_LENGTH)))
- result = BIGNUM_ZERO ();
- else if (n < 0) {
- digit_offset = -n / BIGNUM_DIGIT_LENGTH;
- bit_offset = -n % BIGNUM_DIGIT_LENGTH;
-
- result = bignum_allocate_zeroed (BIGNUM_LENGTH (arg1) - digit_offset,
- BIGNUM_NEGATIVE_P(arg1));
-
- scanr = BIGNUM_START_PTR (result);
- scan1 = BIGNUM_START_PTR (arg1) + digit_offset;
- end = scanr + BIGNUM_LENGTH (result) - 1;
-
- while (scanr < end) {
- *scanr = (*scan1++ & BIGNUM_DIGIT_MASK) >> bit_offset ;
- *scanr = (*scanr |
- *scan1 << (BIGNUM_DIGIT_LENGTH - bit_offset)) & BIGNUM_DIGIT_MASK;
- scanr++;
- }
- *scanr = (*scan1++ & BIGNUM_DIGIT_MASK) >> bit_offset ;
- }
- else if (n == 0) result = arg1;
-
- return (bignum_trim (result));
- }
- static bignum_type
- bignum_pospos_bitwise_op(int op, bignum_type arg1, bignum_type arg2)
- {
- bignum_type result;
- bignum_length_type max_length;
- bignum_digit_type *scan1, *end1, digit1;
- bignum_digit_type *scan2, *end2, digit2;
- bignum_digit_type *scanr, *endr;
- max_length = (BIGNUM_LENGTH(arg1) > BIGNUM_LENGTH(arg2))
- ? BIGNUM_LENGTH(arg1) : BIGNUM_LENGTH(arg2);
- result = bignum_allocate(max_length, 0);
- scanr = BIGNUM_START_PTR(result);
- scan1 = BIGNUM_START_PTR(arg1);
- scan2 = BIGNUM_START_PTR(arg2);
- endr = scanr + max_length;
- end1 = scan1 + BIGNUM_LENGTH(arg1);
- end2 = scan2 + BIGNUM_LENGTH(arg2);
- while (scanr < endr) {
- digit1 = (scan1 < end1) ? *scan1++ : 0;
- digit2 = (scan2 < end2) ? *scan2++ : 0;
- /*
- fprintf(stderr, "[pospos op = %d, i = %ld, d1 = %lx, d2 = %lx]\n",
- op, endr - scanr, digit1, digit2);
- */
- *scanr++ = (op == 0) ? digit1 & digit2 :
- (op == 1) ? digit1 | digit2 :
- digit1 ^ digit2;
- }
- return bignum_trim(result);
- }
- static bignum_type
- bignum_posneg_bitwise_op(int op, bignum_type arg1, bignum_type arg2)
- {
- bignum_type result;
- bignum_length_type max_length;
- bignum_digit_type *scan1, *end1, digit1;
- bignum_digit_type *scan2, *end2, digit2, carry2;
- bignum_digit_type *scanr, *endr;
- char neg_p = op == IOR_OP || op == XOR_OP;
- max_length = (BIGNUM_LENGTH(arg1) > BIGNUM_LENGTH(arg2) + 1)
- ? BIGNUM_LENGTH(arg1) : BIGNUM_LENGTH(arg2) + 1;
- result = bignum_allocate(max_length, neg_p);
- scanr = BIGNUM_START_PTR(result);
- scan1 = BIGNUM_START_PTR(arg1);
- scan2 = BIGNUM_START_PTR(arg2);
- endr = scanr + max_length;
- end1 = scan1 + BIGNUM_LENGTH(arg1);
- end2 = scan2 + BIGNUM_LENGTH(arg2);
- carry2 = 1;
- while (scanr < endr) {
- digit1 = (scan1 < end1) ? *scan1++ : 0;
- digit2 = (~((scan2 < end2) ? *scan2++ : 0) & BIGNUM_DIGIT_MASK)
- + carry2;
- if (digit2 < BIGNUM_RADIX)
- carry2 = 0;
- else
- {
- digit2 = (digit2 - BIGNUM_RADIX);
- carry2 = 1;
- }
-
- *scanr++ = (op == AND_OP) ? digit1 & digit2 :
- (op == IOR_OP) ? digit1 | digit2 :
- digit1 ^ digit2;
- }
-
- if (neg_p)
- bignum_negate_magnitude(result);
- return bignum_trim(result);
- }
- static bignum_type
- bignum_negneg_bitwise_op(int op, bignum_type arg1, bignum_type arg2)
- {
- bignum_type result;
- bignum_length_type max_length;
- bignum_digit_type *scan1, *end1, digit1, carry1;
- bignum_digit_type *scan2, *end2, digit2, carry2;
- bignum_digit_type *scanr, *endr;
- char neg_p = op == AND_OP || op == IOR_OP;
- max_length = (BIGNUM_LENGTH(arg1) > BIGNUM_LENGTH(arg2))
- ? BIGNUM_LENGTH(arg1) + 1 : BIGNUM_LENGTH(arg2) + 1;
- result = bignum_allocate(max_length, neg_p);
- scanr = BIGNUM_START_PTR(result);
- scan1 = BIGNUM_START_PTR(arg1);
- scan2 = BIGNUM_START_PTR(arg2);
- endr = scanr + max_length;
- end1 = scan1 + BIGNUM_LENGTH(arg1);
- end2 = scan2 + BIGNUM_LENGTH(arg2);
- carry1 = 1;
- carry2 = 1;
- while (scanr < endr) {
- digit1 = (~((scan1 < end1) ? *scan1++ : 0) & BIGNUM_DIGIT_MASK) + carry1;
- digit2 = (~((scan2 < end2) ? *scan2++ : 0) & BIGNUM_DIGIT_MASK) + carry2;
- if (digit1 < BIGNUM_RADIX)
- carry1 = 0;
- else
- {
- digit1 = (digit1 - BIGNUM_RADIX);
- carry1 = 1;
- }
-
- if (digit2 < BIGNUM_RADIX)
- carry2 = 0;
- else
- {
- digit2 = (digit2 - BIGNUM_RADIX);
- carry2 = 1;
- }
-
- *scanr++ = (op == 0) ? digit1 & digit2 :
- (op == 1) ? digit1 | digit2 :
- digit1 ^ digit2;
- }
- if (neg_p)
- bignum_negate_magnitude(result);
- return bignum_trim(result);
- }
- static void
- bignum_negate_magnitude(bignum_type arg)
- {
- bignum_digit_type *scan;
- bignum_digit_type *end;
- bignum_digit_type digit;
- bignum_digit_type carry;
- scan = BIGNUM_START_PTR(arg);
- end = scan + BIGNUM_LENGTH(arg);
- carry = 1;
- while (scan < end) {
- digit = (~*scan & BIGNUM_DIGIT_MASK) + carry;
- if (digit < BIGNUM_RADIX)
- carry = 0;
- else
- {
- digit = (digit - BIGNUM_RADIX);
- carry = 1;
- }
-
- *scan++ = digit;
- }
- }
- static long
- bignum_unsigned_logcount(bignum_type arg)
- {
- bignum_digit_type *scan;
- bignum_digit_type *end;
- bignum_digit_type digit;
- /* sufficient for any reasonable big number */
- long result;
- unsigned long i;
- if (BIGNUM_ZERO_P (arg)) return (0L);
- scan = BIGNUM_START_PTR (arg);
- end = scan + BIGNUM_LENGTH (arg);
- result = 0L;
-
- while (scan < end) {
- digit = *scan++ & BIGNUM_DIGIT_MASK;
- for (i = 0; i++ < BIGNUM_DIGIT_LENGTH; digit = digit >> 1L)
- result += digit & 1L;
- }
- return (result);
- }
- int
- bignum_logbitp(int shift, bignum_type arg)
- {
- return((BIGNUM_NEGATIVE_P (arg))
- ? !bignum_unsigned_logbitp (shift, s48_bignum_bitwise_not (arg))
- : bignum_unsigned_logbitp (shift,arg));
- }
- static int
- bignum_unsigned_logbitp(int shift, bignum_type bignum)
- {
- bignum_length_type len = (BIGNUM_LENGTH (bignum));
- bignum_digit_type digit;
- int index = shift / BIGNUM_DIGIT_LENGTH;
- int p;
- if (index >= len)
- return 0;
- digit = (BIGNUM_REF (bignum, index));
- p = shift % BIGNUM_DIGIT_LENGTH;
- return digit & (1 << p);
- }
|