integer
Factor handbook » The language » Numbers » Integers

Next:

fixnum? ( object -- ? )

Vocabulary
math

Class description
The class of integers, which is a disjoint union of fixnums and bignums.

Definition

IN: math

UNION: integer fixnum bignum ;

Methods

USING: cpu.arm.32.assembler.private math ;

M: integer (B) { 24 { 1 25 } { 0 26 } { 1 27 } 0 } insn ;


USING: kernel math math.bitwise.private ;

M: integer (bitfield-quot) [ shift ] curry ;


USING: math math.functions.private math.private ;

M: integer (integer-log2) (log2) ; inline


USING: io kernel math serialize serialize.private ;

M: integer (serialize)
    [ 122 write1 ]
    [ dup 0 < [ neg 109 ] [ 112 ] if write1 serialize-cell ]
    if-zero ;


USING: calendar calendar.private kernel math ;

M: integer +day
    [
        over >date< julian-day-number +
        julian-day-number>date set-date
    ] unless-zero ;


USING: accessors calendar.private kernel math ;

M: integer +hour
    [ over hour>> + hours/days [ >>hour ] dip +day ] unless-zero
    ;


USING: accessors calendar.private kernel math ;

M: integer +minute
    [ over minute>> + minutes/hours [ >>minute ] dip +hour ]
    unless-zero ;


USING: accessors calendar calendar.private kernel math
math.order ;

M: integer +month
    [
        over month>> + months/years
        [ >>month dup days-in-month [ min ] curry change-day ]
        dip +year
    ] unless-zero ;


USING: accessors calendar.private kernel math ;

M: integer +year [ + ] curry change-year adjust-leap-year ;


USING: kernel math math.ratios math.ratios.private ;

M: integer /
    [ division-by-zero ] [
        dup 0 < [ [ neg ] bi@ ] when 2dup simple-gcd
        [ /i ] curry bi@ fraction>
    ] if-zero ;


USING: alien.c-types alien.data core-foundation.numbers kernel
math ;

M: integer <CFNumber>
    [ f kCFNumberLongLongType ] dip longlong <ref>
    CFNumberCreate ;


USING: kernel math mongodb.msg sequences ;

M: integer <mdb-killcursors-msg>
    V{ } clone [ push ] keep <mdb-killcursors-msg> ;


USING: destructors grouping io.pipes io.pipes.private kernel
math sequences ;

M: integer <pipes>
    [
        [ (pipe) |dispose ] replicate
        T{ pipe } [ prefix ] [ suffix ] bi 2 <clumps>
    ] with-destructors ;


USING: math math.matrices sequences ;

M: integer <square-cols> <iota> <square-cols> ;


USING: math math.matrices sequences ;

M: integer <square-rows> <iota> <square-rows> ;


USING: combinators kernel math math.parser math.parser.private
sequences ;

M: integer >base
    {
        { [ over 0 = ] [ 2drop "0" ] }
        { [ over 0 > ] [ positive>base ] }
        [ [ neg ] dip positive>base 45 prefix ]
    } cond ;


USING: bencode math math.parser sequences ;

M: integer >bencode number>string "i" "e" surround ;


USING: math poker.private ;

M: integer >ckf ;


USING: math ;

M: integer >fraction 1 ; inline


USING: arrays io.servers io.servers.private math ;

M: integer >insecure internet-server 1array ;


USING: endian math pack ;

M: integer >n-byte-array >endian ;


USING: cpu.ppc.assembler math ;

M: integer B -2 shift 0 0 18 i-insn ;


USING: cpu.ppc.assembler math ;

M: integer BC -2 shift 0 0 16 b-insn ;


USING: cpu.ppc.assembler math ;

M: integer BL -2 shift 0 1 18 i-insn ;


USING: cpu.x86.assembler cpu.x86.assembler.private make math ;

M: integer CALL 232 , 4, ;


USING: cpu.x86.assembler cpu.x86.assembler.private make math ;

M: integer JMP 233 , 4, ;


USING: cpu.x86.assembler.private math ;

M: integer JUMPcc extended-opcode, 4, ;


