func (card *Card) TakeDamage(amount int) (remainingHP int) { card.CurrentHitPoints = int(math.Dim( float64(card.CurrentHitPoints), float64(amount))) remainingHP = card.CurrentHitPoints return }
func (card *Card) LoseAttack(amount int) (remainingAtk int) { card.CurrentHitPoints = int(math.Dim( float64(card.CurrentAttack), float64(amount))) remainingAtk = card.CurrentAttack return }
func TestMath() { fmt.Println(math.Abs(11)) fmt.Println(math.Abs(-12)) fmt.Println(math.Abs(-12.34)) fmt.Println(math.Dim(15, 17)) fmt.Println(math.Dim(17, 15)) fmt.Println(math.Max(15, 17)) fmt.Println(math.Min(15.6, 15.7)) // 取余 fmt.Println(math.Mod(10, 4)) // 返回值1,整数部分,返回值2,小数部分 fmt.Println(math.Modf(15.6)) // 幂运算 fmt.Println(math.Pow(2, 3)) fmt.Println(math.Sqrt(9)) fmt.Println("MaxInt8 = ", math.MaxInt8) fmt.Println("MinInt8 = ", math.MinInt8) fmt.Println("MaxInt16 = ", math.MaxInt16) fmt.Println("MinInt16 = ", math.MinInt16) fmt.Println("MaxInt32 = ", math.MaxInt32) fmt.Println("MinInt32 = ", math.MinInt32) fmt.Println("MaxInt64 = ", math.MaxInt64) fmt.Println("MinInt64 = ", math.MinInt64) fmt.Println("MaxUint8 = ", math.MaxUint8) fmt.Println("MaxUint16 = ", math.MaxUint16) fmt.Println("MaxUint32 = ", math.MaxUint32) // fmt.Println("MaxUint64 = ", math.MaxUint64) fmt.Println("MaxInt16 = ", math.MaxInt16) fmt.Println("MinInt16 = ", math.MinInt16) }
func ext۰math۰Dim(fr *Frame, args []Value) Value { return math.Dim(args[0].(float64), args[1].(float64)) }
// Dim returns the maximum of x-y or 0. // // Special cases are: // Dim(+Inf, +Inf) = NaN // Dim(-Inf, -Inf) = NaN // Dim(x, NaN) = Dim(NaN, x) = NaN func Dim(x, y float32) float32 { return float32(math.Dim(float64(x), float64(y))) }
// group like terms in a multiplication func groupMulTerms(m *Mul) (changed bool) { terms := m.CS L := len(terms) hasConst := false var coeff *ConstantF = nil for i, x := range terms { if x == nil { continue } // setting up current term powSum := 1.0 xT := x.ExprType() if xT == CONSTANT && !hasConst { hasConst = true } if xT == CONSTANTF { if coeff == nil { coeff = x.(*ConstantF) } else { coeff.F *= x.(*ConstantF).F terms[i] = nil continue } } var xC Expr xTb := NULL switch xT { case NEG: xC = x.(*Neg).C xTb = xC.ExprType() case POWI: p := x.(*PowI) xC = p.Base xTb = p.Base.ExprType() powSum = float64(p.Power) case POWF: p := x.(*PowF) xC = p.Base xTb = p.Base.ExprType() powSum = p.Power case POWE: p := x.(*PowE) if p.Power.ExprType() == CONSTANTF { xC = p.Base xTb = p.Base.ExprType() powSum = p.Power.(*ConstantF).F } } for j := i + 1; j < L; j++ { y := terms[j] if y == nil { continue } // setting up following term(s) powY := 1.0 yT := y.ExprType() if yT == CONSTANT && !hasConst { hasConst = true } if yT == CONSTANTF { if coeff == nil { coeff = y.(*ConstantF) } else { coeff.F *= y.(*ConstantF).F terms[j] = nil continue } } var yC Expr yTb := NULL switch yT { case NEG: yC = y.(*Neg).C yTb = yC.ExprType() case POWI: p := y.(*PowI) yC = p.Base yTb = p.Base.ExprType() powY = float64(p.Power) case POWF: p := y.(*PowF) yC = p.Base yTb = p.Base.ExprType() powY = p.Power case POWE: p := y.(*PowE) if p.Power.ExprType() == CONSTANTF { yC = p.Base yTb = p.Base.ExprType() powY = p.Power.(*ConstantF).F } } // fmt.Println("Types: ", xT, xTb, yT, yTb) // This is the actual comparison Code same := false if xT == yT { if x.AmISame(y) { same = true powSum += powY } if xTb == yTb && xTb != NULL { if xC.AmISame(yC) { same = true powSum += powY } } } else if xTb == yT { if xC.AmISame(y) { same = true powSum += powY } } else if xT == yTb { if x.AmISame(yC) { same = true powSum += powY } } else if xTb == yTb && xTb != NULL { if xC.AmISame(yC) { same = true powSum += powY } } // Check the results of camparison update the terms if same { // fmt.Printf("GotHERE\n") terms[j] = nil changed = true if powSum == 0 { terms[i] = nil // remove the lhs term } else if powSum == 1 { // what is lhs? // if PowI || Neg || ? :: then extract Base if xTb != NULL { switch xT { case NEG: terms[i] = x.(*Neg).C case POWI: terms[i] = x.(*PowI).Base case POWF: terms[i] = x.(*PowF).Base } } } else { // whole or fractional power? flr := math.Floor(powSum) dim := math.Dim(powSum, flr) if dim == 0 { // whole power base := x if xT != POWI { if xTb != NULL { switch xT { case NEG: base = x.(*Neg).C case POWF: base = x.(*PowF).Base } } base = NewPowI(base, int(powSum)) } else { base.(*PowI).Power = int(powSum) } terms[i] = base } else { // fractional power base := x if xT != POWF { if xTb != NULL { switch xT { case NEG: base = x.(*Neg).C case POWI: base = x.(*PowI).Base } } base = NewPowF(base, powSum) } else { base.(*PowF).Power = powSum } } } } } } return }
func isEqual(f1, f2, p float64) bool { return math.Dim(float64(f1), float64(f2)) < p }
// 2.变量类型 func typeDemo() { // 变量声明 var v1 int var ( v2 int v3 string ) //var p *int // 指针类型 // 变量初始化 var v4 int = 10 // 等价于: var v5 = 10 // 一般这样就好 v6 := 10 // 赋值,多重赋值 v1 = 10 v2, v3 = 20, "test" // 匿名变量 _ _, v4 = v5, v6 fmt.Println(v1, v2, v3, v4) // 常量 const Pi float64 = 3.1415926 const MaxPlayer = 10 // 枚举 const ( Sunday = iota // iota从0递增 Mondy Tuesday // ... ) // 类型 // 1. 布尔 var b1 bool b1 = true b1 = (1 == 2) fmt.Println(b1) // 2. 整形 // int8 uint8 int16 uint16 int32 uint32 int64 uint64 int uint uintptr var i32 int32 // 强制转换 i32 = int32(64) // 运算:+, -, *, /, %(求余) // 比较:>, <, ==, >=, <=, != // 位运算:x << y, x >> y, x ^ y, x & y, x | y, ^x (取反) fmt.Println(i32) // 3. 浮点 // float32, float64 var f1 float64 = 1.0001 var f2 float64 = 1.0002 // 浮点比较 isEqual := math.Dim(f1, f2) < 0.0001 fmt.Println(isEqual) // 4. 字符串 var s1 string s1 = "abc" // 字符串连接 s1 = s1 + "ddd" // 取长度 n := len(s1) // 取字符 c1 := s1[0] // 反引号,不转义,常用于正则表达式 s1 = `\w+` fmt.Println(c1) fmt.Println(strings.HasPrefix("prefix", "pre")) // true fmt.Println(strings.HasSuffix("suffix", "fix")) // true // 字节遍历 for i := 0; i < n; i++ { ch := s1[i] fmt.Println(ch) } // Unicode字符遍历 for i, ch := range s1 { fmt.Println(i, ch) } // 5. 数组 var arr1 [32]int //var arr2 [3][8]int // 二维数组 // 初始化 arr1 = [32]int{0} array := [5]int{1, 2, 3, 4, 5} // 临时结构体数组 structArray := []struct { name string age int }{{"Tim", 18}, {"Jim", 20}} // 数组遍历 for i := 0; i < len(array); i++ { fmt.Println(array[i]) } for i, v := range structArray { fmt.Println(i, v) } // 数组是值类型,每次参数传递都是一份拷贝 // 数组切片Slice var mySlice []int = arr1[:2] mySlice1 := make([]int, 5) mySlice2 := make([]int, 5, 10) fmt.Println("len(mySlice2:", len(mySlice2)) // 5 fmt.Println("cap(mySlice2:", cap(mySlice2)) // 10 mySlice3 := append(mySlice, 2, 3, 4) mySlice4 := append(mySlice, mySlice1...) copy(mySlice3, mySlice4) // 6. Map var m map[int]string m[1] = "ddd" m1 := make(map[int]string) m2 := map[int]string{ 1: "a", 2: "b", } delete(m2, 1) value, ok := m1[1] if ok { fmt.Println(value) } for k, v := range m2 { fmt.Println(k, v) } }
func IsEqual(f1, f2 float64) bool { return math.Dim(f1, f2) < 0.00001 }