Multiply() [1/3]

static unsafe void System.Numerics.BigIntegerCalculator.Multiply ( uint * left, int leftLength, uint * right, int rightLength, uint * bits, int bitsLength )

inlinestaticprivate

Definition at line 1239 of file BigIntegerCalculator.cs.

    {
        if (rightLength < MultiplyThreshold)
        {
            for (int i = 0; i < rightLength; i++)
            {
                ulong num = 0uL;
                for (int j = 0; j < leftLength; j++)
                {
                    ulong num2 = bits[i + j] + num + (ulong)((long)left[j] * (long)right[i]);
                    bits[i + j] = (uint)num2;
                    num = num2 >> 32;
                }
                bits[i + leftLength] = (uint)num;
            }
            return;
        }
        int num3 = rightLength >> 1;
        int num4 = num3 << 1;
        int num5 = num3;
        uint* left2 = left + num3;
        int num6 = leftLength - num3;
        int rightLength2 = num3;
        uint* ptr = right + num3;
        int num7 = rightLength - num3;
        int num8 = num4;
        uint* ptr2 = bits + num4;
        int num9 = bitsLength - num4;
        Multiply(left, num5, right, rightLength2, bits, num8);
        Multiply(left2, num6, ptr, num7, ptr2, num9);
        int num10 = num6 + 1;
        int num11 = num7 + 1;
        int num12 = num10 + num11;
        if (num12 < AllocationThreshold)
        {
            uint* ptr3 = stackalloc uint[num10];
            new Span<uint>(ptr3, num10).Clear();
            uint* ptr4 = stackalloc uint[num11];
            new Span<uint>(ptr4, num11).Clear();
            uint* ptr5 = stackalloc uint[num12];
            new Span<uint>(ptr5, num12).Clear();
            Add(left2, num6, left, num5, ptr3, num10);
            Add(ptr, num7, right, rightLength2, ptr4, num11);
            Multiply(ptr3, num10, ptr4, num11, ptr5, num12);
            SubtractCore(ptr2, num9, bits, num8, ptr5, num12);
            AddSelf(bits + num3, bitsLength - num3, ptr5, num12);
            return;
        }
        fixed (uint* ptr6 = new uint[num10])
        {
            fixed (uint* ptr7 = new uint[num11])
            {
                fixed (uint* ptr8 = new uint[num12])
                {
                    Add(left2, num6, left, num5, ptr6, num10);
                    Add(ptr, num7, right, rightLength2, ptr7, num11);
                    Multiply(ptr6, num10, ptr7, num11, ptr8, num12);
                    SubtractCore(ptr2, num9, bits, num8, ptr8, num12);
                    AddSelf(bits + num3, bitsLength - num3, ptr8, num12);
                }
            }
        }
    }

References System.Add, System.Numerics.BigIntegerCalculator.AddSelf(), System.Numerics.BigIntegerCalculator.AllocationThreshold, System.Span< T >.Clear(), System.Multiply, System.Numerics.BigIntegerCalculator.MultiplyThreshold, and System.Numerics.BigIntegerCalculator.SubtractCore().