livy

package
v0.0.0-...-3a9d114 Latest Latest
Warning

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

 Go to latest Published: Jun 23, 2020 License: MIT Imports: 11 Imported by: 0

Documentation

Index

Constants

View Source 
const DefaultAxis = -1
View Source 
const RE_COMPLEX = RE_REAL + `?([+-][jJ])` + RE_REAL
View Source 
const RE_COMPLEX_SPLIT = `(.*)([+-][jJ])(.*)`
View Source 
const RE_JUST_OPERATOR = `([-+*/\\,&|!=<>]+|[a-z][A-Za-z0-9_]*)`
View Source 
const RE_KEYWORD = `(def|if|then|elif|else|fi|while|do|done|break|continue)\b`
View Source 
const RE_OPERATOR = `([-+*/\\,&|!=<>]+|[a-z][A-Za-z0-9_]*[/\\]?)`
View Source 
const RE_REAL = `([-+]?[0-9]+([.][0-9]+)?([eE][-+]?[0-9]+)?)`

Variables

View Source 
var CX_REGEXP = `([-+0-9.eE]+)(([-+])j([-+0-9.eE]+))?`
View Source 
var IdentityValueOfDyadic = map[string]Val{
	"+":   Zero,
	"-":   Zero,
	"or":  Zero,
	"!=":  Zero,
	"<":   Zero,
	">":   Zero,
	"*":   One,
	"div": One,
	"**":  One,
	"and": One,
	"==":  One,
	">=":  One,
	"<=":  One,
}

If not listed, we will use Zero. TODO: have a way to user-define an identity operator (into the Context).

