Merge pull request #5819 from MartinNowak/merge_stable

Merge remote-tracking branch 'upstream/stable' into merge_stable

Author: wilzbach

std/bigint.d

@@ -311,6 +311,55 @@ public:
         assert(b == BigInt("200_002_469"));
     }
 
+    // Issue 16264
+    @system unittest
+    {
+        auto a = BigInt(
+    `335690982744637013564796917901053301979460129353374296317539383938630086938` ~
+    `465898213033510992292836631752875403891802201862860531801760096359705447768` ~
+    `957432600293361240407059207520920532482429912948952142341440301429494694368` ~
+    `264560802292927144211230021750155988283029753927847924288850436812178022006` ~
+    `408597793414273953252832688620479083497367463977081627995406363446761896298` ~
+    `967177607401918269561385622811274398143647535024987050366350585544531063531` ~
+    `7118554808325723941557169427279911052268935775`);
+
+        auto b = BigInt(
+    `207672245542926038535480439528441949928508406405023044025560363701392340829` ~
+    `852529131306106648201340460604257466180580583656068555417076345439694125326` ~
+    `843947164365500055567495554645796102453565953360564114634705366335703491527` ~
+    `429426780005741168078089657359833601261803592920462081364401456331489106355` ~
+    `199133982282631108670436696758342051198891939367812305559960349479160308314` ~
+    `068518200681530999860641597181672463704794566473241690395901768680673716414` ~
+    `243691584391572899147223065906633310537507956952626106509069491302359792769` ~
+    `378934570685117202046921464019396759638376362935855896435623442486036961070` ~
+    `534574698959398017332214518246531363445309522357827985468581166065335726996` ~
+    `711467464306784543112544076165391268106101754253962102479935962248302404638` ~
+    `21737237102628470475027851189594709504`);
+
+        BigInt c = a * b;  // Crashes
+
+        assert(c == BigInt(
+    `697137001950904057507249234183127244116872349433141878383548259425589716813` ~
+    `135440660252012378417669596912108637127036044977634382385990472429604619344` ~
+    `738746224291111527200379708978133071390303850450970292020176369525401803474` ~
+    `998613408923490273129022167907826017408385746675184651576154302536663744109` ~
+    `111018961065316024005076097634601030334948684412785487182572502394847587887` ~
+    `507385831062796361152176364659197432600147716058873232435238712648552844428` ~
+    `058885217631715287816333209463171932255049134340904981280717725999710525214` ~
+    `161541960645335744430049558161514565159449390036287489478108344584188898872` ~
+    `434914159748515512161981956372737022393466624249130107254611846175580584736` ~
+    `276213025837422102290580044755202968610542057651282410252208599309841499843` ~
+    `672251048622223867183370008181364966502137725166782667358559333222947265344` ~
+    `524195551978394625568228658697170315141077913403482061673401937141405425042` ~
+    `283546509102861986303306729882186190883772633960389974665467972016939172303` ~
+    `653623175801495207204880400522581834672918935651426160175413277309985678579` ~
+    `830872397214091472424064274864210953551447463312267310436493480881235642109` ~
+    `668498742629676513172286703948381906930297135997498416573231570483993847269` ~
+    `479552708416124555462530834668011570929850407031109157206202741051573633443` ~
+    `58105600`
+        ));
+    }
+
     /**
      * Implements assignment operators of the form $(D BigInt op= BigInt).
      */

std/internal/math/biguintcore.d

@@ -1402,59 +1402,76 @@ void mulInternal(BigDigit[] result, const(BigDigit)[] x, const(BigDigit)[] y)
         auto extra =  x.length % y.length;
         auto maxchunk = chunksize + extra;
         bool paddingY; // true = we're padding Y, false = we're padding X.
