math

package
v0.0.0-...-6774e02 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 18, 2019 License: MIT Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type DADD 

type DADD struct{ base.NoOperandsInstruction }

Add double

func (*DADD) Execute 

func (self *DADD) Execute(frame *rtda.Frame)

type DDIV 

type DDIV struct{ base.NoOperandsInstruction }

Divide double

func (*DDIV) Execute 

func (self *DDIV) Execute(frame *rtda.Frame)

type DMUL 

type DMUL struct{ base.NoOperandsInstruction }

Multiply double

func (*DMUL) Execute 

func (self *DMUL) Execute(frame *rtda.Frame)

type DNEG 

type DNEG struct{ base.NoOperandsInstruction }

Negate double

func (*DNEG) Execute 

func (self *DNEG) Execute(frame *rtda.Frame)

type DREM 

type DREM struct{ base.NoOperandsInstruction }

Remainder double

func (*DREM) Execute 

func (self *DREM) Execute(frame *rtda.Frame)

type DSUB 

type DSUB struct{ base.NoOperandsInstruction }

Subtract double

func (*DSUB) Execute 

func (self *DSUB) Execute(frame *rtda.Frame)

type FADD 

type FADD struct{ base.NoOperandsInstruction }

Add float

func (*FADD) Execute 

func (self *FADD) Execute(frame *rtda.Frame)

type FDIV 

type FDIV struct{ base.NoOperandsInstruction }

Divide float

func (*FDIV) Execute 

func (self *FDIV) Execute(frame *rtda.Frame)

type FMUL 

type FMUL struct{ base.NoOperandsInstruction }

Multiply float

func (*FMUL) Execute 

func (self *FMUL) Execute(frame *rtda.Frame)

type FNEG 

type FNEG struct{ base.NoOperandsInstruction }

Negate float

func (*FNEG) Execute 

func (self *FNEG) Execute(frame *rtda.Frame)

type FREM 

type FREM struct{ base.NoOperandsInstruction }

Remainder float

func (*FREM) Execute 

func (self *FREM) Execute(frame *rtda.Frame)

type FSUB 

type FSUB struct{ base.NoOperandsInstruction }

Subtract float

func (*FSUB) Execute 

func (self *FSUB) Execute(frame *rtda.Frame)

type IADD 

type IADD struct{ base.NoOperandsInstruction }

Add int

func (*IADD) Execute 

func (self *IADD) Execute(frame *rtda.Frame)

type IAND 

type IAND struct{ base.NoOperandsInstruction }

Boolean AND int

func (*IAND) Execute 

func (self *IAND) Execute(frame *rtda.Frame)

type IDIV 

type IDIV struct{ base.NoOperandsInstruction }

Divide int

func (*IDIV) Execute 

func (self *IDIV) Execute(frame *rtda.Frame)

type IINC 

type IINC struct {
	Index uint
	Const int32
}

Increment local variable by constant

func (*IINC) Execute 

func (self *IINC) Execute(frame *rtda.Frame)

func (*IINC) FetchOperands 

func (self *IINC) FetchOperands(reader *base.BytecodeReader)

type IMUL 

type IMUL struct{ base.NoOperandsInstruction }

Multiply int

func (*IMUL) Execute 

func (self *IMUL) Execute(frame *rtda.Frame)

type INEG 

type INEG struct{ base.NoOperandsInstruction }

Negate int

func (*INEG) Execute 

func (self *INEG) Execute(frame *rtda.Frame)

type IOR 

type IOR struct{ base.NoOperandsInstruction }

Boolean OR int

func (*IOR) Execute 

func (self *IOR) Execute(frame *rtda.Frame)

type IREM 

type IREM struct{ base.NoOperandsInstruction }

Remainder int

func (*IREM) Execute 

func (self *IREM) Execute(frame *rtda.Frame)

type ISHL 

type ISHL struct{ base.NoOperandsInstruction }

Shift left int

func (*ISHL) Execute 

func (self *ISHL) Execute(frame *rtda.Frame)

type ISHR 

type ISHR struct{ base.NoOperandsInstruction }

Arithmetic shift right int

func (*ISHR) Execute 

func (self *ISHR) Execute(frame *rtda.Frame)

type ISUB 

type ISUB struct{ base.NoOperandsInstruction }

Subtract int

func (*ISUB) Execute 

func (self *ISUB) Execute(frame *rtda.Frame)

type IUSHR 

type IUSHR struct{ base.NoOperandsInstruction }

Logical shift right int

func (*IUSHR) Execute 

func (self *IUSHR) Execute(frame *rtda.Frame)

type IXOR 

type IXOR struct{ base.NoOperandsInstruction }

Boolean XOR int

func (*IXOR) Execute 

func (self *IXOR) Execute(frame *rtda.Frame)

type LADD 

type LADD struct{ base.NoOperandsInstruction }

Add long

func (*LADD) Execute 

func (self *LADD) Execute(frame *rtda.Frame)

type LAND 

type LAND struct{ base.NoOperandsInstruction }

Boolean AND long

func (*LAND) Execute 

func (self *LAND) Execute(frame *rtda.Frame)

type LDIV 

type LDIV struct{ base.NoOperandsInstruction }

Divide long

func (*LDIV) Execute 

func (self *LDIV) Execute(frame *rtda.Frame)

type LMUL 

type LMUL struct{ base.NoOperandsInstruction }

Multiply long

func (*LMUL) Execute 

func (self *LMUL) Execute(frame *rtda.Frame)

type LNEG 

type LNEG struct{ base.NoOperandsInstruction }

Negate long

func (*LNEG) Execute 

func (self *LNEG) Execute(frame *rtda.Frame)

type LOR 

type LOR struct{ base.NoOperandsInstruction }

Boolean OR long

func (*LOR) Execute 

func (self *LOR) Execute(frame *rtda.Frame)

type LREM 

type LREM struct{ base.NoOperandsInstruction }

Remainder long

func (*LREM) Execute 

func (self *LREM) Execute(frame *rtda.Frame)

type LSHL 

type LSHL struct{ base.NoOperandsInstruction }

Shift left long

func (*LSHL) Execute 

func (self *LSHL) Execute(frame *rtda.Frame)

type LSHR 

type LSHR struct{ base.NoOperandsInstruction }

Arithmetic shift right long

func (*LSHR) Execute 

func (self *LSHR) Execute(frame *rtda.Frame)

type LSUB 

type LSUB struct{ base.NoOperandsInstruction }

Subtract long

func (*LSUB) Execute 

func (self *LSUB) Execute(frame *rtda.Frame)

type LUSHR 

type LUSHR struct{ base.NoOperandsInstruction }

Logical shift right long

func (*LUSHR) Execute 

func (self *LUSHR) Execute(frame *rtda.Frame)

type LXOR 

type LXOR struct{ base.NoOperandsInstruction }

Boolean XOR long

func (*LXOR) Execute 

func (self *LXOR) Execute(frame *rtda.Frame)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.