math

package
v0.0.0-...-eae4ae3 Latest Latest
Warning

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

 Go to latest Published: Jul 28, 2020 License: Apache-2.0 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
}

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
}

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
}

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.