maths

README

Maths

暂无介绍...

目录导航

列出了该 package 下所有的函数及类型定义，可通过目录导航进行快捷跳转 ❤️

展开 / 折叠目录导航

包级函数定义

函数名称	描述
Compare	根据特定表达式比较两个值
IsContinuity	检查一组值是否连续
IsContinuityWithSort	检查一组值排序后是否连续
GetDefaultTolerance	获取默认误差范围
Pow	整数幂运算
PowInt64	整数幂运算
Min	返回两个数之中较小的值
Max	返回两个数之中较大的值
MinMax	将两个数按照较小的和较大的顺序进行返回
MaxMin	将两个数按照较大的和较小的顺序进行返回
Clamp	将给定值限制在最小值和最大值之间
Tolerance	检查两个值是否在一个误差范围内
Merge	通过一个参考值合并两个数字
UnMerge	通过一个参考值取消合并的两个数字
MergeToInt64	将两个数字合并为一个 int64 数字
UnMergeInt64	将一个 int64 数字拆分为两个数字
ToContinuous	将一组非连续的数字转换为从1开始的连续数字
CountDigits	接收一个整数 num 作为输入，并返回该数字的位数
GetDigitValue	接收一个整数 num 和一个表示目标位数的整数 digit 作为输入，并返
JoinNumbers	将一组数字连接起来
IsOdd	返回 n 是否为奇数
IsEven	返回 n 是否为偶数
MakeLastDigitsZero	返回一个新的数，其中 num 的最后 digits 位数被设为零。

类型定义

类型	名称	描述
STRUCT	CompareExpression	比较表达式

---

详情信息

func Compare[V generic.Ordered](a V, expression CompareExpression, b V) bool

根据特定表达式比较两个值

---

func IsContinuity[S ~[]V, V generic.Integer](values S) bool

检查一组值是否连续

示例代码：

func ExampleIsContinuity() {
	fmt.Println(maths.IsContinuity([]int{1, 2, 3, 4, 5, 6, 7}))
	fmt.Println(maths.IsContinuity([]int{1, 2, 3, 5, 5, 6, 7}))
}

---

func IsContinuityWithSort[S ~[]V, V generic.Integer](values S) bool

检查一组值排序后是否连续

---

func GetDefaultTolerance() float64

获取默认误差范围

---

func Pow(a int, n int) int

整数幂运算

---

func PowInt64(a int64, n int64) int64

整数幂运算

---

func Min[V generic.Number](a V, b V) V

返回两个数之中较小的值

---

func Max[V generic.Number](a V, b V) V

返回两个数之中较大的值

---

func MinMax[V generic.Number](a V, b V) (min V, max V)

将两个数按照较小的和较大的顺序进行返回

---

func MaxMin[V generic.Number](a V, b V) (max V, min V)

将两个数按照较大的和较小的顺序进行返回

---

func Clamp[V generic.Number](value V, min V, max V) V

将给定值限制在最小值和最大值之间

---

func Tolerance[V generic.Number](value1 V, value2 V, tolerance V) bool

检查两个值是否在一个误差范围内

---

func Merge[V generic.SignedNumber](refer V, a V, b V) V

通过一个参考值合并两个数字

---

func UnMerge[V generic.SignedNumber](refer V, num V) (a V, b V)

通过一个参考值取消合并的两个数字

---

func MergeToInt64[V generic.SignedNumber](v1 V, v2 V) int64

将两个数字合并为一个 int64 数字

---

func UnMergeInt64[V generic.SignedNumber](n int64) (V, V)

将一个 int64 数字拆分为两个数字

---

func ToContinuous[S ~[]V, V generic.Integer](nums S) map[V]V

将一组非连续的数字转换为从1开始的连续数字

• 返回值是一个 map，key 是从 1 开始的连续数字，value 是原始数字

示例代码：

func ExampleToContinuous() {
	var nums = []int{1, 2, 3, 5, 6, 7, 9, 10, 11}
	var continuous = maths.ToContinuous(nums)
	fmt.Println(nums)
	fmt.Println(continuous)
}