USING: combinators cpu.x86.assembler cpu.x86.assembler.operands
cpu.x86.assembler.private kernel make math ;

M: integer MOVABS
    swap {
        { AL [ 160 , cell, ] }
        { AX [ 102 , 161 , cell, ] }
        { EAX [ 161 , cell, ] }
        { RAX [ 72 , 161 , cell, ] }
        [ swap bad-movabs-operands ]
    } case ;


USING: cpu.arm.32.assembler.private math ;

M: integer addressing-mode-2 ;


USING: cpu.arm.32.assembler.private math math.bitwise ;

M: integer addressing-mode-3
    b>n/n { { 1 22 } { 1 7 } { 1 4 } 0 8 } bitfield ;


USING: calendar math ;

M: integer april 4 1 <date> ;


USING: calendar math ;

M: integer august 8 1 <date> ;


USING: alien.data math ;

M: integer binary-zero? zero? ; inline


USING: math math.bitwise math.bitwise.private ;

M: integer bit-count assert-non-negative (bit-count) ; inline


USING: cuda.libraries.private math ;

M: integer block-dim 1 1 ; inline


USING: kernel math sequences ;

M: integer bounds-check?
    dupd length < [ 0 >= ] [ drop f ] if ; inline


USING: kernel math sequences.deep ;

M: integer branch? drop f ;


USING: alien.c-types math math.parser ;

M: integer c-type-string number>string ;


USING: kernel math regexp.classes ;

M: integer class-member? = ; inline


USING: math math.matrices math.matrices.private ;

M: integer cols-except scalar-except-quot simple-cols-except ;


USING: math tools.disassembler.private ;

M: integer convert-address ;


USING: calendar.english math sequences ;

M: integer day-name day-names nth ;


USING: calendar.format io kernel math math.parser sequences ;

M: integer day. number>string dup length 2 < [ bl ] when write ;


USING: calendar kernel math ;

M: integer days-in-year leap-year? 366 365 ? ;


USING: calendar math ;

M: integer december 12 1 <date> ;


USING: kernel math ;

M: integer denominator drop 1 ; inline


USING: drunken-bishop endian kernel math ;

M: integer drunken-bishop.
    dup log2 8 /mod zero? [ 1 + ] unless >be drunken-bishop. ;


USING: calendar kernel math ;

M: integer easter dup easter-month-day <date> ;


USING: effects math math.parser ;

M: integer effect>string number>string ;


USING: calendar.format kernel make math math.parser sequences
splitting ;

M: integer elapsed-time
    dup 0 < [ "negative seconds" throw ] when [
        {
            { 60 "s" }
            { 60 "m" }
            { 24 "h" }
            { 7 "d" }
            { 52 "w" }
            { f "y" }
        } [
            [ first [ /mod ] [ dup ] if* ] [ second ] bi
            swap dup 0 >
            [ number>string prepend , ] [ 2drop ] if
        ] each drop
    ] { } make [ "0s" ] [ reverse join-words ] if-empty ;


USING: alien.enums math ;

M: integer enum>number ;


USING: calendar math ;

M: integer february 2 1 <date> ;


USING: io.files.info.unix.private math math.bitwise ;

M: integer file-mode? mask? ;


USING: calendar math ;

M: integer first-day-of-year <year> ;


USING: cpu.x86.assembler.private math math.order ;

M: integer fits-in-byte? -128 127 between? ;


USING: kernel math math.functions ;

M: integer frexp
    [ 0.0 0 ] [
        dup 0 > [ 1 ] [ abs -1 ] if swap dup log2 [
            52 swap - shift 4503599627370495 bitand
            0.5 double>bits bitor bits>double
        ] [ 1 + ] bi [ * ] dip
    ] if-zero ; inline


USING: fuel.pprint math prettyprint ;

M: integer fuel-pprint pprint ; inline


USING: io.sockets kernel math tftp ;

M: integer get-tftp-host "127.0.0.1" swap <inet4> ;


USING: cuda.libraries.private math ;

M: integer grid-dim 1 ; inline


