nints.pas

cipher 5.1。一个几乎包含了所有常见的加密算法的控件

function  NDivU(var Q: IInteger; const A: IInteger; B: Cardinal): Cardinal; overload;
procedure NDiv(var Q: IInteger; const A,B: IInteger); overload;
procedure NDivRem(var Q,R: IInteger; const A,B: IInteger); overload;
procedure NDivMod(var Q,R: IInteger; const A,B: IInteger); overload;
procedure NAddMod(var A: IInteger; const B,C,M: IInteger); overload;
procedure NAddMod(var A: IInteger; const B,M: IInteger); overload;
procedure NSubMod(var A: IInteger; const B,C,M: IInteger); overload;
procedure NSubMod(var A: IInteger; const B,M: IInteger); overload;
procedure NMulMod(var A: IInteger; const B,C,M: IInteger); overload;
procedure NMulMod(var A: IInteger; const B,M: IInteger); overload;
procedure NMulMod2k(var A: IInteger; const B,C: IInteger; K: Cardinal); overload;
procedure NMulMod2k(var A: IInteger; const B: IInteger; K: Cardinal); overload;
procedure NSqrMod(var A: IInteger; const B,M: IInteger); overload;
procedure NSqrMod(var A: IInteger; const M: IInteger); overload;
procedure NSqrMod2k(var A: IInteger; const B: IInteger; K: Cardinal); overload;
procedure NSqrMod2k(var A: IInteger; K: Cardinal); overload;
function  NInvMod(var A: IInteger; const M: IInteger): Boolean; overload;
function  NInvMod(var A: IInteger; const B,M: IInteger): Boolean; overload;
function  NInvMod(var A: IIntegerArray; const B: IIntegerArray; const M: IInteger; Inv2k: Cardinal = 0): Boolean; overload;
function  NInvMod(var A: IIntegerArray; const M: IInteger; Inv2k: Cardinal = 0): Boolean; overload;
function  NInvMod2k(var A: IInteger; K: Cardinal): Boolean; overload;
function  NInvMod2k(var A: IInteger; const B: IInteger; K: Cardinal): Boolean; overload;
function  NPowMod(var A: IInteger; const E,M: IInteger; const P: IPowModPrecomputation = nil): Boolean; overload;
function  NPowMod(var A: IInteger; const B,E,M: IInteger; const P: IPowModPrecomputation = nil): Boolean; overload;
function  NPowMod(var A: IInteger; const B,E: IIntegerArray; const M: IInteger): Boolean; overload;
function  NPowMod2k(var A: IInteger; const B,E: IInteger; K: Cardinal; const P: IPowModPrecomputation = nil): Boolean; overload;
function  NPowMod2k(var A: IInteger; const E: IInteger; K: Cardinal; const P: IPowModPrecomputation = nil): Boolean; overload;
procedure NPow(var A: IInteger; E: Integer); overload;
procedure NPow(var A: IInteger; B,E: Integer); overload;
procedure NPow(var A: IInteger; const B: IInteger; E: Integer); overload;
function  NGCD1(const A: IIntegerArray): Boolean; overload;
function  NGCD1(const A,B: IInteger): Boolean; overload;
function  NGCD(A, B: Integer): Integer; overload;
function  NGCD(var D: IInteger; const A,B: IInteger): Boolean; overload;
function  NGCD(var D: IInteger; const A: IIntegerArray): Boolean; overload;
function  NGCD(var D,U,V: IInteger; const A,B: IInteger): Boolean; overload;
procedure NLCM(var L: IInteger; const A,B: IInteger); overload;
function  NCRT(var A: IInteger; const R,M: IIntegerArray): Boolean; overload;
function  NCRT(var A: IInteger; const R,M,U: IIntegerArray): Boolean; overload;
function  NCRT(var U: IIntegerArray; const M: IIntegerArray): Boolean; overload;
function  NSqrt(var A: IInteger; const B: IInteger): Boolean; overload;  // 1.)
function  NSqrt(var A: IInteger): Boolean; overload;
function  NSqrt(var A,R: IInteger; const B: IInteger): Boolean; overload;
function  NSqrtMod2k(var A: IInteger; K: Cardinal): Boolean; overload;
function  NSqrtMod2k(var A: IInteger; const B: IInteger; K: Cardinal): Boolean; overload;
function  NSqrtMod(var A: IInteger; const P: IInteger; Check: Boolean = False): Integer; overload;
function  NRoot(var A,R: IInteger; const B: IInteger; E: Integer): Boolean; overload; // 1.)
function  NRoot(var A: IInteger; E: Integer): Boolean; overload;
function  NRoot(var A: IInteger; const B: IInteger; E: Integer): Boolean; overload;
function  NRootMod2k(var A: IInteger; const E: IInteger; K: Cardinal): Boolean; overload;
function  NRootMod2k(var A: IInteger; const B,E: IInteger; K: Cardinal): Boolean; overload;
function  NIsPerfectSqr(const A: IInteger; FullTest: Boolean = True): Boolean; overload;
function  NIsPerfectSqr(const N: Int64): Boolean; overload;
function  NIsPerfectPower(var B: IInteger; const N: IInteger; Bound: Cardinal = 0): Cardinal; overload; // 1.)
function  NIsPerfectPower(const N: IInteger; Bound: Cardinal = 0): Cardinal; overload;
function  NIsPower(const N: IInteger; B,E: Integer): Boolean; overload;
function  NIsPower(const N,B: IInteger; E: Integer): Boolean; overload;
function  NIsPower(const N,B,E: IInteger): Boolean; overload;
function  NIsPowerOf2(const A: IInteger): Integer; overload;
function  NIsDivisible(const A: IInteger; B: Cardinal): Boolean; overload;
function  NTrialDivision(const A: IInteger; Bound: Cardinal = $FFFF): TTrialDivision; overload;
function  NSmallFactor(const A: IInteger; Bound: Cardinal = 0): Cardinal; overload;
function  NSPP(const N: IInteger; const Bases: array of Integer): Boolean;
function  NIsProbablePrime(const A: IInteger): Boolean; overload;
function  NIsProbablePrime(const A: IInteger; const Bases: array of Integer): Boolean; overload;
function  NMakePrime(var P: IInteger; const Bases: array of Integer): Integer; overload;
function  NMakePrime(var P: IInteger; const Bases: array of Integer;
            Residue, Modulus: Integer; Callback: TIIntegerPrimeCallback = nil): Integer; overload;
