# SingleIntegerΒΆ

SingleInteger is intended to support machine integer arithmetic.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from LeftModule %

*: (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

_|_: %
~=: (%, %) -> Boolean

from BasicType

~: % -> %

`~ n` returns the bit-by-bit logical not of the single integer `n`.

abs: % -> %

from OrderedRing

addmod: (%, %, %) -> %
And: (%, %) -> %

`And(n, m)` returns the bit-by-bit logical and of the single integers `n` and `m`.

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %
associates?: (%, %) -> Boolean

from EntireRing

associator: (%, %, %) -> %
base: () -> %
binomial: (%, %) -> %
bit?: (%, %) -> Boolean
characteristic: () -> NonNegativeInteger
coerce: % -> %

from Algebra %

coerce: % -> OutputForm
coerce: Integer -> %
commutator: (%, %) -> %
convert: % -> DoubleFloat
convert: % -> Float
convert: % -> InputForm
convert: % -> Integer
convert: % -> Pattern Integer
convert: % -> String
copy: % -> %
D: % -> %

from DifferentialRing

D: (%, NonNegativeInteger) -> %

from DifferentialRing

dec: % -> %
differentiate: % -> %

from DifferentialRing

differentiate: (%, NonNegativeInteger) -> %

from DifferentialRing

divide: (%, %) -> Record(quotient: %, remainder: %)

from EuclideanDomain

euclideanSize: % -> NonNegativeInteger

from EuclideanDomain

even?: % -> Boolean
expressIdealMember: (List %, %) -> Union(List %, failed)
exquo: (%, %) -> Union(%, failed)

from EntireRing

extendedEuclidean: (%, %) -> Record(coef1: %, coef2: %, generator: %)

from EuclideanDomain

extendedEuclidean: (%, %, %) -> Union(Record(coef1: %, coef2: %), failed)

from EuclideanDomain

factor: % -> Factored %
factorial: % -> %
false: %

from Logic

gcd: (%, %) -> %

from GcdDomain

gcd: List % -> %

from GcdDomain

gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial %

from GcdDomain

hash: % -> SingleInteger

from Hashable

hashUpdate!: (HashState, %) -> HashState

from Hashable

inc: % -> %
init: %

from StepThrough

invmod: (%, %) -> %
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: % -> %
max: (%, %) -> %

from OrderedSet

max: () -> %

`max()` returns the largest single integer.

min: (%, %) -> %

from OrderedSet

min: () -> %

`min()` returns the smallest single integer.

mulmod: (%, %, %) -> %
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
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, %)
permutation: (%, %) -> %
plenaryPower: (%, PositiveInteger) -> %
positive?: % -> Boolean

from OrderedRing

positiveRemainder: (%, %) -> %
powmod: (%, %, %) -> %
prime?: % -> Boolean
principalIdeal: List % -> Record(coef: List %, generator: %)
qconvert: Integer -> %

`qconvert(x)` converts `x` to % trusting that `x` is in correct range.

quo: (%, %) -> %

from EuclideanDomain

random: % -> %
rational?: % -> Boolean
rational: % -> Fraction Integer
rationalIfCan: % -> Union(Fraction Integer, failed)
recip: % -> Union(%, failed)

from MagmaWithUnit

rem: (%, %) -> %

from EuclideanDomain

retract: % -> Integer
retractIfCan: % -> Union(Integer, failed)
rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

sample: %

from AbelianMonoid

shift: (%, %) -> %
sign: % -> Integer

from OrderedRing

sizeLess?: (%, %) -> Boolean

from EuclideanDomain

smaller?: (%, %) -> Boolean

from Comparable

squareFree: % -> Factored %
squareFreePart: % -> %
submod: (%, %, %) -> %
subtractIfCan: (%, %) -> Union(%, failed)
symmetricRemainder: (%, %) -> %
T: %
true: %

from Logic

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

BasicType

BiModule(%, %)

BoundedDistributiveLattice

BoundedJoinSemilattice

BoundedLattice

BoundedMeetSemilattice

CancellationAbelianMonoid

Canonical

canonicalsClosed

canonicalUnitNormal

CharacteristicZero

CombinatorialFunctionCategory

CommutativeRing

CommutativeStar

Comparable

DifferentialRing

DistributiveLattice

EntireRing

EuclideanDomain

GcdDomain

Hashable

IntegerNumberSystem

IntegralDomain

JoinSemilattice

Lattice

LeftOreRing

Logic

Magma

MagmaWithUnit

MeetSemilattice

Monoid

multiplicativeValuation

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

OpenMath

OrderedAbelianGroup

OrderedAbelianMonoid

OrderedAbelianSemiGroup

OrderedCancellationAbelianMonoid

OrderedIntegralDomain

OrderedRing

OrderedSet

PartialOrder

PrincipalIdealDomain

RealConstant

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

StepThrough

TwoSidedRecip

UniqueFactorizationDomain

unitsKnown