USING: kernel math unix unix.ffi unix.groups unix.groups.private
;

M: integer group-struct
    (group-struct) [ [ getgrgid_r ] unix-system-call drop ] keep
    check-group-struct ;


USING: kernel math math.order xml-rpc xml.data
xml.syntax.private ;

M: integer item>xml
    dup 31 2^ neg 31 2^ 1 - between?
    [ "Integers must fit in 32 bits" throw ] unless 1 nenum T{
    xml-chunk
        { seq
            V{
                ""
                T{ tag { name ~name~ } { children ~vector~ } }
                ""
            }
        }
    } interpolate-xml ;


USING: calendar math ;

M: integer january 1 1 <date> ;


USING: json.private math math.parser ;

M: integer json-coerce number>string ;


USING: calendar math ;

M: integer july 7 1 <date> ;


USING: calendar math ;

M: integer june 6 1 <date> ;


USING: calendar math ;

M: integer last-day-of-year 12 31 <date> ;


USING: kernel math math.functions ;

M: integer ldexp
    2dup [ zero? ] either? [ 2drop 0 ] [ shift ] if ;


USING: calendar kernel math math.functions ;

M: integer leap-year? dup 100 divisor? 400 4 ? divisor? ;


USING: geo-ip interval-maps math ;

M: integer lookup-ip ip-intervals interval-at ;


USING: calendar math ;

M: integer march 3 1 <date> ;


USING: calendar math ;

M: integer may 5 1 <date> ;


USING: arrays kernel math regexp.ast regexp.classes regexp.nfa
unicode ;

M: integer modify-class
    case-insensitive option? [
        dup Letter?
        [ [ ch>lower ] [ ch>upper ] bi 2array <or-class> ] when
    ] when ;


USING: calendar.english math sequences ;

M: integer month-name check-month 1 - month-names nth ;


USING: math tools.deploy.test.7 ;

M: integer my-generic sq ;


USING: cpu.x86.assembler.private endian make math ;

M: integer n, >le % ;


USING: math math.vectors.simd.intrinsics.private ;

M: integer native/ /i ; inline


USING: calendar math ;

M: integer november 11 1 <date> ;


USING: math math.hashcodes math.hashcodes.private ;

M: integer number-hashcode 1 hash-fraction ;


USING: kernel math math.functions math.parser math.text.french
math.text.french.private ;

M: integer number>text
    dup abs 102 10^ >= [ number>string ] [ basic ] if ;


USING: math math.text.english math.text.english.private
namespaces ;

M: integer number>text
    [ "zero" ] [ [ (number>text) ] with-scope ] if-zero ;


USING: math ;

M: integer numerator ; inline


USING: calendar math ;

M: integer october 10 1 <date> ;


USING: kernel math zim ;

M: integer read-entry-content
    [ read-entry-index ] keep [ read-entry-content ] curry
    [ f f ] if* ;


USING: kernel math math.ratios math.ratios.private ;

M: integer recip
    1 swap
    [ division-by-zero ]
    [ dup 0 < [ [ neg ] bi@ ] when fraction> ] if-zero ;


USING: cpu.arm.64.assembler.opcodes math ;

M: integer register ;


USING: math math.parser yaml.conversion ;

M: integer represent-scalar number>string ;


USING: math retries ;

M: integer retries* <counted-retries> ;


USING: math math.functions ;

M: integer round ; inline


USING: math math.extras ;

M: integer round-away-from-zero ; inline


USING: math math.functions ;

M: integer round-to-even ; inline


USING: math math.functions ;

M: integer round-to-odd ; inline


USING: math math.matrices math.matrices.private ;

M: integer rows-except scalar-except-quot simple-rows-except ;


USING: calendar math ;

M: integer september 9 1 <date> ;


USING: kernel math sequences sequences.seq ;

M: integer seq-bounds-check?
    tuck lengthd > [ 0 >= ] [ drop f ] if ; inline


USING: math unix.groups unix.groups.private ;

M: integer set-effective-group (set-effective-group) ;


USING: math unix.users unix.users.private ;

M: integer set-effective-user (set-effective-user) ;