-        if (extra * extra * 2 < y.length*y.length)
-        {
-            // The leftover bit is small enough that it should be incorporated
-            // in the existing chunks.
-            // Make all the chunks a tiny bit bigger
-            // (We're padding y with zeros)
-            chunksize += extra / numchunks;
-            extra = x.length - chunksize*numchunks;
-            // there will probably be a few left over.
-            // Every chunk will either have size chunksize, or chunksize+1.
-            maxchunk = chunksize + 1;
-            paddingY = true;
-            assert(chunksize + extra + chunksize *(numchunks-1) == x.length );
+        bool isExtraSmall = extra * extra * 2 < y.length * y.length;
+        if (numchunks == 1 && isExtraSmall)
+        {
+            // We divide (x_first_half * y) and (x_last_half * y)
+            // between 1.414:1 and 1.707:1 (1.707 = 1+1/sqrt(2)).
+            // (1.414 ~ 1.707)/2:1 is balanced.
+            BigDigit [] scratchbuff = new BigDigit[karatsubaRequiredBuffSize(y.length) + y.length];
+            BigDigit [] partial = scratchbuff[$ - y.length .. $];
+            mulKaratsuba(result[0 .. half + y.length], y, x[0 .. half], scratchbuff);
+            partial[] = result[half .. half + y.length];
+            mulKaratsuba(result[half .. $], y, x[half .. $], scratchbuff);
+            addAssignSimple(result[half .. half + y.length], partial);
+            () @trusted { GC.free(scratchbuff.ptr); } ();
         }
         else
         {
-            // the extra bit is large enough that it's worth making a new chunk.
-            // (This means we're padding x with zeros, when doing the first one).
-            maxchunk = chunksize;
-            ++numchunks;
-            paddingY = false;
-            assert(extra + chunksize *(numchunks-1) == x.length );
-        }
-        // We make the buffer a bit bigger so we have space for the partial sums.
-        BigDigit [] scratchbuff = new BigDigit[karatsubaRequiredBuffSize(maxchunk) + y.length];
-        BigDigit [] partial = scratchbuff[$ - y.length .. $];
-        size_t done; // how much of X have we done so far?
-        if (paddingY)
-        {
-            // If the first chunk is bigger, do it first. We're padding y.
-            mulKaratsuba(result[0 .. y.length + chunksize + (extra > 0 ? 1 : 0 )],
-                x[0 .. chunksize + (extra>0?1:0)], y, scratchbuff);
-            done = chunksize + (extra > 0 ? 1 : 0);
-            if (extra) --extra;
-        }
-        else
-        {   // We're padding X. Begin with the extra bit.
-            mulKaratsuba(result[0 .. y.length + extra], y, x[0 .. extra], scratchbuff);
-            done = extra;
-            extra = 0;
-        }
-        immutable basechunksize = chunksize;
-        while (done < x.length)
-        {
-            chunksize = basechunksize + (extra > 0 ? 1 : 0);
-            if (extra) --extra;
-            partial[] = result[done .. done+y.length];
-            mulKaratsuba(result[done .. done + y.length + chunksize],
-                       x[done .. done+chunksize], y, scratchbuff);
-            addAssignSimple(result[done .. done + y.length + chunksize], partial);
-            done += chunksize;
+            if (isExtraSmall)
+            {
+                // The leftover bit is small enough that it should be incorporated
+                // in the existing chunks.
+                // Make all the chunks a tiny bit bigger
+                // (We're padding y with zeros)
+                chunksize += extra / numchunks;
+                extra = x.length - chunksize*numchunks;
+                // there will probably be a few left over.
+                // Every chunk will either have size chunksize, or chunksize+1.
+                maxchunk = chunksize + 1;
+                paddingY = true;
+                assert(chunksize + extra + chunksize *(numchunks-1) == x.length );
+            }
+            else
+            {
+                // the extra bit is large enough that it's worth making a new chunk.
+                // (This means we're padding x with zeros, when doing the first one).
+                maxchunk = chunksize;
+                ++numchunks;
+                paddingY = false;
+                assert(extra + chunksize *(numchunks-1) == x.length );
+            }
+            // We make the buffer a bit bigger so we have space for the partial sums.
+            BigDigit [] scratchbuff = new BigDigit[karatsubaRequiredBuffSize(maxchunk) + y.length];
+            BigDigit [] partial = scratchbuff[$ - y.length .. $];
+            size_t done; // how much of X have we done so far?
+            if (paddingY)
+            {
+                // If the first chunk is bigger, do it first. We're padding y.
+                mulKaratsuba(result[0 .. y.length + chunksize + (extra > 0 ? 1 : 0 )],
+                    x[0 .. chunksize + (extra>0?1:0)], y, scratchbuff);
+                done = chunksize + (extra > 0 ? 1 : 0);
+                if (extra) --extra;
+            }
+            else
+            {   // We're padding X. Begin with the extra bit.
+                mulKaratsuba(result[0 .. y.length + extra], y, x[0 .. extra], scratchbuff);
+                done = extra;
+                extra = 0;
+            }
+            immutable basechunksize = chunksize;
+            while (done < x.length)
+            {
+                chunksize = basechunksize + (extra > 0 ? 1 : 0);
+                if (extra) --extra;
+                partial[] = result[done .. done+y.length];
+                mulKaratsuba(result[done .. done + y.length + chunksize],
+                        x[done .. done+chunksize], y, scratchbuff);
+                addAssignSimple(result[done .. done + y.length + chunksize], partial);
+                done += chunksize;
+            }
+            () @trusted { GC.free(scratchbuff.ptr); } ();
         }
-        () @trusted { GC.free(scratchbuff.ptr); } ();
     }
     else
     {
@@ -1963,7 +1980,7 @@ bool less(const(BigDigit)[] x, const(BigDigit)[] y) pure nothrow
 bool inplaceSub(BigDigit[] result, const(BigDigit)[] x, const(BigDigit)[] y)
     pure nothrow
 {
-    assert(result.length == (x.length >= y.length) ? x.length : y.length);
+    assert(result.length == ((x.length >= y.length) ? x.length : y.length));
 
     size_t minlen;
     bool negative;
@@ -2021,7 +2038,7 @@ void mulKaratsuba(BigDigit [] result, const(BigDigit) [] x,
         const(BigDigit)[] y, BigDigit [] scratchbuff) pure nothrow
 {
     assert(x.length >= y.length);
-          assert(result.length < uint.max, "Operands too large");
+    assert(result.length < uint.max, "Operands too large");
     assert(result.length == x.length + y.length);
     if (x.length <= KARATSUBALIMIT)
     {