function  NMakePrime(var P: IInteger; const Bases: array of Integer;
            const Residue, Modulus: IInteger; Callback: TIIntegerPrimeCallback = nil): Integer; overload;
procedure NLimLeePrime(var P: IInteger; var F: IIntegerArray; PBitSize: Integer; QBitSize: Integer = 0); overload;
procedure NLimLeePrime(var P,Q: IInteger; PBitSize: Integer; QBitSize: Integer = 0); overload;
function  NJacobi(A,B: Int64): Integer; overload;
function  NJacobi(A,B: Integer): Integer; overload;
function  NJacobi(A: Integer; const B: IInteger): Integer; overload;
function  NJacobi(const A: IInteger; B: Integer): Integer; overload;
function  NJacobi(const A,B: IInteger): Integer; overload;
procedure NLucas(var V: IInteger; const K: IInteger); overload;
procedure NLucas(var U,V: IInteger; const K: IInteger); overload;
procedure NLucas(var V: IInteger; const K,P,Q: IInteger); overload;
procedure NLucas(var U,V: IInteger; const K,P,Q: IInteger); overload;
procedure NLucasMod(var V: IInteger; const K,P,M: IInteger); overload;
procedure NLucasMod(var V: IInteger; const K,P,Q,M: IInteger); overload;
procedure NLucasMod(var U,V: IInteger; const K,P,Q,M: IInteger); overload;
function  NInvLucasMod(var A: IInteger; const K,N,P,Q: IInteger): Boolean; overload;
function  NInvLucasMod(var A: IInteger; const K,N,P,Q,U: IInteger): Boolean; overload;

procedure NFermat(var A: IInteger; N: Cardinal; const M: IInteger = nil); overload;
procedure NFibonacci(var R: IInteger; N: Cardinal; const M: IInteger = nil); overload;

function  NDigitCount(FromBase, ToBase: TBase; Digits: Cardinal): Cardinal; overload;
function  NDigitCount(const A: IInteger; Base: TBase = 10; Exactly: Boolean = True): Cardinal; overload;
function  NLn(const A: IInteger; Base: Cardinal = 1; ErrorCheck: Boolean = False): Extended; overload;
function  NDigit(const A: IInteger; Index: Integer; Piece: TPiece = piByte): Cardinal; overload;
procedure NDigit(var A: IInteger; Index: Integer; Value: Cardinal; Piece: TPiece = piByte); overload;
procedure NAF(var A: TNAFArray; const B: IInteger; W: Byte = 2); overload;
function  NStr(const A: IInteger; Base: TBase = 0): String; overload;
function  NStr(const A: IInteger; const Format: TStrFormat): String; overload;
function  NInt32(const A: IInteger; RangeCheck: Boolean = True): Integer; overload;
function  NInt64(const A: IInteger; RangeCheck: Boolean = True): Int64; overload;
function  NLong(const A: IInteger; RangeCheck: Boolean = True): Cardinal; overload;
function  NFloat(const A: IInteger; RangeCheck: Boolean = True): Extended; overload;
function  NRange(const A: IInteger; Range: PTypeInfo; RaiseError: Boolean = False): Boolean; overload;
procedure NSave(const A: IInteger; Stream: TStream; Format: TIntegerFormat = ifASN1); overload;
procedure NSave(const A: IInteger; const FileName: String; Format: TIntegerFormat = ifASN1); overload;
procedure NLoad(var R: IInteger; Stream: TStream; Format: TIntegerFormat = ifASN1); overload;
procedure NLoad(var R: IInteger; const FileName: String; Format: TIntegerFormat = ifASN1); overload;
procedure NHash(var A: IInteger; Hash: TDECHashClass = nil; Bits: Integer = 0; Index: Cardinal = 0); overload;
procedure NHash(var A: IInteger; const B: IInteger; Hash: TDECHashClass = nil; Bits: Integer = 0; Index: Cardinal = 0); overload;