USING: io.files.info.unix kernel math ;

M: integer set-file-group f swap set-file-ids ;


USING: io.files.info.unix math ;

M: integer set-file-user f set-file-ids ;


USING: math unix.groups unix.groups.private ;

M: integer set-real-group (set-real-group) ;


USING: math unix.users unix.users.private ;

M: integer set-real-user (set-real-user) ;


USING: cpu.arm.32.assembler.private math math.bitwise ;

M: integer shift-imm/reg
    { { 0 4 } 5 { register 0 } 7 } bitfield ;


USING: cpu.arm.32.assembler cpu.arm.32.assembler.private math ;

M: integer shifter-op 0 <IMM> shifter-op ;


USING: math sequences unix.signals ;

M: integer signal-name 1 - signal-names ?nth ;


USING: kernel math threads threads.private ;

M: integer sleep-until
    [ self ] dip schedule-sleep "sleep" suspend drop ;


USING: math math.text.english text-to-speech ;

M: integer speak number>text speak-text ;


USING: io json kernel math math.parser ;

M: integer stream-write-json
    [ number>string ] [ stream-write ] bi* ;


USING: math summary ;

M: integer summary object-summary ;


USING: cursors kernel math ;

M: integer up/i [ 1 - + ] keep /i ; inline


USING: math unix.groups unix.groups.private unix.users ;

M: integer user-groups user-name (user-groups) ;


USING: assocs kernel math namespaces unix.ffi unix.users ;

M: integer user-passwd
    user-cache get
    [ at ] [ getpwuid [ passwd>new-passwd ] [ f ] if* ] if* ;


USING: calendar combinators.short-circuit kernel math ;

M: integer weeks-in-week-year
    { [ 1 1 <date> thursday? ] [ 12 31 <date> thursday? ] } 1||
    53 52 ? ;


USING: db.queries math ;

M: integer where object-where ;


USING: arrays arrays.shaped math ;

M: integer wrap-shape 1array <uniform-shape> ;


USING: cbor cbor.private kernel math ;

M: integer write-cbor
    dup 0 >= [ 0 write-integer ] [ neg 1 - 1 write-integer ] if
    ;


USING: gml.printer io math math.parser ;

M: integer write-gml number>string write ;


USING: combinators endian io kernel math msgpack ;

M: integer write-msgpack
    dup 0 >= [
        {
            { [ dup 127 <= ] [ write1 ] }
            { [ dup 255 <= ] [ 204 write1 write1 ] }
            { [ dup 65535 <= ] [ 205 write1 2 >be write ] }
            { [ dup 4294967295 <= ] [ 206 write1 4 >be write ] }
            {
                [ dup 18446744073709551615 <= ]
                [ 207 write1 8 >be write ]
            }
            [ cannot-convert ]
        } cond
    ] [
        {
            { [ dup -31 >= ] [ write1 ] }
            { [ dup -128 >= ] [ 208 write1 write1 ] }
            { [ dup -32768 >= ] [ 209 write1 2 >be write ] }
            {
                [ dup -2147483648 >= ]
                [ 210 write1 4 >be write ]
            }
            {
                [ dup -9223372036854775808 >= ]
                [ 211 write1 8 >be write ]
            }
            [ cannot-convert ]
        } cond
    ] if ;


USING: cuda.ptx io math math.parser ;

M: integer write-ptx-operand number>string write ;


USING: formatting math redis.command-writer.private ;

M: integer write-resp ":%s\r\n" printf ;


USING: kernel math yaml.conversion yaml.ffi ;

M: integer yaml-tag drop YAML_INT_TAG ;


USING: calendar.english calendar.format calendar.format.private
formatting grouping io io.streams.string kernel math math.parser
ranges sequences splitting ;

M: integer year.
    dup number>string 64 center. nl 12 [1..b] [
        [
            [ month-name 20 center. ]
            [ days-header. days. nl nl ] bi
        ] with-string-writer split-lines
    ] with map 3 <groups>
    [ first3 [ "%-20s  %-20s  %-20s\n" printf ] 3each ] each ;