juce_BigInteger.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   The code included in this file is provided under the terms of the ISC license
   http://www.isc.org/downloads/software-support-policy/isc-license. Permission
   To use, copy, modify, and/or distribute this software for any purpose with or
   without fee is hereby granted provided that the above copyright notice and
   this permission notice appear in all copies.
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
namespace juce
{
 
//==============================================================================
class JUCE_API  BigInteger
{
public:
    //==============================================================================
    BigInteger();

    BigInteger (uint32 value);

    BigInteger (int32 value);

    BigInteger (int64 value);

    BigInteger (const BigInteger&);

    BigInteger (BigInteger&&) noexcept;

    BigInteger& operator= (BigInteger&&) noexcept;

    ~BigInteger() = default;
 
    //==============================================================================
    BigInteger& operator= (const BigInteger&);

    void swapWith (BigInteger&) noexcept;
 
    //==============================================================================
    bool operator[] (int bit) const noexcept;

    bool isZero() const noexcept;

    bool isOne() const noexcept;

    int toInteger() const noexcept;

    int64 toInt64() const noexcept;
 
    //==============================================================================
    void clear() noexcept;

    void clearBit (int bitNumber) noexcept;

    void setBit (int bitNumber);

    void setBit (int bitNumber, bool shouldBeSet);

    void setRange (int startBit, int numBits, bool shouldBeSet);

    void insertBit (int bitNumber, bool shouldBeSet);

    BigInteger getBitRange (int startBit, int numBits) const;

    uint32 getBitRangeAsInt (int startBit, int numBits) const noexcept;

    void setBitRangeAsInt (int startBit, int numBits, uint32 valueToSet);

    void shiftBits (int howManyBitsLeft, int startBit);

    int countNumberOfSetBits() const noexcept;

    int findNextSetBit (int startIndex) const noexcept;

    int findNextClearBit (int startIndex) const noexcept;

    int getHighestBit() const noexcept;
 
    //==============================================================================
    bool isNegative() const noexcept;

    void setNegative (bool shouldBeNegative) noexcept;

    void negate() noexcept;
 
    //==============================================================================
    // All the standard arithmetic ops...
 
    BigInteger& operator+= (const BigInteger&);
    BigInteger& operator-= (const BigInteger&);
    BigInteger& operator*= (const BigInteger&);
    BigInteger& operator/= (const BigInteger&);
    BigInteger& operator|= (const BigInteger&);
    BigInteger& operator&= (const BigInteger&);
    BigInteger& operator^= (const BigInteger&);
    BigInteger& operator%= (const BigInteger&);
    BigInteger& operator<<= (int numBitsToShift);
    BigInteger& operator>>= (int numBitsToShift);
    BigInteger& operator++();
    BigInteger& operator--();
    BigInteger operator++ (int);
    BigInteger operator-- (int);
 
    BigInteger operator-() const;
    BigInteger operator+ (const BigInteger&) const;
    BigInteger operator- (const BigInteger&) const;
    BigInteger operator* (const BigInteger&) const;
    BigInteger operator/ (const BigInteger&) const;
    BigInteger operator| (const BigInteger&) const;
    BigInteger operator& (const BigInteger&) const;
    BigInteger operator^ (const BigInteger&) const;
    BigInteger operator% (const BigInteger&) const;
    BigInteger operator<< (int numBitsToShift) const;
    BigInteger operator>> (int numBitsToShift) const;
 
    bool operator== (const BigInteger&) const noexcept;
    bool operator!= (const BigInteger&) const noexcept;
    bool operator<  (const BigInteger&) const noexcept;
    bool operator<= (const BigInteger&) const noexcept;
    bool operator>  (const BigInteger&) const noexcept;
    bool operator>= (const BigInteger&) const noexcept;
 
    //==============================================================================
    int compare (const BigInteger& other) const noexcept;

    int compareAbsolute (const BigInteger& other) const noexcept;
 
    //==============================================================================
    void divideBy (const BigInteger& divisor, BigInteger& remainder);

    BigInteger findGreatestCommonDivisor (BigInteger other) const;

    void exponentModulo (const BigInteger& exponent, const BigInteger& modulus);

    void inverseModulo (const BigInteger& modulus);

    void montgomeryMultiplication (const BigInteger& other, const BigInteger& modulus,
                                   const BigInteger& modulusp, int k);

    void extendedEuclidean (const BigInteger& a, const BigInteger& b,
                            BigInteger& xOut, BigInteger& yOut);
 
    //==============================================================================
    String toString (int base, int minimumNumCharacters = 1) const;

    void parseString (StringRef text, int base);
 
    //==============================================================================
    MemoryBlock toMemoryBlock() const;

    void loadFromMemoryBlock (const MemoryBlock& data);
 
private:
    //==============================================================================
    enum { numPreallocatedInts = 4 };
    HeapBlock<uint32> heapAllocation;
    uint32 preallocated[numPreallocatedInts];
    size_t allocatedSize;
    int highestBit = -1;
    bool negative = false;
 
    uint32* getValues() const noexcept;
    uint32* ensureSize (size_t);
    void shiftLeft (int bits, int startBit);
    void shiftRight (int bits, int startBit);
 
    JUCE_LEAK_DETECTOR (BigInteger)
};

OutputStream& JUCE_CALLTYPE operator<< (OutputStream& stream, const BigInteger& value);
 
} // namespace juce