View Source 
var Log *log.Logger = log.New(os.Stderr, "livy: ", 0)
View Source 
var MatchClose = regexp.MustCompile(`^[)]`).FindStringSubmatch
View Source 
var MatchCloseCurly = regexp.MustCompile(`^[}]`).FindStringSubmatch
View Source 
var MatchCloseSquare = regexp.MustCompile(`^[]]`).FindStringSubmatch
View Source 
var MatchComplex = regexp.MustCompile(`^` + RE_COMPLEX).FindStringSubmatch
View Source 
var MatchComplexSplit = regexp.MustCompile(RE_COMPLEX_SPLIT).FindStringSubmatch
View Source 
var MatchCx = regexp.MustCompile(CX_REGEXP)
View Source 
var MatchEach = regexp.MustCompile("^" + RE_JUST_OPERATOR + `[~]`).FindStringSubmatch
View Source 
var MatchInnerProduct = regexp.MustCompile("^" + RE_JUST_OPERATOR + "[.]" + RE_JUST_OPERATOR).FindStringSubmatch
View Source 
var MatchKeyword = regexp.MustCompile("^" + RE_KEYWORD).FindStringSubmatch
View Source 
var MatchNumber = regexp.MustCompile(`^` + RE_REAL).FindStringSubmatch
View Source 
var MatchOpen = regexp.MustCompile(`^[(]`).FindStringSubmatch
View Source 
var MatchOpenCurly = regexp.MustCompile(`^[{]`).FindStringSubmatch
View Source 
var MatchOpenSquare = regexp.MustCompile(`^[[]`).FindStringSubmatch
View Source 
var MatchOperator = regexp.MustCompile("^" + RE_OPERATOR).FindStringSubmatch
View Source 
var MatchOuterProduct = regexp.MustCompile("^[.][.]" + RE_JUST_OPERATOR).FindStringSubmatch
View Source 
var MatchReduce = regexp.MustCompile("^" + RE_JUST_OPERATOR + `[/]`).FindStringSubmatch
View Source 
var MatchScan = regexp.MustCompile("^" + RE_JUST_OPERATOR + `[\\]`).FindStringSubmatch
View Source 
var MatchSemi = regexp.MustCompile(`^[;\n]`).FindStringSubmatch
View Source 
var MatchString = regexp.MustCompile(`^(["]([^"\\]|[\\].)*["])`).FindStringSubmatch
View Source 
var MatchVariable = regexp.MustCompile(`^([A-Z_][A-Za-z0-9_]*)`).FindStringSubmatch
View Source 
var MatchWhite = regexp.MustCompile(`^([ \t\r]*)`).FindStringSubmatch
View Source 
var One = &Num{1.0}
View Source 
var StandardDyadics = map[string]DyadicFunc{
	"member": dyadicMember,
	"e":      dyadicMember,
	"j":      WrapMatMatDyadic(WrapCxDyadic(cxcxJ)),
	"rect":   WrapMatMatDyadic(WrapCxDyadic(cxcxRect)),

	"rho": dyadicRho,
	"p":   dyadicRho,

	"transpose": dyadicTranspose,
	",":         dyadicCatenate,
	"laminate":  dyadicLaminate,
	"rot":       dyadicRot,
	"take":      dyadicTake,
	"drop":      dyadicDrop,
	"compress":  dyadicCompress,
	"expand":    dyadicExpand,

	`\`: dyadicExpand,

	"==": WrapMatMatDyadic(WrapCxBoolDyadic(
		func(a, b complex128) bool { return a == b })),
	"!=": WrapMatMatDyadic(WrapCxBoolDyadic(
		func(a, b complex128) bool { return a != b })),
	"<": WrapMatMatDyadic(WrapFloatBoolDyadic(
		func(a, b float64) bool { return a < b })),
	">": WrapMatMatDyadic(WrapFloatBoolDyadic(
		func(a, b float64) bool { return a > b })),
	"<=": WrapMatMatDyadic(WrapFloatBoolDyadic(
		func(a, b float64) bool { return a <= b })),
	">=": WrapMatMatDyadic(WrapFloatBoolDyadic(
		func(a, b float64) bool { return a >= b })),
	"and": WrapMatMatDyadic(WrapFloatBoolDyadic(ffand)),
	"or":  WrapMatMatDyadic(WrapFloatBoolDyadic(ffor)),
	"xor": WrapMatMatDyadic(WrapFloatBoolDyadic(ffxor)),

	"+": WrapMatMatDyadic(WrapCxDyadic(
		func(a, b complex128) complex128 { return a + b })),
	"-": WrapMatMatDyadic(WrapCxDyadic(
		func(a, b complex128) complex128 { return a - b })),
	"*": WrapMatMatDyadic(WrapCxDyadic(
		func(a, b complex128) complex128 { return a * b })),
	"/": WrapMatMatDyadic(WrapCxDyadic(
		func(a, b complex128) complex128 { return a / b })),
	"div": WrapMatMatDyadic(WrapCxDyadic(
		func(a, b complex128) complex128 { return a / b })),
	"**": WrapMatMatDyadic(WrapCxDyadic(
		func(a, b complex128) complex128 { return cmplx.Pow(a, b) })),
	"remainder": WrapMatMatDyadic(WrapFloatDyadic(
		func(a, b float64) float64 { return math.Remainder(a, b) })),
	"mod": WrapMatMatDyadic(WrapFloatDyadic(
		func(a, b float64) float64 { return math.Mod(a, b) })),
	"atan": WrapMatMatDyadic(WrapFloatDyadic(
		func(a, b float64) float64 { return math.Atan2(a, b) })),
	"copysign": WrapMatMatDyadic(WrapFloatDyadic(
		func(a, b float64) float64 { return math.Copysign(a, b) })),
	"dim": WrapMatMatDyadic(WrapFloatDyadic(
		func(a, b float64) float64 { return math.Dim(a, b) })),
	"hypot": WrapMatMatDyadic(WrapFloatDyadic(
		func(a, b float64) float64 { return math.Hypot(a, b) })),
	"isInf": WrapMatMatDyadic(WrapFloatBoolDyadic(
		func(a, b float64) bool { return math.IsInf(a, int(b)) })),
	"jn": WrapMatMatDyadic(WrapFloatDyadic(
		func(a, b float64) float64 { return math.Jn(int(a), b) })),
	"yn": WrapMatMatDyadic(WrapFloatDyadic(
		func(a, b float64) float64 { return math.Yn(int(a), b) })),
}
View Source 
var StandardMonadics = map[string]MonadicFunc{
	"box":   monadicBox,
	"unbox": monadicUnbox,
	"b":     monadicBox,
	"u":     monadicUnbox,
	"s2b":   monadicS2B,
	"b2s":   monadicB2S,

	"up":        monadicUp,
	"down":      monadicDown,
	"transpose": transposeMonadic,
	",":         ravelMonadic,
	"rot":       rotMonadic,
	"iota":      iotaMonadic,
	"iota1":     iota1Monadic,
	"rho":       rhoMonadic,

	"i":  iotaMonadic,
	"i1": iota1Monadic,
	"p":  rhoMonadic,
	"j": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(0.0, 1.0) * b
	})),
	"real": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(real(b), 0.0)
	})),
	"imag": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(imag(b), 0.0)
	})),
	"rect": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		Must(imag(b) == 0)
		return cmplx.Rect(1.0, real(b))
	})),
	"isInf": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return Bool2Cx(cmplx.IsInf(b))
	})),
	"isNaN": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return Bool2Cx(cmplx.IsNaN(b))
	})),
	"asin": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Asin(b)
	})),
	"acos": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Acos(b)
	})),
	"atan": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Atan(b)
	})),
	"sin": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Sin(b)
	})),
	"cos": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Cos(b)
	})),
	"tan": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Tan(b)
	})),
	"asinh": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Asinh(b)
	})),
	"acosh": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Acosh(b)
	})),
	"atanh": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Atanh(b)
	})),
	"sinh": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Sinh(b)
	})),
	"cosh": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Cosh(b)
	})),
	"tanh": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Tanh(b)
	})),
	"exp": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Exp(b)
	})),
	"exp2": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Exp2(b)
	})),
	"expm1": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Expm1(b)
	})),
	"log": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Log(b)
	})),
	"log10": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Log10(b)
	})),
	"log2": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Log2(b)
	})),
	"log1p": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Log1p(b)
	})),
	"ceil": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Ceil(b)
	})),
	"floor": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Floor(b)
	})),
	"round": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(math.Round(real(b)), math.Round(imag(b)))
	})),
	"round1": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(math.Round(real(10*b))/10, math.Round(imag(10*b))/10)
	})),
	"round2": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(math.Round(real(100*b))/100, math.Round(imag(100*b))/100)
	})),
	"round3": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(math.Round(real(1000*b))/1000, math.Round(imag(1000*b))/1000)
	})),
	"round4": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(math.Round(real(10000*b))/10000, math.Round(imag(10000*b))/10000)
	})),
	"round5": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(math.Round(real(100000*b))/100000, math.Round(imag(100000*b))/100000)
	})),
	"round6": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(math.Round(real(1000000*b))/1000000, math.Round(imag(1000000*b))/10000000)
	})),
	"round7": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(math.Round(real(10000000*b))/10000000, math.Round(imag(10000000*b))/100000000)
	})),
	"round8": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(math.Round(real(100000000*b))/100000000, math.Round(imag(100000000*b))/1000000000)
	})),
	"round9": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(math.Round(real(1000000000*b))/1000000000, math.Round(imag(1000000000*b))/10000000000)
	})),
	"roundToEven": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.RoundToEven(b)
	})),
	"ki":     WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return 1024 * b })),
	"mi":     WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return 1024 * 1024 * b })),
	"gi":     WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return 1024 * 1024 * 1024 * b })),
	"ti":     WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return 1024 * 1024 * 1024 * 1024 * b })),
	"pi":     WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return 1024 * 1024 * 1024 * 1024 * 1024 * b })),
	"ei":     WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * b })),
	"ks":     WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return 1000 * b })),
	"ms":     WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return 1000 * 1000 * b })),
	"gs":     WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return 1000 * 1000 * 1000 * b })),
	"ts":     WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return 1000 * 1000 * 1000 * 1000 * b })),
	"ps":     WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return 1000 * 1000 * 1000 * 1000 * 1000 * b })),
	"es":     WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * b })),
	"millis": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return b / 1000 })),
	"micros": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return b / 1000 / 1000 })),
	"nanos":  WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return b / 1000 / 1000 / 1000 })),
	"picos":  WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return b / 1000 / 1000 / 1000 / 1000 })),
	"div":    WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 { return 1 / b })),
	"cbrt": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		if imag(b) == 0 {
			return complex(math.Cbrt(real(b)), 0)
		} else {
			return cmplx.Pow(b, complex(1.0/3.0, 0))
		}
	})),
	"sqrt": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return cmplx.Sqrt(b)
	})),
	"double": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return b + b
	})),
	"square": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return b * b
	})),
	"sgn": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		if b < 0 {
			return -1
		} else if b > 0 {
			return +1
		} else if b == 0 {
			return 0
		} else {
			panic("cannot sgn")
		}
	})),
	"abs": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(cmplx.Abs(b), 0)
	})),
	"phase": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(cmplx.Phase(b), 0.0)
	})),
	"erf": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Erf(b)
	})),
	"erfc": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Erfc(b)
	})),
	"erfinv": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Erfinv(b)
	})),
	"erfcinv": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Erfcinv(b)
	})),
	"gamma": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Gamma(b)
	})),
	"inf": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Inf(int(b))
	})),
	"y0": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Y0(b)
	})),
	"y1": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		return math.Y1(b)
	})),
	"neg": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return -b
	})),
	"-": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return -b
	})),
	"+": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return +b
	})),
	"conjugate": WrapMatMonadic(WrapCxMonadic(func(b complex128) complex128 {
		return complex(real(b), -imag(b))
	})),
	"not": WrapMatMonadic(WrapFloatMonadic(func(b float64) float64 {
		x := float2bool(b)
		return boolf(!x)
	})),
}
View Source 
var Zero = &Num{0.0}

Functions

func Bool2Cx 

func Bool2Cx(b bool) complex128

func BoundingBoxString 

func BoundingBoxString(s string) (w int, h int)

func Check 

func Check(err error)

func Compare 

func Compare(a, b Val) int

func Cx2Str 

func Cx2Str(c complex128) string

func FillString 

func FillString(w, h int, s string) []string

func GetVectorOfScalarFloats 

func GetVectorOfScalarFloats(a Val) []float64

func GetVectorOfScalarInts 

func GetVectorOfScalarInts(a Val) []int

func Mod 

func Mod(x int, modulus int) int

Mod forcing positive result, since I don't actually know what Go does.

func Must 

func Must(predicate bool)

func ParseCx 

func ParseCx(s string) complex128

func Product 

func Product(v []int) int

func RenderBoxString 

func RenderBoxString(sss [][]string, border int) string

func RenderPrettyMatrix 

func RenderPrettyMatrix(mat Mat) string

func SameRank 

func SameRank(a, b *Mat) bool

func SameShape 

func SameShape(a, b *Mat) bool

Types

type Box 

type Box struct {
	X interface{}
}

func (Box) Compare 

func (a Box) Compare(x Val) int

func (Box) GetScalarCx 

func (o Box) GetScalarCx() complex128

func (Box) GetScalarFloat 

func (o Box) GetScalarFloat() float64

func (Box) GetScalarInt 

func (o Box) GetScalarInt() int

func (Box) GetScalarOrNil 

func (o Box) GetScalarOrNil() Val

func (Box) Pretty 

func (o Box) Pretty() string

func (Box) Ravel 

func (o Box) Ravel() []Val

func (Box) Shape 

func (o Box) Shape() []int

func (Box) Size 

func (o Box) Size() int

func (Box) String 

func (o Box) String() string

func (Box) ValEnum 

func (o Box) ValEnum() ValEnum

type Break 

type Break struct{}
var BREAK Break

func (Break) Eval 

func (Break) Eval(c *Context) Val

func (Break) String 

func (o Break) String() string

type Cond 

type Cond struct {
	If   *Seq
	Then *Seq
	Else *Seq
}

func (Cond) Eval 

func (o Cond) Eval(c *Context) Val

func (Cond) String 

func (o Cond) String() string

type Context 

type Context struct {
	Globals    map[string]Val
	Monadics   map[string]MonadicFunc
	Dyadics    map[string]DyadicFunc
	LocalStack []map[string]Val

	FormatReal         string
	FormatImagPlus     string
	FormatImagMinus    string
	FormatComplexPlus  string
	FormatComplexMinus string

	StringExtension StringExtensionFunc
	Extra           map[string]interface{}
}

func NewContext 

func NewContext() *Context

func (*Context) Command 

func (c *Context) Command(s string)

type Continue 

type Continue struct{}
var CONTINUE Continue

func (Continue) Eval 

func (Continue) Eval(c *Context) Val

func (Continue) String 

func (o Continue) String() string

type Def 

type Def struct {
	Name   string
	Seq    *Seq
	Lhs    string
	Axis   string
	Rhs    string
	Locals []string
}

func (Def) Eval 

func (o Def) Eval(c *Context) Val

func (Def) String 

func (o Def) String() string

type Dyad 

type Dyad struct {
	Token *Token
	A     Expression
	Op    string
	B     Expression
	Axis  Expression
}

func (Dyad) Assign 

func (o Dyad) Assign(c *Context) Val

func (Dyad) Eval 

func (o Dyad) Eval(c *Context) Val

func (Dyad) String 

func (o Dyad) String() string

type DyadicFunc 

type DyadicFunc func(c *Context, a Val, b Val, axis int) Val

func MkEachOpDyadic 

func MkEachOpDyadic(name string, fn DyadicFunc) DyadicFunc

func MkInnerProduct 

func MkInnerProduct(name string, fn1, fn2 DyadicFunc) DyadicFunc

func MkOuterProduct 

func MkOuterProduct(name string, fn DyadicFunc) DyadicFunc

func WrapCxBoolDyadic 

func WrapCxBoolDyadic(fn FuncCxCxBool) DyadicFunc

func WrapCxDyadic 

func WrapCxDyadic(fn FuncCxCxCx) DyadicFunc

func WrapFloatBoolDyadic 

func WrapFloatBoolDyadic(fn FuncFloatFloatBool) DyadicFunc

func WrapFloatDyadic 

func WrapFloatDyadic(fn FuncFloatFloatFloat) DyadicFunc

func WrapMatMatDyadic 

func WrapMatMatDyadic(fn DyadicFunc) DyadicFunc

type Expression 

type Expression interface {
	Eval(*Context) Val
	String() string
}

type FuncCxCxBool 

type FuncCxCxBool func(complex128, complex128) bool

type FuncCxCxCx 

type FuncCxCxCx func(complex128, complex128) complex128

type FuncFloatFloatBool 

type FuncFloatFloatBool func(float64, float64) bool

type FuncFloatFloatFloat 

type FuncFloatFloatFloat func(float64, float64) float64

type IndexedValSlice 

type IndexedValSlice struct {
	Vals []Val
	Ints []int
}

func (IndexedValSlice) Len 

func (p IndexedValSlice) Len() int

func (IndexedValSlice) Less 

func (p IndexedValSlice) Less(i, j int) bool

func (*IndexedValSlice) Swap 

func (p *IndexedValSlice) Swap(i, j int)

type Lex 

type Lex struct {
	Tokens []*Token
	Source string
	// contains filtered or unexported fields
}

func Tokenize 

func Tokenize(s string) *Lex

func (*Lex) DoNextToken 

func (lex *Lex) DoNextToken() bool

func (Lex) String 

func (x Lex) String() string

type List 

type List struct {
	Vec []Expression
}

func (List) Eval 

func (o List) Eval(c *Context) Val

func (List) String 

func (o List) String() string

type Literal 

type Literal struct {
	V Val
}

func (Literal) Eval 

func (o Literal) Eval(c *Context) Val

func (Literal) String 

func (o Literal) String() string

type Mat 

type Mat struct {
	M []Val
	S []int
}

func (Mat) Compare 

func (a Mat) Compare(x Val) int

func (Mat) GetScalarCx 

func (o Mat) GetScalarCx() complex128

func (Mat) GetScalarFloat 

func (o Mat) GetScalarFloat() float64

func (Mat) GetScalarInt 

func (o Mat) GetScalarInt() int

func (Mat) GetScalarOrNil 

func (o Mat) GetScalarOrNil() Val

func (Mat) Pretty 

func (o Mat) Pretty() string

func (Mat) PrettyMatrix 

func (o Mat) PrettyMatrix(vec []string) string

func (Mat) Ravel 

func (o Mat) Ravel() []Val

func (Mat) Shape 

func (o Mat) Shape() []int

func (Mat) Size 

func (o Mat) Size() int

func (Mat) String 

func (o Mat) String() string

func (Mat) ValEnum 

func (o Mat) ValEnum() ValEnum

type Matcher 

type Matcher struct {
	Type    TokenType
	MatchFn func(string) []string
}

type Monad 

type Monad struct {
	Token *Token
	Op    string
	B     Expression
	Axis  Expression
}

func (Monad) Eval 

func (o Monad) Eval(c *Context) Val

func (Monad) String 

func (o Monad) String() string

type MonadicFunc 

type MonadicFunc func(c *Context, b Val, dim int) Val

func MkEachOpMonadic 

func MkEachOpMonadic(name string, fn MonadicFunc) MonadicFunc

func MkReduceOrScanOp 

func MkReduceOrScanOp(name string, fn DyadicFunc, identity Val, toScan bool) MonadicFunc

func WrapCxMonadic 

func WrapCxMonadic(fn funcCxCx) MonadicFunc

func WrapFloatMonadic 

func WrapFloatMonadic(fn funcFloatFloat) MonadicFunc

func WrapMatMonadic 

func WrapMatMonadic(fn MonadicFunc) MonadicFunc

type Num 

type Num struct {
	F complex128
}

func BoolNum 

func BoolNum(b bool) *Num

func CxNum 

func CxNum(f complex128) *Num

func FloatNum 

func FloatNum(f float64) *Num

func IntNum 

func IntNum(i int) *Num

func (Num) Compare 

func (a Num) Compare(x Val) int
func (a Char) Compare(x Val) int {
	b, ok := x.(*Char)
	if !ok {
		Log.Panicf("Char::Compare to not-a-Char: %#v", x)
	}
	switch {
	case a.R < b.R:
		return -1
	case a.R == b.R:
		return 0
	case a.R > b.R:
		return +1
	}
	panic("NOT_REACHED")
}

func (Num) GetScalarCx 

func (o Num) GetScalarCx() complex128
func (o Char) GetScalarCx() complex128 {
	Log.Panicf("Char cannot be a Scalar Complex: '%c'", o.R)
	panic(0)
}

func (o Char) GetScalarFloat() float64 {
	Log.Panicf("Char cannot be a Scalar Float: '%c'", o.R)
	panic(0)
}

func (Num) GetScalarFloat 

func (o Num) GetScalarFloat() float64

func (Num) GetScalarInt 

func (o Num) GetScalarInt() int
func (o Char) GetScalarInt() int {
	Log.Panicf("Char cannot be a Scalar Int: '%c'", o.R)
	panic(0)
}

func (Num) GetScalarOrNil 

func (o Num) GetScalarOrNil() Val
func (o Char) GetScalarOrNil() Val {
	return o
}

func (Num) Pretty 

func (o Num) Pretty() string
func (o Char) Pretty() string {
	return fmt.Sprintf("'%c' ", o.R)
}

func (Num) Ravel 

func (o Num) Ravel() []Val
func (o Char) Ravel() []Val {
	return []Val{o}
}

func (Num) Shape 

func (o Num) Shape() []int
func (o Char) Shape() []int {
	return nil
}

func (Num) Size 

func (o Num) Size() int
func (o Char) Size() int {
	return 1
}

func (Num) String 

func (o Num) String() string

func (Num) ValEnum 

func (o Num) ValEnum() ValEnum
func (o Char) ValEnum() ValEnum {
	return CharVal
}

type Number 

type Number struct {
	F complex128
}

func (Number) Eval 

func (o Number) Eval(c *Context) Val

func (Number) String 

func (o Number) String() string

type Parser 

type Parser struct {
	Context *Context
}

func (*Parser) ParseDef 

func (p *Parser) ParseDef(lex *Lex, i int) (*Def, int)

func (*Parser) ParseExpr 

func (p *Parser) ParseExpr(lex *Lex, i int) (z Expression, zi int)

func (*Parser) ParseIf 

func (p *Parser) ParseIf(lex *Lex, i int) (*Cond, int)

func (*Parser) ParseSeq 

func (p *Parser) ParseSeq(lex *Lex, i int) (*Seq, int)

func (*Parser) ParseSquare 

func (p *Parser) ParseSquare(lex *Lex, i int) ([]Expression, int)

func (*Parser) ParseWhile 

func (p *Parser) ParseWhile(lex *Lex, i int) (*While, int)

type Seq 

type Seq struct {
	Vec []Expression
}

func (Seq) Eval 

func (o Seq) Eval(c *Context) Val

func (Seq) String 

func (o Seq) String() string

type StringExtensionFunc 

type StringExtensionFunc func(s string) Expression

type Subscript 

type Subscript struct {
	Matrix Expression
	Vec    []Expression
}

func (Subscript) Assign 

func (o Subscript) Assign(c *Context, b Val) Val

func (Subscript) Eval 

func (o Subscript) Eval(c *Context) Val

func (Subscript) PreEval 

func (o Subscript) PreEval(c *Context) (mat *Mat, newShape []int, subscripts [][]int)

func (Subscript) String 

func (o Subscript) String() string

type Token 

type Token struct {
	Type  TokenType
	Str   string
	Pos   int
	Match []string
}

func (Token) String 

func (t Token) String() string

type TokenType 

type TokenType int
const (
	EndToken TokenType = iota
	ComplexToken
	NumberToken
	VariableToken
	OperatorToken
	OpenToken // 5
	CloseToken
	OpenSquareToken
	CloseSquareToken
	SemiToken
	InnerProductToken // 10
	OuterProductToken
	OpenCurlyToken
	CloseCurlyToken
	KeywordToken
	ReduceToken // 15
	ScanToken
	EachToken
	StringToken
)

type Val 

type Val interface {
	Compare(Val) int
	ValEnum() ValEnum
	String() string
	Pretty() string
	Size() int
	Shape() []int
	Ravel() []Val
	GetScalarInt() int
	GetScalarFloat() float64
	GetScalarCx() complex128
	GetScalarOrNil() Val
}

func CallFor 

func CallFor(c *Context, fn func() Val, why string, what string) Val

func EvalFor 

func EvalFor(c *Context, expr Expression, why string, what string) Val

func GetVectorOfScalarVals 

func GetVectorOfScalarVals(a Val) []Val

func RepeatVal 

func RepeatVal(a Val, n int) []Val

type ValEnum 

type ValEnum int
const (
	CharVal ValEnum = iota + 1
	NumVal
	MatVal
	BoxVal
	ChirpVal // github.com/yak-libs/chirp-lang extension
)

type Variable 

type Variable struct {
	S string
}

func (Variable) Eval 

func (o Variable) Eval(c *Context) Val

func (Variable) String 

func (o Variable) String() string

type While 

type While struct {
	While *Seq
	Do    *Seq
}

func (While) Eval 

func (o While) Eval(c *Context) Val

func (While) String 

func (o While) String() string

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.