SB-BIGNUM

SB-BIGNUM

properties


ID: SB-BIGNUM
LOCK: T


private: bignum implementation

BIGNUM-TRUNCATE-SINGLE-DIGIT   compiled function

properties


ID: SB-BIGNUM:BIGNUM-TRUNCATE-SINGLE-DIGIT
ALLOC: HEAP IMMOBILE



BIGNUM-TRUNCATE-SINGLE-DIGIT names a compiled function:
  Lambda-list: (X Y)
  Derived type: (FUNCTION
                 (BIGNUM (INTEGER -9223372036854775808 18446744073709551615))
                 (VALUES (OR NULL INTEGER)
                         (INTEGER -18446744073709551615 18446744073709551615)
                         &OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

ADD-BIGNUM-FIXNUM   compiled function

properties


ID: SB-BIGNUM:ADD-BIGNUM-FIXNUM
ALLOC: HEAP IMMOBILE



ADD-BIGNUM-FIXNUM names a compiled function:
  Lambda-list: (A B)
  Declared type: (FUNCTION (BIGNUM FIXNUM) (VALUES INTEGER &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, movable, no-verify-arg-count
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;COMPILER;FNDB.LISP

ADD-BIGNUMS   compiled function

properties


ID: SB-BIGNUM:ADD-BIGNUMS
ALLOC: HEAP IMMOBILE



ADD-BIGNUMS names a compiled function:
  Lambda-list: (A B)
  Declared type: (FUNCTION (BIGNUM BIGNUM) (VALUES INTEGER &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, movable, no-verify-arg-count
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;COMPILER;FNDB.LISP

%DIGIT-0-OR-PLUSP

properties


ID: SB-BIGNUM:%DIGIT-0-OR-PLUSP
ALLOC: HEAP IMMOBILE



%DIGIT-0-OR-PLUSP names an undefined function
  Declared type: (FUNCTION ((UNSIGNED-BYTE 64)) (VALUES BOOLEAN &OPTIONAL))
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

BIGNUM-LOGBITP   compiled function

properties


ID: SB-BIGNUM:BIGNUM-LOGBITP
ALLOC: HEAP IMMOBILE



BIGNUM-LOGBITP names a compiled function:
  Lambda-list: (INDEX BIGNUM)
  Derived type: (FUNCTION ((MOD 4294967295) BIGNUM) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

%UNARY-TRUNCATE-DOUBLE-FLOAT-TO-BIGNUM   compiled function

properties


ID: SB-BIGNUM:%UNARY-TRUNCATE-DOUBLE-FLOAT-TO-BIGNUM
ALLOC: HEAP IMMOBILE



%UNARY-TRUNCATE-DOUBLE-FLOAT-TO-BIGNUM names a compiled function:
  Lambda-list: (NUMBER)
  Declared type: (FUNCTION (DOUBLE-FLOAT) (VALUES BIGNUM &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count, fixed-args
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;COMPILER;FNDB.LISP
    • SB-C::FOLDER
  • SYS:SRC;COMPILER;FNDB.LISP

%BIGNUM-SET-LENGTH

properties


ID: SB-BIGNUM:%BIGNUM-SET-LENGTH
ALLOC: HEAP IMMOBILE



%BIGNUM-SET-LENGTH names an undefined function
  Declared type: (FUNCTION (BIGNUM (UNSIGNED-BYTE 32)) (VALUES &OPTIONAL))
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

%BIGNUM-SET

properties


ID: SB-BIGNUM:%BIGNUM-SET
ALLOC: HEAP IMMOBILE



%BIGNUM-SET names an undefined function
  Declared type: (FUNCTION (BIGNUM (MOD 4294967295) (UNSIGNED-BYTE 64))
                  (VALUES &OPTIONAL))
  • Called by
    • COERCE
    • SB-GMP::MPZ->BIGNUM
    • SB-GMP::ALLOCATE-BIGNUM
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

%BIGNUM-REF-WITH-OFFSET

properties


ID: SB-BIGNUM:%BIGNUM-REF-WITH-OFFSET
ALLOC: HEAP IMMOBILE



%BIGNUM-REF-WITH-OFFSET names an undefined function
  Declared type: (FUNCTION (BIGNUM FIXNUM (SIGNED-BYTE 24))
                  (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  • Called by
    • COERCE
    • SB-MPFR:COMPARE
    • SB-MPFR:POWER
    • DIV
    • SB-MPFR:MUL
    • SB-MPFR:SUB
    • SB-MPFR:ADD
    • SB-ACLREPL::COMPONENT-AT
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-TRAN.LISP
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

%ASHL

properties


ID: SB-BIGNUM:%ASHL
ALLOC: HEAP IMMOBILE



%ASHL names an undefined function
  Declared type: (FUNCTION ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 6))
                  (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

SXHASH-BIGNUM   compiled function

properties


ID: SB-BIGNUM:SXHASH-BIGNUM
ALLOC: HEAP IMMOBILE



SXHASH-BIGNUM names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (INTEGER) (VALUES (UNSIGNED-BYTE 62) &OPTIONAL))
  Derived type: (FUNCTION (T) (VALUES (UNSIGNED-BYTE 62) &OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

BIGNUM-TRUNCATE   compiled function

properties


ID: SB-BIGNUM:BIGNUM-TRUNCATE
ALLOC: HEAP IMMOBILE



BIGNUM-TRUNCATE names a compiled function:
  Lambda-list: (A B)
  Derived type: (FUNCTION (BIGNUM BIGNUM) *)
  Source file: SYS:CONTRIB;SB-GMP;GMP.LISP.NEWEST
definitions
  • SYS:CONTRIB;SB-GMP;GMP.LISP.NEWEST

BIGNUM-INTEGER-LENGTH   compiled function

properties


ID: SB-BIGNUM:BIGNUM-INTEGER-LENGTH
ALLOC: HEAP IMMOBILE



BIGNUM-INTEGER-LENGTH names a compiled function:
  Lambda-list: (BIGNUM)
  Derived type: (FUNCTION (BIGNUM) (VALUES (MOD 274877906880) &OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

SXHASH-BIGNUM-DOUBLE-FLOAT   compiled function

properties


ID: SB-BIGNUM:SXHASH-BIGNUM-DOUBLE-FLOAT
ALLOC: HEAP IMMOBILE



SXHASH-BIGNUM-DOUBLE-FLOAT names a compiled function:
  Lambda-list: (NUMBER)
  Declared type: (FUNCTION (DOUBLE-FLOAT) (VALUES (UNSIGNED-BYTE 62)&OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count, fixed-args
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;COMPILER;FNDB.LISP
    • SB-C::FOLDER
  • SYS:SRC;COMPILER;FNDB.LISP

BIGNUM-PLUS-P   compiled function

properties


ID: SB-BIGNUM:BIGNUM-PLUS-P
ALLOC: HEAP IMMOBILE



BIGNUM-PLUS-P names a compiled function:
  Lambda-list: (BIGNUM)
  Derived type: (FUNCTION (BIGNUM) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

%ALLOCATE-BIGNUM

properties


ID: SB-BIGNUM:%ALLOCATE-BIGNUM
ALLOC: HEAP IMMOBILE



%ALLOCATE-BIGNUM names an undefined function
  Declared type: (FUNCTION ((UNSIGNED-BYTE 32)) (VALUES BIGNUM &OPTIONAL))
  • Called by
    • SB-GMP::ALLOCATE-BIGNUM
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP
  • SYS:SRC;COMPILER;GENERIC;VM-MACS.LISP
    • SB-C:IR2-CONVERT

MULTIPLY-BIGNUM-AND-FIXNUM   compiled function

properties


ID: SB-BIGNUM:MULTIPLY-BIGNUM-AND-FIXNUM
ALLOC: HEAP IMMOBILE



MULTIPLY-BIGNUM-AND-FIXNUM names a compiled function:
  Lambda-list: (BIGNUM FIXNUM)
  Derived type: (FUNCTION (BIGNUM FIXNUM) (VALUES (OR NULL INTEGER) &OPTIONAL))
  Inline proclamation: NOTINLINE (no inline expansion available)
  Source file: SYS:SRC;CODE;X86-64-VM.LISP
definitions
  • SYS:SRC;CODE;X86-64-VM.LISP

BIGNUM-COMPARE   compiled function

properties


ID: SB-BIGNUM:BIGNUM-COMPARE
ALLOC: HEAP IMMOBILE



BIGNUM-COMPARE names a compiled function:
  Lambda-list: (A B)
  Declared type: (FUNCTION (BIGNUM BIGNUM) (VALUES (INTEGER -1 1) &REST T))
  Derived type: (FUNCTION (BIGNUM BIGNUM) (VALUES (INTEGER -1 1) &OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

BIGNUM-GCD   compiled function

properties


ID: SB-BIGNUM:BIGNUM-GCD
ALLOC: HEAP IMMOBILE



BIGNUM-GCD names a compiled function:
  Lambda-list: (A B)
  Derived type: (FUNCTION (INTEGER INTEGER) (VALUES INTEGER &OPTIONAL))
  Source file: SYS:CONTRIB;SB-GMP;GMP.LISP.NEWEST
definitions
  • SYS:CONTRIB;SB-GMP;GMP.LISP.NEWEST

%MULTIPLY

properties


ID: SB-BIGNUM:%MULTIPLY
ALLOC: HEAP IMMOBILE



%MULTIPLY names an undefined function
  Declared type: (FUNCTION ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64))
                  (VALUES (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64) &OPTIONAL))
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

BIGNUM-LOGICAL-IOR   compiled function

properties


ID: SB-BIGNUM:BIGNUM-LOGICAL-IOR
ALLOC: HEAP IMMOBILE



BIGNUM-LOGICAL-IOR names a compiled function:
  Lambda-list: (A B)
  Derived type: (FUNCTION (BIGNUM BIGNUM) (VALUES (OR NULL INTEGER) &OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

BIGNUM-ASHIFT-LEFT   compiled function

properties


ID: SB-BIGNUM:BIGNUM-ASHIFT-LEFT
ALLOC: HEAP IMMOBILE



BIGNUM-ASHIFT-LEFT names a compiled function:
  Lambda-list: (BIGNUM X &OPTIONAL BIGNUM-LEN)
  Derived type: (FUNCTION
                 (BIGNUM UNSIGNED-BYTE &OPTIONAL (OR NULL (UNSIGNED-BYTE 32)))
                 (VALUES (OR NULL INTEGER) &OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

BIGNUM-LOGICAL-NOT   compiled function

properties


ID: SB-BIGNUM:BIGNUM-LOGICAL-NOT
ALLOC: HEAP IMMOBILE



BIGNUM-LOGICAL-NOT names a compiled function:
  Lambda-list: (A)
  Derived type: (FUNCTION (BIGNUM) (VALUES BIGNUM &OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

%UNARY-TRUNCATE-SINGLE-FLOAT-TO-BIGNUM   compiled function

properties


ID: SB-BIGNUM:%UNARY-TRUNCATE-SINGLE-FLOAT-TO-BIGNUM
ALLOC: HEAP IMMOBILE



%UNARY-TRUNCATE-SINGLE-FLOAT-TO-BIGNUM names a compiled function:
  Lambda-list: (NUMBER)
  Declared type: (FUNCTION (SINGLE-FLOAT) (VALUES BIGNUM &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count, fixed-args
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;COMPILER;FNDB.LISP
    • SB-C::FOLDER
  • SYS:SRC;COMPILER;FNDB.LISP

BIGNUM-TO-SINGLE-FLOAT   compiled function

properties


ID: SB-BIGNUM:BIGNUM-TO-SINGLE-FLOAT
ALLOC: HEAP IMMOBILE



BIGNUM-TO-SINGLE-FLOAT names a compiled function:
  Lambda-list: (BIGNUM)
  Declared type: (FUNCTION (BIGNUM) (VALUES SINGLE-FLOAT &OPTIONAL))
  Known attributes: foldable, movable, no-verify-arg-count, unboxed-return
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP
    • SB-C::FOLDER
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

%SUBTRACT-WITH-BORROW

properties


ID: SB-BIGNUM:%SUBTRACT-WITH-BORROW
ALLOC: HEAP IMMOBILE



%SUBTRACT-WITH-BORROW names an undefined function
  Declared type: (FUNCTION ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64) BIT)
                  (VALUES (UNSIGNED-BYTE 64) BIT &OPTIONAL))
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

UNARY-TRUNCATE-SINGLE-FLOAT-TO-BIGNUM-DIV   compiled function

properties


ID: SB-BIGNUM:UNARY-TRUNCATE-SINGLE-FLOAT-TO-BIGNUM-DIV
ALLOC: HEAP IMMOBILE



UNARY-TRUNCATE-SINGLE-FLOAT-TO-BIGNUM-DIV names a compiled function:
  Lambda-list: (QUOT NUMBER DIVISOR)
  Declared type: (FUNCTION (SINGLE-FLOAT SINGLE-FLOAT SINGLE-FLOAT)
                  (VALUES BIGNUM SINGLE-FLOAT &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count, fixed-args, unboxed-return
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;COMPILER;FNDB.LISP
    • SB-C::FOLDER
  • SYS:SRC;COMPILER;FLOAT-TRAN.LISP
  • SYS:SRC;COMPILER;FNDB.LISP

BIGNUM-LOGICAL-AND   compiled function

properties


ID: SB-BIGNUM:BIGNUM-LOGICAL-AND
ALLOC: HEAP IMMOBILE



BIGNUM-LOGICAL-AND names a compiled function:
  Lambda-list: (A B)
  Derived type: (FUNCTION (BIGNUM BIGNUM) (VALUES (OR NULL INTEGER) &OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

UNARY-TRUNCATE-DOUBLE-FLOAT-TO-BIGNUM-DIV   compiled function

properties


ID: SB-BIGNUM:UNARY-TRUNCATE-DOUBLE-FLOAT-TO-BIGNUM-DIV
ALLOC: HEAP IMMOBILE



UNARY-TRUNCATE-DOUBLE-FLOAT-TO-BIGNUM-DIV names a compiled function:
  Lambda-list: (QUOT NUMBER DIVISOR)
  Declared type: (FUNCTION (DOUBLE-FLOAT DOUBLE-FLOAT DOUBLE-FLOAT)
                  (VALUES BIGNUM DOUBLE-FLOAT &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count, fixed-args, unboxed-return
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;COMPILER;FNDB.LISP
    • SB-C::FOLDER
  • SYS:SRC;COMPILER;FLOAT-TRAN.LISP
  • SYS:SRC;COMPILER;FNDB.LISP

%BIGNUM-REF

properties


ID: SB-BIGNUM:%BIGNUM-REF
ALLOC: HEAP IMMOBILE



%BIGNUM-REF names an undefined function
  Declared type: (FUNCTION (BIGNUM (MOD 4294967295))
                  (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))

(SETF %BIGNUM-REF) names a compiled function:
  Lambda-list: (VAL BIGNUM INDEX)
  Derived type: (FUNCTION (T T T) (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;BIGNUM.LISP
  • Called by
    • COERCE
    • SB-MPFR:COMPARE
    • SB-MPFR:POWER
    • DIV
    • SB-MPFR:MUL
    • SB-MPFR:SUB
    • SB-MPFR:ADD
    • SB-ACLREPL::COMPONENT-AT
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-TRAN.LISP
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

%BIGNUM-LENGTH   compiled function

properties


ID: SB-BIGNUM:%BIGNUM-LENGTH
ALLOC: HEAP IMMOBILE



%BIGNUM-LENGTH names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (BIGNUM) (VALUES (INTEGER 1 4294967295) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, always-translatable
  Source file: SYS:SRC;CODE;STUBS.LISP
  • Called by
    • COERCE
    • SB-MPFR:COMPARE
    • SB-MPFR:POWER
    • DIV
    • SB-MPFR:MUL
    • SB-MPFR:SUB
    • SB-MPFR:ADD
    • (INSPECTED-PARTS (BIGNUM))
    • (INSPECTED-DESCRIPTION (BIGNUM))
definitions
  • SYS:SRC;CODE;STUBS.LISP
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP
  • SYS:SRC;COMPILER;SRCTRAN.LISP
    • SB-C:DERIVE-TYPE

BIT-INDEX

properties


ID: SB-BIGNUM:BIT-INDEX
ALLOC: HEAP IMMOBILE



BIT-INDEX names a type-specifier:
  Lambda-list: ()
  Expansion: (INTEGER 0 274877906943)
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-TYPE.LISP

SUBTRACT-FIXNUM-BIGNUM   compiled function

properties


ID: SB-BIGNUM:SUBTRACT-FIXNUM-BIGNUM
ALLOC: HEAP IMMOBILE



SUBTRACT-FIXNUM-BIGNUM names a compiled function:
  Lambda-list: (A B)
  Declared type: (FUNCTION (FIXNUM BIGNUM) (VALUES INTEGER &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, movable, no-verify-arg-count
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;COMPILER;FNDB.LISP

%ADD-WITH-CARRY

properties


ID: SB-BIGNUM:%ADD-WITH-CARRY
ALLOC: HEAP IMMOBILE



%ADD-WITH-CARRY names an undefined function
  Declared type: (FUNCTION ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64) BIT)
                  (VALUES (UNSIGNED-BYTE 64) BIT &OPTIONAL))
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

BIGNUM-ASHIFT-RIGHT   compiled function

properties


ID: SB-BIGNUM:BIGNUM-ASHIFT-RIGHT
ALLOC: HEAP IMMOBILE



BIGNUM-ASHIFT-RIGHT names a compiled function:
  Lambda-list: (BIGNUM COUNT)
  Derived type: (FUNCTION (BIGNUM UNSIGNED-BYTE)
                 (VALUES (OR NULL INTEGER) &OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

%RANDOM-BIGNUM   compiled function

properties


ID: SB-BIGNUM:%RANDOM-BIGNUM
ALLOC: HEAP IMMOBILE



%RANDOM-BIGNUM names a compiled function:
  Lambda-list: (ARG STATE)
  Derived type: (FUNCTION ((INTEGER 4611686018427387904) RANDOM-STATE)
                 (VALUES (OR NULL INTEGER) &OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM-RANDOM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM-RANDOM.LISP

SUBTRACT-BIGNUM-FIXNUM   compiled function

properties


ID: SB-BIGNUM:SUBTRACT-BIGNUM-FIXNUM
ALLOC: HEAP IMMOBILE



SUBTRACT-BIGNUM-FIXNUM names a compiled function:
  Lambda-list: (A B)
  Declared type: (FUNCTION (BIGNUM FIXNUM) (VALUES INTEGER &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, movable, no-verify-arg-count
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;COMPILER;FNDB.LISP

BIGNUM-LENGTH   vop

properties


ID: SB-BIGNUM:BIGNUM-LENGTH
ALLOC: HEAP IMMOBILE



BIGNUM-LENGTH names a type-specifier:
  Lambda-list: ()
  Expansion: (MOD 4294967296)
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-TYPE.LISP

%BIGFLOOR

properties


ID: SB-BIGNUM:%BIGFLOOR
ALLOC: HEAP IMMOBILE



%BIGFLOOR names an undefined function
  Declared type: (FUNCTION
                  ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64))
                  (VALUES (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64) &OPTIONAL))
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

BIGNUM-LOGCOUNT   compiled function

properties


ID: SB-BIGNUM:BIGNUM-LOGCOUNT
ALLOC: HEAP IMMOBILE



BIGNUM-LOGCOUNT names a compiled function:
  Lambda-list: (BIGNUM)
  Derived type: (FUNCTION (BIGNUM)
                 (VALUES (INTEGER -274877906816 274877906880) &OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

SUBTRACT-BIGNUM   compiled function

properties


ID: SB-BIGNUM:SUBTRACT-BIGNUM
ALLOC: HEAP IMMOBILE



SUBTRACT-BIGNUM names a compiled function:
  Lambda-list: (A B)
  Declared type: (FUNCTION (BIGNUM BIGNUM) (VALUES INTEGER &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, movable, no-verify-arg-count
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;COMPILER;FNDB.LISP

MAKE-SMALL-BIGNUM   compiled function

properties


ID: SB-BIGNUM:MAKE-SMALL-BIGNUM
ALLOC: HEAP IMMOBILE



MAKE-SMALL-BIGNUM names a compiled function:
  Lambda-list: (FIXNUM)
  Derived type: (FUNCTION (T) (VALUES BIGNUM &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

%ASHR

properties


ID: SB-BIGNUM:%ASHR
ALLOC: HEAP IMMOBILE



%ASHR names an undefined function
  Declared type: (FUNCTION ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 6))
                  (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

UNARY-TRUNCATE-DOUBLE-FLOAT-TO-BIGNUM   compiled function

properties


ID: SB-BIGNUM:UNARY-TRUNCATE-DOUBLE-FLOAT-TO-BIGNUM
ALLOC: HEAP IMMOBILE



UNARY-TRUNCATE-DOUBLE-FLOAT-TO-BIGNUM names a compiled function:
  Lambda-list: (NUMBER)
  Declared type: (FUNCTION (DOUBLE-FLOAT)
                  (VALUES BIGNUM (MEMBER 0.0d0) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count, fixed-args, unboxed-return
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;CODE;NUMBERS.LISP
    • SB-C::FOLDER
  • SYS:SRC;COMPILER;FNDB.LISP

MULTIPLY-BIGNUMS   compiled function

properties


ID: SB-BIGNUM:MULTIPLY-BIGNUMS
ALLOC: HEAP IMMOBILE



MULTIPLY-BIGNUMS names a compiled function:
  Lambda-list: (A B)
  Derived type: (FUNCTION (BIGNUM BIGNUM) *)
  Source file: SYS:CONTRIB;SB-GMP;GMP.LISP.NEWEST
definitions
  • SYS:CONTRIB;SB-GMP;GMP.LISP.NEWEST

BIGNUM-LOGICAL-XOR   compiled function

properties


ID: SB-BIGNUM:BIGNUM-LOGICAL-XOR
ALLOC: HEAP IMMOBILE



BIGNUM-LOGICAL-XOR names a compiled function:
  Lambda-list: (A B)
  Derived type: (FUNCTION (BIGNUM BIGNUM) (VALUES (OR NULL INTEGER) &OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

BIGNUM-TO-DOUBLE-FLOAT   compiled function

properties


ID: SB-BIGNUM:BIGNUM-TO-DOUBLE-FLOAT
ALLOC: HEAP IMMOBILE



BIGNUM-TO-DOUBLE-FLOAT names a compiled function:
  Lambda-list: (BIGNUM)
  Declared type: (FUNCTION (BIGNUM) (VALUES DOUBLE-FLOAT &OPTIONAL))
  Known attributes: foldable, movable, no-verify-arg-count, unboxed-return
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP
    • SB-C::FOLDER
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

BIGNUM-ELEMENT-TYPE

properties


ID: SB-BIGNUM:BIGNUM-ELEMENT-TYPE
ALLOC: HEAP IMMOBILE



BIGNUM-ELEMENT-TYPE names a type-specifier:
  Lambda-list: ()
  Expansion: WORD
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-TYPE.LISP

%MULTIPLY-AND-ADD

properties


ID: SB-BIGNUM:%MULTIPLY-AND-ADD
ALLOC: HEAP IMMOBILE



%MULTIPLY-AND-ADD names an undefined function
  Declared type: (FUNCTION
                  ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64)
                   &OPTIONAL (UNSIGNED-BYTE 64))
                  (VALUES (UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64) &OPTIONAL))
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

BIGNUM-INDEX

properties


ID: SB-BIGNUM:BIGNUM-INDEX
ALLOC: HEAP IMMOBILE



BIGNUM-INDEX names a type-specifier:
  Lambda-list: ()
  Expansion: (MOD 4294967295)
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-TYPE.LISP

BIGNUM-ASHIFT-LEFT-FIXNUM   compiled function

properties


ID: SB-BIGNUM:BIGNUM-ASHIFT-LEFT-FIXNUM
ALLOC: HEAP IMMOBILE



BIGNUM-ASHIFT-LEFT-FIXNUM names a compiled function:
  Lambda-list: (FIXNUM COUNT)
  Derived type: (FUNCTION (FIXNUM (UNSIGNED-BYTE 62)) (VALUES BIGNUM&OPTIONAL))
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP

MAXIMUM-BIGNUM-LENGTH   constant var

properties


ID: SB-BIGNUM:MAXIMUM-BIGNUM-LENGTH
ALLOC: HEAP IMMOBILE



MAXIMUM-BIGNUM-LENGTH names a constant variable:
  Value: 4294967295
definitions
  • SYS:SRC;COMPILER;GENERIC;EARLY-VM.LISP

UNARY-TRUNCATE-SINGLE-FLOAT-TO-BIGNUM   compiled function

properties


ID: SB-BIGNUM:UNARY-TRUNCATE-SINGLE-FLOAT-TO-BIGNUM
ALLOC: HEAP IMMOBILE



UNARY-TRUNCATE-SINGLE-FLOAT-TO-BIGNUM names a compiled function:
  Lambda-list: (NUMBER)
  Declared type: (FUNCTION (SINGLE-FLOAT)
                  (VALUES BIGNUM (MEMBER 0.0) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count, fixed-args
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;CODE;NUMBERS.LISP
    • SB-C::FOLDER
  • SYS:SRC;COMPILER;FNDB.LISP

%FIXNUM-DIGIT-WITH-CORRECT-SIGN

properties


ID: SB-BIGNUM:%FIXNUM-DIGIT-WITH-CORRECT-SIGN
ALLOC: HEAP IMMOBILE



%FIXNUM-DIGIT-WITH-CORRECT-SIGN names an undefined function
  Declared type: (FUNCTION ((UNSIGNED-BYTE 64))
                  (VALUES (SIGNED-BYTE 64) &OPTIONAL))
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

%DIGIT-LOGICAL-SHIFT-RIGHT

properties


ID: SB-BIGNUM:%DIGIT-LOGICAL-SHIFT-RIGHT
ALLOC: HEAP IMMOBILE



%DIGIT-LOGICAL-SHIFT-RIGHT names an undefined function
  Declared type: (FUNCTION ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 6))
                  (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
definitions
  • SYS:SRC;COMPILER;GENERIC;VM-FNDB.LISP

SXHASH-BIGNUM-SINGLE-FLOAT   compiled function

properties


ID: SB-BIGNUM:SXHASH-BIGNUM-SINGLE-FLOAT
ALLOC: HEAP IMMOBILE



SXHASH-BIGNUM-SINGLE-FLOAT names a compiled function:
  Lambda-list: (NUMBER)
  Declared type: (FUNCTION (SINGLE-FLOAT) (VALUES (UNSIGNED-BYTE 62)&OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count, fixed-args
  Source file: SYS:SRC;CODE;BIGNUM.LISP
definitions
  • SYS:SRC;CODE;BIGNUM.LISP
  • SYS:SRC;COMPILER;FNDB.LISP
    • SB-C::FOLDER
  • SYS:SRC;COMPILER;FNDB.LISP