simd-128

Vocabulary

math.vectors.simd

Definition

USING: byte-arrays ;

IN: math.vectors.simd

TUPLE: simd-128
    {
        underlying byte-array read-only initial:
        B{ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
    } ;

Methods

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

M: simd-128 (vmerge-head)
    dup simd-rep
    [ (simd-vmerge-head) ]
    [ M\ simd-128 (vmerge-head) (call-next-method) ] vv->v-op ;
    inline


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

M: simd-128 (vmerge-tail)
    dup simd-rep
    [ (simd-vmerge-tail) ]
    [ M\ simd-128 (vmerge-tail) (call-next-method) ] vv->v-op ;
    inline


USING: math.vectors.simd prettyprint.custom ;

M: simd-128 >pprint-sequence ;


USING: alien kernel math.vectors.simd ;

M: simd-128 byte-length drop 16 ; inline


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

M: simd-128 clone [ clone ] change-underlying ; inline


USING: math.vectors math.vectors.simd ;

M: simd-128 distance v- norm ; inline


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

M: simd-128 equal?
    dup simd-rep
    [ drop v= vall? ] [ 3drop f ] if-both-vectors-match ; inline


USING: accessors kernel math.vectors.simd ;

M: simd-128 hashcode* underlying>> hashcode* ; inline


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

M: simd-128 hlshift
    over simd-rep
    [ (simd-hlshift) ]
    [ M\ simd-128 hlshift (call-next-method) ] vn->v-op ; inline


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

M: simd-128 hrshift
    over simd-rep
    [ (simd-hrshift) ]
    [ M\ simd-128 hrshift (call-next-method) ] vn->v-op ; inline


USING: kernel math.vectors math.vectors.simd ;

M: simd-128 n*v [ simd-with ] keep v* ; inline


USING: kernel math.vectors math.vectors.simd ;

M: simd-128 n+v [ simd-with ] keep v+ ; inline


USING: kernel math.vectors math.vectors.simd ;

M: simd-128 n-v [ simd-with ] keep v- ; inline


USING: kernel math.vectors math.vectors.simd ;

M: simd-128 n/v [ simd-with ] keep v/ ; inline


USING: byte-arrays kernel math.vectors.simd
math.vectors.simd.private sequences ;

M: simd-128 new-sequence
    2dup length =
    [ nip [ 16 (byte-array) ] make-underlying ]
    [ length bad-simd-length ] if ; inline


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

M: simd-128 norm-sq dup vdot (simd-positive) ; inline


USING: math.vectors.simd prettyprint.custom ;

M: simd-128 pprint* pprint-object ;


USING: generic kernel math.vectors.simd
math.vectors.simd.intrinsics math.vectors.simd.private sequences
;

M: simd-128 sum
    dup simd-rep
    [ (simd-sum) ] [ M\ simd-128 sum (call-next-method) ]
    v->x-op ; inline


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

M: simd-128 v*
    dup simd-rep
    [ (simd-v*) ] [ M\ simd-128 v* (call-next-method) ] vv->v-op
    ; inline


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

M: simd-128 v*high
    dup simd-rep
    [ (simd-v*high) ] [ M\ simd-128 v*high (call-next-method) ]
    vv->v-op ; inline


USING: kernel math.vectors math.vectors.simd ;

M: simd-128 v*n over simd-with v* ; inline


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

M: simd-128 v+
    dup simd-rep
    [ (simd-v+) ] [ M\ simd-128 v+ (call-next-method) ] vv->v-op
    ; inline


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

M: simd-128 v+-
    dup simd-rep
    [ (simd-v+-) ] [ M\ simd-128 v+- (call-next-method) ]
    vv->v-op ; inline


USING: kernel math.vectors math.vectors.simd ;

M: simd-128 v+n over simd-with v+ ; inline


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

M: simd-128 v-
    dup simd-rep
    [ (simd-v-) ] [ M\ simd-128 v- (call-next-method) ] vv->v-op
    ; inline


USING: kernel math.vectors math.vectors.simd ;

M: simd-128 v-n over simd-with v- ; inline


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

M: simd-128 v/
    dup simd-rep
    [ (simd-v/) ] [ M\ simd-128 v/ (call-next-method) ] vv->v-op
    ; inline


USING: kernel math.vectors math.vectors.simd ;

M: simd-128 v/n over simd-with v/ ; inline


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

M: simd-128 v<
    dup simd-rep
    [ (simd-v<) ] [ M\ simd-128 v< (call-next-method) ] vv->v-op
    ; inline


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

M: simd-128 v<=
    dup simd-rep
    [ (simd-v<=) ] [ M\ simd-128 v<= (call-next-method) ]
    vv->v-op ; inline


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

M: simd-128 v=
    dup simd-rep
    [ (simd-v=) ] [ M\ simd-128 v= (call-next-method) ] vv->v-op
    ; inline


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

M: simd-128 v>
    dup simd-rep
    [ (simd-v>) ] [ M\ simd-128 v> (call-next-method) ] vv->v-op
    ; inline


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

M: simd-128 v>=
    dup simd-rep
    [ (simd-v>=) ] [ M\ simd-128 v>= (call-next-method) ]
    vv->v-op ; inline


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

M: simd-128 vabs
    dup simd-rep
    [ (simd-vabs) ] [ M\ simd-128 vabs (call-next-method) ]
    v->v-op ; inline


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

M: simd-128 vall?
    dup simd-rep
    [ (simd-vall?) ] [ M\ simd-128 vall? (call-next-method) ]
    v->x-op ; inline


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

M: simd-128 vand
    dup simd-rep
    [ (simd-vand) ] [ M\ simd-128 vand (call-next-method) ]
    vv->v-op ; inline


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

M: simd-128 vandn
    dup simd-rep
    [ (simd-vandn) ] [ M\ simd-128 vandn (call-next-method) ]
    vv->v-op ; inline


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

M: simd-128 vany?
    dup simd-rep
    [ (simd-vany?) ] [ M\ simd-128 vany? (call-next-method) ]
    v->x-op ; inline


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

M: simd-128 vavg
    dup simd-rep
    [ (simd-vavg) ] [ M\ simd-128 vavg (call-next-method) ]
    vv->v-op ; inline


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

M: simd-128 vbitand
    dup simd-rep
    [ (simd-vbitand) ]
    [ M\ simd-128 vbitand (call-next-method) ] vv->v-op ; inline


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

M: simd-128 vbitandn
    dup simd-rep
    [ (simd-vbitandn) ]
    [ M\ simd-128 vbitandn (call-next-method) ] vv->v-op ;
    inline


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

M: simd-128 vbitnot
    dup simd-rep
    [ (simd-vbitnot) ]
    [ M\ simd-128 vbitnot (call-next-method) ] v->v-op ; inline


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

M: simd-128 vbitor
    dup simd-rep
    [ (simd-vbitor) ] [ M\ simd-128 vbitor (call-next-method) ]
    vv->v-op ; inline


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

M: simd-128 vbitxor
    dup simd-rep
    [ (simd-vbitxor) ]
    [ M\ simd-128 vbitxor (call-next-method) ] vv->v-op ; inline


USING: kernel math.vectors math.vectors.simd sequences ;

M: simd-128 vbroadcast swap [ nth ] [ simd-with ] bi ; inline


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

M: simd-128 vcount
    dup simd-rep [
        [ (simd-vgetmask) (simd-positive) ]
        [ M\ simd-128 vcount (call-next-method) ] v->x-op
    ] [ mask>count ] bi ; inline


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

M: simd-128 vdot
    dup simd-rep
    [ (simd-vdot) ] [ M\ simd-128 vdot (call-next-method) ]
    vv->x-op ; inline


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

M: simd-128 vlshift
    over simd-rep
    [ (simd-vlshift) ]
    [ M\ simd-128 vlshift (call-next-method) ] vn->v-op ; inline


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

M: simd-128 vmax
    dup simd-rep
    [ (simd-vmax) ] [ M\ simd-128 vmax (call-next-method) ]
    vv->v-op ; inline


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

M: simd-128 vmin
    dup simd-rep
    [ (simd-vmin) ] [ M\ simd-128 vmin (call-next-method) ]
    vv->v-op ; inline


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

M: simd-128 vneg
    dup simd-rep
    [ (simd-vneg) ] [ M\ simd-128 vneg (call-next-method) ]
    v->v-op ; inline


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

M: simd-128 vnone?
    dup simd-rep
    [ (simd-vnone?) ] [ M\ simd-128 vnone? (call-next-method) ]
    v->x-op ; inline


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

M: simd-128 vnot
    dup simd-rep
    [ (simd-vnot) ] [ M\ simd-128 vnot (call-next-method) ]
    v->v-op ; inline


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

M: simd-128 vor
    dup simd-rep
    [ (simd-vor) ] [ M\ simd-128 vor (call-next-method) ]
    vv->v-op ; inline


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

M: simd-128 vrshift
    over simd-rep
    [ (simd-vrshift) ]
    [ M\ simd-128 vrshift (call-next-method) ] vn->v-op ; inline


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

M: simd-128 vs*
    dup simd-rep
    [ (simd-vs*) ] [ M\ simd-128 vs* (call-next-method) ]
    vv->v-op ; inline


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

M: simd-128 vs+
    dup simd-rep
    [ (simd-vs+) ] [ M\ simd-128 vs+ (call-next-method) ]
    vv->v-op ; inline


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

M: simd-128 vs-
    dup simd-rep
    [ (simd-vs-) ] [ M\ simd-128 vs- (call-next-method) ]
    vv->v-op ; inline


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

M: simd-128 vsad
    dup simd-rep
    [ (simd-vsad) ] [ M\ simd-128 vsad (call-next-method) ]
    vv->x-op ; inline


USING: math.vectors math.vectors.simd ;

M: simd-128 vshuffle vshuffle-bytes ; inline


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

M: simd-128 vshuffle-bytes
    dup simd-rep
    [ (simd-vshuffle-bytes) ]
    [ M\ simd-128 vshuffle-bytes (call-next-method) ] vv'->v-op
    ; inline


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

M: simd-128 vshuffle-elements
    over simd-rep
    [ (simd-vshuffle-elements) ]
    [ M\ simd-128 vshuffle-elements (call-next-method) ]
    vx->v-op ; inline


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

M: simd-128 vshuffle2-elements
    over simd-rep
    [ (simd-vshuffle2-elements) ]
    [ M\ simd-128 vshuffle2-elements (call-next-method) ]
    vvx->v-op ; inline


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

M: simd-128 vsqrt
    dup simd-rep
    [ (simd-vsqrt) ] [ M\ simd-128 vsqrt (call-next-method) ]
    v->v-op ; inline


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

M: simd-128 vunordered?
    dup simd-rep
    [ (simd-vunordered?) ]
    [ M\ simd-128 vunordered? (call-next-method) ] vv->v-op ;
    inline


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

M: simd-128 vxor
    dup simd-rep
    [ (simd-vxor) ] [ M\ simd-128 vxor (call-next-method) ]
    vv->v-op ; inline