SingleIntegerΒΆ

si.spad line 143

SingleInteger is intended to support machine integer arithmetic.

0: %
from AbelianMonoid
1: %
from MagmaWithUnit
*: (%, %) -> %
from Magma
*: (Integer, %) -> %
from AbelianGroup
*: (NonNegativeInteger, %) -> %
from AbelianMonoid
*: (PositiveInteger, %) -> %
from AbelianSemiGroup
+: (%, %) -> %
from AbelianSemiGroup
-: % -> %
from AbelianGroup
-: (%, %) -> %
from AbelianGroup
/\: (%, %) -> %
n /\ m returns the bit-by-bit logical and of the single integers n and m.
<: (%, %) -> Boolean
from PartialOrder
<=: (%, %) -> Boolean
from PartialOrder
=: (%, %) -> Boolean
from BasicType
>: (%, %) -> Boolean
from PartialOrder
>=: (%, %) -> Boolean
from PartialOrder
\/: (%, %) -> %
n \/ m returns the bit-by-bit logical or of the single integers n and m.
^: (%, NonNegativeInteger) -> %
from MagmaWithUnit
^: (%, PositiveInteger) -> %
from Magma
_|_: %
from BoundedJoinSemilattice
~: % -> %
~ n returns the bit-by-bit logical not of the single integer n.
~=: (%, %) -> Boolean
from BasicType
abs: % -> %
from OrderedRing
addmod: (%, %, %) -> %
from IntegerNumberSystem
And: (%, %) -> %
And(n, m) returns the bit-by-bit logical and of the single integers n and m.
annihilate?: (%, %) -> Boolean
from Rng
antiCommutator: (%, %) -> %
from NonAssociativeSemiRng
associates?: (%, %) -> Boolean
from EntireRing
associator: (%, %, %) -> %
from NonAssociativeRng
base: () -> %
from IntegerNumberSystem
binomial: (%, %) -> %
from CombinatorialFunctionCategory
bit?: (%, %) -> Boolean
from IntegerNumberSystem
characteristic: () -> NonNegativeInteger
from NonAssociativeRing
coerce: % -> %
from Algebra %
coerce: % -> OutputForm
from CoercibleTo OutputForm
coerce: Integer -> %
from NonAssociativeRing
commutator: (%, %) -> %
from NonAssociativeRng
convert: % -> DoubleFloat
from ConvertibleTo DoubleFloat
convert: % -> Float
from ConvertibleTo Float
convert: % -> InputForm
from ConvertibleTo InputForm
convert: % -> Integer
from ConvertibleTo Integer
convert: % -> Pattern Integer
from ConvertibleTo Pattern Integer
convert: % -> String
from ConvertibleTo String
copy: % -> %
from IntegerNumberSystem
D: % -> %
from DifferentialRing
D: (%, NonNegativeInteger) -> %
from DifferentialRing
dec: % -> %
from IntegerNumberSystem
differentiate: % -> %
from DifferentialRing
differentiate: (%, NonNegativeInteger) -> %
from DifferentialRing
divide: (%, %) -> Record(quotient: %, remainder: %)
from EuclideanDomain
euclideanSize: % -> NonNegativeInteger
from EuclideanDomain
even?: % -> Boolean
from IntegerNumberSystem
expressIdealMember: (List %, %) -> Union(List %, failed)
from PrincipalIdealDomain
exquo: (%, %) -> Union(%, failed)
from EntireRing
extendedEuclidean: (%, %) -> Record(coef1: %, coef2: %, generator: %)
from EuclideanDomain
extendedEuclidean: (%, %, %) -> Union(Record(coef1: %, coef2: %), failed)
from EuclideanDomain
factor: % -> Factored %
from UniqueFactorizationDomain
factorial: % -> %
from CombinatorialFunctionCategory
gcd: (%, %) -> %
from GcdDomain
gcd: List % -> %
from GcdDomain
gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial %
from GcdDomain
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
inc: % -> %
from IntegerNumberSystem
init: %
from StepThrough
invmod: (%, %) -> %
from IntegerNumberSystem
latex: % -> String
from SetCategory
lcm: (%, %) -> %
from GcdDomain
lcm: List % -> %
from GcdDomain
lcmCoef: (%, %) -> Record(llcm_res: %, coeff1: %, coeff2: %)
from LeftOreRing
leftPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
leftPower: (%, PositiveInteger) -> %
from Magma
leftRecip: % -> Union(%, failed)
from MagmaWithUnit
length: % -> %
from IntegerNumberSystem
mask: % -> %
from IntegerNumberSystem
max: (%, %) -> %
from OrderedSet
max: () -> %
max() returns the largest single integer.
min: (%, %) -> %
from OrderedSet
min: () -> %
min() returns the smallest single integer.
mulmod: (%, %, %) -> %
from IntegerNumberSystem
multiEuclidean: (List %, %) -> Union(List %, failed)
from EuclideanDomain
negative?: % -> Boolean
from OrderedRing
nextItem: % -> Union(%, failed)
from StepThrough
Not: % -> %
Not(n) returns the bit-by-bit logical not of the single integer n.
not: % -> %
not(n) returns the bit-by-bit logical not of the single integer n.
odd?: % -> Boolean
from IntegerNumberSystem
OMwrite: % -> String
from OpenMath
OMwrite: (%, Boolean) -> String
from OpenMath
OMwrite: (OpenMathDevice, %) -> Void
from OpenMath
OMwrite: (OpenMathDevice, %, Boolean) -> Void
from OpenMath
one?: % -> Boolean
from MagmaWithUnit
opposite?: (%, %) -> Boolean
from AbelianMonoid
Or: (%, %) -> %
Or(n, m) returns the bit-by-bit logical or of the single integers n and m.
patternMatch: (%, Pattern Integer, PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %)
from PatternMatchable Integer
permutation: (%, %) -> %
from CombinatorialFunctionCategory
positive?: % -> Boolean
from OrderedRing
positiveRemainder: (%, %) -> %
from IntegerNumberSystem
powmod: (%, %, %) -> %
from IntegerNumberSystem
prime?: % -> Boolean
from UniqueFactorizationDomain
principalIdeal: List % -> Record(coef: List %, generator: %)
from PrincipalIdealDomain
qconvert: Integer -> %
qconvert(x) converts x to % trusting that x is in correct range.
quo: (%, %) -> %
from EuclideanDomain
random: % -> %
from IntegerNumberSystem
rational: % -> Fraction Integer
from IntegerNumberSystem
rational?: % -> Boolean
from IntegerNumberSystem
rationalIfCan: % -> Union(Fraction Integer, failed)
from IntegerNumberSystem
recip: % -> Union(%, failed)
from MagmaWithUnit
rem: (%, %) -> %
from EuclideanDomain
retract: % -> Integer
from RetractableTo Integer
retractIfCan: % -> Union(Integer, failed)
from RetractableTo Integer
rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
rightPower: (%, PositiveInteger) -> %
from Magma
rightRecip: % -> Union(%, failed)
from MagmaWithUnit
sample: %
from AbelianMonoid
shift: (%, %) -> %
from IntegerNumberSystem
sign: % -> Integer
from OrderedRing
sizeLess?: (%, %) -> Boolean
from EuclideanDomain
smaller?: (%, %) -> Boolean
from Comparable
squareFree: % -> Factored %
from UniqueFactorizationDomain
squareFreePart: % -> %
from UniqueFactorizationDomain
submod: (%, %, %) -> %
from IntegerNumberSystem
subtractIfCan: (%, %) -> Union(%, failed)
from CancellationAbelianMonoid
symmetricRemainder: (%, %) -> %
from IntegerNumberSystem
T: %
from BoundedMeetSemilattice
unit?: % -> Boolean
from EntireRing
unitCanonical: % -> %
from EntireRing
unitNormal: % -> Record(unit: %, canonical: %, associate: %)
from EntireRing
xor: (%, %) -> %
xor(n, m) returns the bit-by-bit logical xor of the single integers n and m.
zero?: % -> Boolean
from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra %

BasicType

BiModule(%, %)

BoundedDistributiveLattice

BoundedJoinSemilattice

BoundedLattice

BoundedMeetSemilattice

CancellationAbelianMonoid

Canonical

canonicalsClosed

canonicalUnitNormal

CharacteristicZero

CoercibleTo OutputForm

CombinatorialFunctionCategory

CommutativeRing

CommutativeStar

Comparable

ConvertibleTo DoubleFloat

ConvertibleTo Float

ConvertibleTo InputForm

ConvertibleTo Integer

ConvertibleTo Pattern Integer

ConvertibleTo String

DifferentialRing

DistributiveLattice

EntireRing

EuclideanDomain

GcdDomain

IntegerNumberSystem

IntegralDomain

JoinSemilattice

Lattice

LeftModule %

LeftOreRing

Logic

Magma

MagmaWithUnit

MeetSemilattice

Module %

Monoid

multiplicativeValuation

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

OpenMath

OrderedAbelianGroup

OrderedAbelianMonoid

OrderedAbelianSemiGroup

OrderedCancellationAbelianMonoid

OrderedIntegralDomain

OrderedRing

OrderedSet

PartialOrder

PatternMatchable Integer

PrincipalIdealDomain

RealConstant

RetractableTo Integer

RightModule %

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

StepThrough

UniqueFactorizationDomain

unitsKnown