v*high ( u v -- w ) - Factor Documentation

Vocabulary
math.vectors

Definition

IN: math.vectors

GENERIC: v*high ( u v -- w )

Methods

USING: alien.c-types elf math math.vectors sequences
specialized-arrays.instances.elf.Elf32_Phdr ;

M: Elf32_Phdr-array v*high
    [ * \ Elf32_Phdr heap-size neg shift ] 2map ; inline


USING: alien.c-types elf math math.vectors sequences
specialized-arrays.instances.elf.Elf32_Shdr ;

M: Elf32_Shdr-array v*high
    [ * \ Elf32_Shdr heap-size neg shift ] 2map ; inline


USING: alien.c-types elf math math.vectors sequences
specialized-arrays.instances.elf.Elf32_Sym ;

M: Elf32_Sym-array v*high
    [ * \ Elf32_Sym heap-size neg shift ] 2map ; inline


USING: alien.c-types elf math math.vectors sequences
specialized-arrays.instances.elf.Elf64_Phdr ;

M: Elf64_Phdr-array v*high
    [ * \ Elf64_Phdr heap-size neg shift ] 2map ; inline


USING: alien.c-types elf math math.vectors sequences
specialized-arrays.instances.elf.Elf64_Shdr ;

M: Elf64_Shdr-array v*high
    [ * \ Elf64_Shdr heap-size neg shift ] 2map ; inline


USING: alien.c-types elf math math.vectors sequences
specialized-arrays.instances.elf.Elf64_Sym ;

M: Elf64_Sym-array v*high
    [ * \ Elf64_Sym heap-size neg shift ] 2map ; inline


USING: alien.c-types benchmark.nbody-simd math math.vectors
sequences
specialized-arrays.instances.benchmark.nbody-simd.body ;

M: body-array v*high [ * \ body heap-size neg shift ] 2map
    ; inline


USING: alien.c-types gpu.demos.bunny math math.vectors
sequences
specialized-arrays.instances.gpu.demos.bunny.bunny-vertex-struct
;

M: bunny-vertex-struct-array v*high
    [ * \ bunny-vertex-struct heap-size neg shift ] 2map ;
    inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.char ;

M: char-array v*high [ * \ char heap-size neg shift ] 2map
    ; inline


USING: alien.c-types alien.complex math math.vectors sequences
specialized-arrays.instances.alien.complex.complex-double ;

M: complex-double-array v*high
    [ * \ complex-double heap-size neg shift ] 2map ; inline


USING: alien.c-types alien.complex math math.vectors sequences
specialized-arrays.instances.alien.complex.complex-float ;

M: complex-float-array v*high
    [ * \ complex-float heap-size neg shift ] 2map ; inline


USING: alien.c-types chipmunk.ffi math math.vectors sequences
specialized-arrays.instances.chipmunk.ffi.cpContact ;

M: cpContact-array v*high
    [ * \ cpContact heap-size neg shift ] 2map ; inline


USING: alien.c-types chipmunk.ffi math math.vectors sequences
specialized-arrays.instances.chipmunk.ffi.cpPolyShapeAxis ;

M: cpPolyShapeAxis-array v*high
    [ * \ cpPolyShapeAxis heap-size neg shift ] 2map ; inline


USING: alien.c-types chipmunk.ffi math math.vectors sequences
specialized-arrays.instances.chipmunk.ffi.cpVect ;