function  NMont(const M: IInteger): Cardinal; overload;
procedure NMont(var A: IInteger; const M: IInteger; R: Cardinal); overload;
procedure NMont(var A: IInteger; const B,M: IInteger; R: Cardinal); overload;
procedure NMont(var A: IIntegerArray; const B: IIntegerArray; const M: IInteger; Inv2k: Cardinal = 0); overload;
procedure NMont(var A: IIntegerArray; const M: IInteger; Inv2k: Cardinal = 0); overload;
procedure NRedc(var A: IInteger; const M: IInteger; R: Cardinal); overload;
procedure NRedc(var A: IInteger; const B,M: IInteger; R: Cardinal); overload;
procedure NRedc(var A: IIntegerArray; const B: IIntegerArray; const M: IInteger; Inv2k: Cardinal = 0); overload;
procedure NRedc(var A: IIntegerArray; const M: IInteger; Inv2k: Cardinal = 0); overload;

procedure NSet(var P: IPowModPrecomputation; const B,M: IInteger; EMaxBitSize: Integer; EIsNeg: Boolean = False); overload;
procedure NSave(const P: IPowModPrecomputation; Stream: TStream); overload;
procedure NLoad(var P: IPowModPrecomputation; Stream: TStream); overload;

function  NSum(const A: IInteger): Long96; overload;
function  NMod(const A: Long96; B: Cardinal): Cardinal; overload;
procedure NSumModFactors(var Factors: IInteger; Bit: Integer); overload;
procedure NSumModModulis(var Modulis: IInteger; const Factors: IInteger); overload;
function  NInvMod2k32(A: Cardinal): Cardinal; overload; // A^-1 mod 2^32
function  NInvMod2k32(const A: IInteger; B: Cardinal; BInv: Cardinal = 0): Cardinal; overload;
function  NInvMul2k32(A,B: Cardinal; BInv: Cardinal = 0): Cardinal; overload;

procedure NInsert(var A: IInteger; B: Cardinal; Duplicates: Boolean = False); overload;
function  NFind(const A: IInteger; B: Cardinal; var Index: Integer): Boolean; overload;
function  NFind(const A: IInteger; B: Cardinal): Integer; overload;
procedure NSort(var A: IInteger); overload;
procedure NSort(var A: IIntegerArray; Compare: TIIntegerSortCompare); overload;
procedure NSort(var A: IIntegerArray; Abs: Boolean = False; Descending: Boolean = False); overload;
function  NForEach(const A: IIntegerArray; Callback: TIIntegerForEachCallback): IInteger; overload;
function  NBinarySplitting(var P,Q: IInteger; Count: Integer;
            Callback: TIIntegerBinarySplittingCallback; ImplicitShift: Boolean = True): Cardinal; overload;
function  NConfig(Flag: Cardinal = 3): Cardinal;

procedure NRaise(Msg: PResStringRec; const Param: String); overload;
procedure NRaise(Msg: PResStringRec; const Param: array of const); overload;
procedure NRaise(Msg: PResStringRec = nil); overload;
procedure NRaise_DivByZero; overload;

procedure NParseFormat(var F: TStrFormat; const B: String);
function  NLog2(A: Cardinal): Integer;
function  NBitWeight(A: Cardinal): Integer; overload;
function  NBitSwap(A: Cardinal): Cardinal; overload;
function  NGrayCodeTo(N: Cardinal): Cardinal; overload;
procedure NGrayCodeTo(var A: IInteger; const B: IInteger); overload;
function  NToGrayCode(N: Cardinal): Cardinal; overload;
procedure NToGrayCode(var A: IInteger; const B: IInteger); overload;

function  NGreenCodeTo(N: Cardinal): Cardinal; overload;
procedure NGreenCodeTo(var A: IInteger; const B: IInteger); overload;
function  NToGreenCode(N: Cardinal): Cardinal; overload;
procedure NToGreenCode(var A: IInteger; const B: IInteger); overload;

// predefined and fast constant
function  NNull: IInteger;      //  0
function  NOne: IInteger;       // +1
function  NMinusOne: IInteger;  // -1
function  NTwo: IInteger;       // +2
function  NMinusTwo: IInteger;  // -2

function  NBreakEven(Index: Integer): Cardinal;

// points
procedure NSwp(var A,B: I2Point); overload;
procedure NSwp(var A,B: I3Point); overload;
procedure NSet(var A: I2Point; const B: I2Point); overload;
procedure NSet(var A: I3Point; const B: I3Point); overload;

var
  NStrFormat: TStrFormat = (
    Base: 10;
    Plus: '';
    Minus: '-';
    Zero: '';
    Comma: ',';
    DigitsPerBlock: 5;
    BlockSep: ' ';
    BlockPadding: ' ';
    DigitsPerLine: 0;
    LineSep: #13#10;
    LinePadding: #0;
    DigitsChars: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/';
    FormatChars: ' /\-+;:#~"()[]?_<>!