---

func CountDigits[V generic.Number](num V) int

接收一个整数 num 作为输入，并返回该数字的位数

---

func GetDigitValue(num int64, digit int) int64

接收一个整数 num 和一个表示目标位数的整数 digit 作为输入，并返 回数字 num 在指定位数上的数值。我们使用 math.Abs() 函数获取 num 的绝对值，并通 过除以10的操作将 num 移动到目标位数上。然后，通过取余运算得到位数上的数值

---

func JoinNumbers[V generic.Number](num1 V, n ...V) V

将一组数字连接起来

---

func IsOdd[V generic.Integer](n V) bool

返回 n 是否为奇数

---

func IsEven[V generic.Integer](n V) bool

返回 n 是否为偶数

---

func MakeLastDigitsZero[T generic.Number](num T, digits int) T

返回一个新的数，其中 num 的最后 digits 位数被设为零。

• 函数首先创建一个 10 的 digits 次方的遮罩，然后通过整除和乘以这个遮罩来使 num 的最后 digits 位归零。
• 当 T 类型为浮点型时，将被向下取整后再进行转换

查看 / 收起单元测试

func TestMakeLastDigitsZero(t *testing.T) {
	for i := 0; i < 20; i++ {
		n := float64(random.Int64(100, 999999))
		t.Log(n, 3, maths.MakeLastDigitsZero(n, 3))
	}
}

---

CompareExpression STRUCT

比较表达式

type CompareExpression int

Documentation

Index

• Constants
• func Clamp[V generic.Number](value, min, max V) V
• func Compare[V generic.Ordered](a V, expression CompareExpression, b V) bool
• func CountDigits[V generic.Number](num V) int
• func GetDefaultTolerance() float64
• func GetDigitValue(num int64, digit int) int64
• func IsContinuity[S ~[]V, V generic.Integer](values S) bool
• func IsContinuityWithSort[S ~[]V, V generic.Integer](values S) bool
• func IsEven[V generic.Integer](n V) bool
• func IsOdd[V generic.Integer](n V) bool
• func JoinNumbers[V generic.Number](num1 V, n ...V) V
• func MakeLastDigitsZero[T generic.Number](num T, digits int) T
• func Max[V generic.Number](a, b V) V
• func MaxMin[V generic.Number](a, b V) (max, min V)
• func Merge[V generic.SignedNumber](refer, a, b V) V
• func MergeToInt64[V generic.SignedNumber](v1 V, v2 V) int64
• func Min[V generic.Number](a, b V) V
• func MinMax[V generic.Number](a, b V) (min, max V)
• func Pow(a, n int) int
• func PowInt64(a, n int64) int64
• func ToContinuous[S ~[]V, V generic.Integer](nums S) map[V]V
• func Tolerance[V generic.Number](value1, value2, tolerance V) bool
• func UnMerge[V generic.SignedNumber](refer, num V) (a, b V)
• func UnMergeInt64[V generic.SignedNumber](n int64) (V, V)
• type CompareExpression

Examples

• IsContinuity
• ToContinuous

Constants

const (
	DefaultTolerance = 0.0001 // 默认误差范围
	Zero             = 0      // 零
)

Functions

func Clamp

func Clamp[V generic.Number](value, min, max V) V

Clamp 将给定值限制在最小值和最大值之间

func Compare

func Compare[V generic.Ordered](a V, expression CompareExpression, b V) bool

Compare 根据特定表达式比较两个值

func CountDigits

func CountDigits[V generic.Number](num V) int

CountDigits 接收一个整数 num 作为输入，并返回该数字的位数

func GetDefaultTolerance

func GetDefaultTolerance() float64

GetDefaultTolerance 获取默认误差范围

func GetDigitValue

func GetDigitValue(num int64, digit int) int64

GetDigitValue 接收一个整数 num 和一个表示目标位数的整数 digit 作为输入，并返 回数字 num 在指定位数上的数值。我们使用 math.Abs() 函数获取 num 的绝对值，并通 过除以10的操作将 num 移动到目标位数上。然后，通过取余运算得到位数上的数值