M: cpVect-array v*high
    [ * \ cpVect heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors math.vectors.simd.cords
sequences
specialized-arrays.instances.math.vectors.simd.cords.double-4 ;

M: double-4-array v*high
    [ * \ double-4 heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.double ;

M: double-array v*high
    [ * \ double heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.unix.linux.epoll.epoll-event
unix.linux.epoll ;

M: epoll-event-array v*high
    [ * \ epoll-event heap-size neg shift ] 2map ; inline


USING: alien.c-types macho math math.vectors sequences
specialized-arrays.instances.macho.fat_arch ;

M: fat_arch-array v*high
    [ * \ fat_arch heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors math.vectors.simd
sequences
specialized-arrays.instances.math.vectors.simd.float-4 ;

M: float-4-array v*high
    [ * \ float-4 heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.float ;

M: float-array v*high
    [ * \ float heap-size neg shift ] 2map ; inline


USING: alien.c-types game.loop.benchmark math math.vectors
sequences
specialized-arrays.instances.game.loop.benchmark.game-loop-benchmark
;

M: game-loop-benchmark-array v*high
    [ * \ game-loop-benchmark heap-size neg shift ] 2map ;
    inline


USING: alien.c-types math math.floats.half math.vectors
sequences specialized-arrays.instances.math.floats.half.half ;

M: half-array v*high [ * \ half heap-size neg shift ] 2map
    ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.int ;

M: int-array v*high [ * \ int heap-size neg shift ] 2map ;
    inline


USING: alien.c-types libusb math math.vectors sequences
specialized-arrays.instances.libusb.libusb_iso_packet_descriptor
;

M: libusb_iso_packet_descriptor-array v*high
    [ * \ libusb_iso_packet_descriptor heap-size neg shift ]
    2map ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.long ;

M: long-array v*high [ * \ long heap-size neg shift ] 2map
    ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.longlong ;

M: longlong-array v*high
    [ * \ longlong heap-size neg shift ] 2map ; inline


USING: alien.c-types macho math math.vectors sequences
specialized-arrays.instances.macho.nlist ;

M: nlist-array v*high
    [ * \ nlist heap-size neg shift ] 2map ; inline


USING: alien.c-types macho math math.vectors sequences
specialized-arrays.instances.macho.nlist_64 ;

M: nlist_64-array v*high
    [ * \ nlist_64 heap-size neg shift ] 2map ; inline


USING: alien.c-types fluids math math.vectors sequences
specialized-arrays.instances.fluids.particle_t ;

M: particle_t-array v*high
    [ * \ particle_t heap-size neg shift ] 2map ; inline


USING: alien.c-types benchmark.struct-arrays math math.vectors
sequences
specialized-arrays.instances.benchmark.struct-arrays.point ;

M: point-array v*high
    [ * \ point heap-size neg shift ] 2map ; inline


USING: alien.c-types macho math math.vectors sequences
specialized-arrays.instances.macho.section ;

M: section-array v*high
    [ * \ section heap-size neg shift ] 2map ; inline


USING: alien.c-types macho math math.vectors sequences
specialized-arrays.instances.macho.section_64 ;

M: section_64-array v*high
    [ * \ section_64 heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.short ;

M: short-array v*high
    [ * \ short heap-size neg shift ] 2map ; 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: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.size_t ;

M: size_t-array v*high
    [ * \ size_t heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors ogg.theora sequences
specialized-arrays.instances.ogg.theora.th-quant-ranges ;

M: th-quant-ranges-array v*high
    [ * \ th-quant-ranges heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.unix.time.timeval unix.time ;

M: timeval-array v*high
    [ * \ timeval heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors math.vectors.simd
sequences
specialized-arrays.instances.math.vectors.simd.uchar-16 ;

M: uchar-16-array v*high
    [ * \ uchar-16 heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.uchar ;

M: uchar-array v*high
    [ * \ uchar heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.tools.disassembler.udis.ud_operand
tools.disassembler.udis ;

M: ud_operand-array v*high
    [ * \ ud_operand heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors math.vectors.simd
sequences specialized-arrays.instances.math.vectors.simd.uint-4
;

M: uint-4-array v*high
    [ * \ uint-4 heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.uint ;

M: uint-array v*high [ * \ uint heap-size neg shift ] 2map
    ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.uintptr_t ;

M: uintptr_t-array v*high
    [ * \ uintptr_t heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.ulong ;

M: ulong-array v*high
    [ * \ ulong heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.ulonglong ;

M: ulonglong-array v*high
    [ * \ ulonglong heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.ushort ;

M: ushort-array v*high
    [ * \ ushort heap-size neg shift ] 2map ; inline


USING: alien.c-types math math.vectors sequences
specialized-arrays.instances.alien.c-types.void* ;

M: void*-array v*high
    [ * \ void* heap-size neg shift ] 2map ; inline