func IsContinuity

func IsContinuity[S ~[]V, V generic.Integer](values S) bool

IsContinuity 检查一组值是否连续

Example

package main

import (
	"fmt"
	"github.com/kercylan98/minotaur/utils/maths"
)

func main() {
	fmt.Println(maths.IsContinuity([]int{1, 2, 3, 4, 5, 6, 7}))
	fmt.Println(maths.IsContinuity([]int{1, 2, 3, 5, 5, 6, 7}))
}

Output:

true
false

func IsContinuityWithSort

func IsContinuityWithSort[S ~[]V, V generic.Integer](values S) bool

IsContinuityWithSort 检查一组值排序后是否连续

func IsEven

func IsEven[V generic.Integer](n V) bool

IsEven 返回 n 是否为偶数

func IsOdd

func IsOdd[V generic.Integer](n V) bool

IsOdd 返回 n 是否为奇数

func JoinNumbers

func JoinNumbers[V generic.Number](num1 V, n ...V) V

JoinNumbers 将一组数字连接起来

func MakeLastDigitsZero

func MakeLastDigitsZero[T generic.Number](num T, digits int) T

MakeLastDigitsZero 返回一个新的数，其中 num 的最后 digits 位数被设为零。

• 函数首先创建一个 10 的 digits 次方的遮罩，然后通过整除和乘以这个遮罩来使 num 的最后 digits 位归零。
• 当 T 类型为浮点型时，将被向下取整后再进行转换

func Max

func Max[V generic.Number](a, b V) V

Max 返回两个数之中较大的值

func MaxMin

func MaxMin[V generic.Number](a, b V) (max, min V)

MaxMin 将两个数按照较大的和较小的顺序进行返回

func Merge

func Merge[V generic.SignedNumber](refer, a, b V) V

Merge 通过一个参考值合并两个数字

func MergeToInt64

func MergeToInt64[V generic.SignedNumber](v1 V, v2 V) int64

MergeToInt64 将两个数字合并为一个 int64 数字

func Min

func Min[V generic.Number](a, b V) V

Min 返回两个数之中较小的值

func MinMax

func MinMax[V generic.Number](a, b V) (min, max V)

MinMax 将两个数按照较小的和较大的顺序进行返回

func Pow

func Pow(a, n int) int

Pow 整数幂运算

func PowInt64

func PowInt64(a, n int64) int64

PowInt64 整数幂运算

func ToContinuous

func ToContinuous[S ~[]V, V generic.Integer](nums S) map[V]V

ToContinuous 将一组非连续的数字转换为从1开始的连续数字

• 返回值是一个 map，key 是从 1 开始的连续数字，value 是原始数字

Example

package main

import (
	"fmt"
	"github.com/kercylan98/minotaur/utils/maths"
)

func main() {
	var nums = []int{1, 2, 3, 5, 6, 7, 9, 10, 11}
	var continuous = maths.ToContinuous(nums)

	fmt.Println(nums)
	fmt.Println(continuous)

}

Output:

[1 2 3 5 6 7 9 10 11]
map[1:1 2:2 3:3 4:5 5:6 6:7 7:9 8:10 9:11]

func Tolerance

func Tolerance[V generic.Number](value1, value2, tolerance V) bool

Tolerance 检查两个值是否在一个误差范围内

func UnMerge

func UnMerge[V generic.SignedNumber](refer, num V) (a, b V)

UnMerge 通过一个参考值取消合并的两个数字

func UnMergeInt64

func UnMergeInt64[V generic.SignedNumber](n int64) (V, V)

UnMergeInt64 将一个 int64 数字拆分为两个数字

Types

type CompareExpression

type CompareExpression int

CompareExpression 比较表达式

const (
	CompareGreaterThan        CompareExpression = 1 // 大于
	CompareGreaterThanOrEqual CompareExpression = 2 // 大于等于
	CompareLessThan           CompareExpression = 3 // 小于
	CompareLessThanOrEqual    CompareExpression = 4 // 小于等于
	CompareEqual              CompareExpression = 5 // 等于
)