diff --git a/data/cache/cache_fast.go b/data/cache/cache_fast.go
index a166dfe9643b16cc9394aa0f7561d8af1248b3e2..b2ae6304dc2a7948d04346580ae04b724251d146 100644
--- a/data/cache/cache_fast.go
+++ b/data/cache/cache_fast.go
@@ -2,6 +2,7 @@ package cache
 
 import (
 	"errors"
+	"gitee.com/quant1x/pandas"
 	"gitee.com/quant1x/pandas/data/category"
 	"github.com/mymmsc/gox/logger"
 	"os"
@@ -101,3 +102,11 @@ func GetCache(fullCode string) *os.File {
 	}
 	return file
 }
+
+// KLine 加载K线
+func KLine(code string) pandas.DataFrame {
+	filename := GetCacheFilename(code)
+	df := pandas.ReadCSV(filename)
+	_ = df.SetNames("date", "open", "high", "low", "close", "volume")
+	return df
+}
diff --git a/dataframe_select.go b/dataframe_select.go
index 0c2dc0df37cd8354bc85c2321497a63730f06e19..1f281e3259f40afb9afb4bbad6714968a67612b9 100644
--- a/dataframe_select.go
+++ b/dataframe_select.go
@@ -19,6 +19,19 @@ func (self DataFrame) Col(colname string) stat.Series {
 	return self.columns[idx].Copy()
 }
 
+func (self DataFrame) ColAsNDArray(colname string) stat.Series {
+	if self.Err != nil {
+		return stat.NewSeries[stat.DType]()
+	}
+	// Check that colname exist on dataframe
+	idx := findInStringSlice(colname, self.Names())
+	if idx < 0 {
+		return stat.NewSeries[stat.DType]()
+	}
+	vs := self.columns[idx].DTypes()
+	return stat.NewSeries[stat.DType](vs...)
+}
+
 // SetNames changes the column names of a DataFrame to the ones passed as an
 // argument.
 // 修改全部的列名
diff --git a/formula/ema.go b/formula/ema.go
index 33590e775c4bf929f4b2de85f64ebc3eaf93513c..ac8310c0438225c9eb996cae6008ea69a4a9b7ad 100644
--- a/formula/ema.go
+++ b/formula/ema.go
@@ -8,7 +8,7 @@ import (
 // EMA 指数移动平均,为了精度 S>4*N  EMA至少需要120周期
 // alpha=2/(span+1)
 // TODO:这个版本是对的, 通达信EMA居然实现了真的序列, 那为啥SMA不是呢?!
-func EMA(S stat.Series, N any) any {
+func EMA(S stat.Series, N any) stat.Series {
 	var X []stat.DType
 	switch v := N.(type) {
 	case int:
@@ -28,7 +28,7 @@ func EMA(S stat.Series, N any) any {
 			k = j
 		}
 		return stat.DType(stat.DType(2) / (j + 1))
-	}, Adjust: false}).Mean().Values()
+	}, Adjust: false}).Mean()
 	_ = k
 	return x
 }
diff --git a/indicator/kdj.go b/indicator/kdj.go
new file mode 100644
index 0000000000000000000000000000000000000000..00ed318d2d9eeb8ddf1d778b9070fa8b15e558aa
--- /dev/null
+++ b/indicator/kdj.go
@@ -0,0 +1,45 @@
+package indicator
+
+import (
+	"gitee.com/quant1x/pandas"
+	. "gitee.com/quant1x/pandas/formula"
+)
+
+// KDJ 指标
+//
+//	RSV:=(CLOSE-LLV(LOW,N))/(HHV(HIGH,N)-LLV(LOW,N))*100;
+//	RSV赋值:(收盘价-N日内最低价的最低值)/(N日内最高价的最高值-N日内最低价的最低值)*100
+//	K:EMA(RSV,M1,1);
+//	输出K:RSV的M1日[1日权重]移动平均
+//	D:EMA(K,M2,1);
+//	输出D:K的M2日[1日权重]移动平均
+//	J:3*K-2*D;
+//	输出J:3*K-2*D
+func KDJ(df pandas.DataFrame, N, M1, M2 int) pandas.DataFrame {
+	//CLOSE, HIGH, LOW stat.Series
+	var (
+		CLOSE = df.ColAsNDArray("close")
+		HIGH  = df.ColAsNDArray("high")
+		LOW   = df.ColAsNDArray("low")
+	)
+
+	// 计算N周期的最高价序列
+	x01 := HHV(HIGH, N)
+	// 计算N周期的最低价序列
+	x02 := LLV(LOW, N)
+
+	// CLOSE-LLV(LOW,N)
+	x11 := CLOSE.Sub(x02)
+	// (HHV(HIGH,N)-LLV(LOW,N))*100
+	x12 := x01.Sub(x02)
+
+	//(CLOSE-LLV(LOW,N))/(HHV(HIGH,N)-LLV(LOW,N))*100
+	RSV := x11.Div(x12).Mul(100)
+	//K:SMA(RSV,M1,1);
+	K := EMA(RSV, M1*2-1)
+	D := EMA(K, M2*2-1)
+	// 3*K-2*D;
+	J := K.Mul(3).Sub(D.Mul(2))
+
+	return pandas.NewDataFrame(K, D, J)
+}
diff --git a/indicator/kdj_test.go b/indicator/kdj_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..20995607b4b6a03e7d42f03feada06d545e76dd9
--- /dev/null
+++ b/indicator/kdj_test.go
@@ -0,0 +1,14 @@
+package indicator
+
+import (
+	"fmt"
+	"gitee.com/quant1x/pandas/data/cache"
+	"testing"
+)
+
+func TestKDJ(t *testing.T) {
+	df := cache.KLine("sz002528")
+	fmt.Println(df)
+	df1 := KDJ(df, 9, 3, 3)
+	fmt.Println(df1)
+}
diff --git a/series.go b/series.go
index 9e63db5a0d3f6c2180e1167bbb9bd40db4459db7..60c7a3eb6183836b0b805deca563c737e7f17380 100644
--- a/series.go
+++ b/series.go
@@ -345,3 +345,23 @@ func (self *NDFrame) FillNa(v any, inplace bool) stat.Series {
 	}
 	return self
 }
+
+func (self *NDFrame) Add(x any) stat.Series {
+	//TODO implement me
+	panic("implement me")
+}
+
+func (self *NDFrame) Sub(x any) stat.Series {
+	//TODO implement me
+	panic("implement me")
+}
+
+func (self *NDFrame) Mul(x any) stat.Series {
+	//TODO implement me
+	panic("implement me")
+}
+
+func (self *NDFrame) Div(x any) stat.Series {
+	//TODO implement me
+	panic("implement me")
+}
diff --git a/stat/argmax.go b/stat/argmax.go
index 00239263f6be376bb85b66f101bcae6419faae21..7aab7799a3f24d8c987d894cee2e1ad86d21ff82 100644
--- a/stat/argmax.go
+++ b/stat/argmax.go
@@ -67,11 +67,11 @@ func __arg_max_go[T Ordered](x []T) int {
 }
 
 func __arg_max_go_bool(x []bool) int {
-	max := bool2Int(x[0])
+	max := BoolToInt(x[0])
 	idx := 0
 	for i, v := range x[1:] {
-		if bool2Int(v) > max {
-			max = bool2Int(v)
+		if BoolToInt(v) > max {
+			max = BoolToInt(v)
 			idx = 1 + i
 		}
 	}
diff --git a/stat/argmin.go b/stat/argmin.go
index d77e568ec43fde056da55955ee17682f17c13636..264692be4ad474cfe476b055abdc91478f10804f 100644
--- a/stat/argmin.go
+++ b/stat/argmin.go
@@ -67,11 +67,11 @@ func __arg_min_go[T Ordered](x []T) int {
 }
 
 func __arg_min_go_bool(x []bool) int {
-	min := bool2Int(x[0])
+	min := BoolToInt(x[0])
 	idx := 0
 	for i, v := range x[1:] {
-		if bool2Int(v) < min {
-			min = bool2Int(v)
+		if BoolToInt(v) < min {
+			min = BoolToInt(v)
 			idx = 1 + i
 		}
 	}
diff --git a/stat/ndarray_fromnumeric.go b/stat/ndarray_fromnumeric.go
index ef7c449d089a3ae729365f06fa971f489ab4b2e6..62154876567c4791d81ff93ec21d5a0421a980cd 100644
--- a/stat/ndarray_fromnumeric.go
+++ b/stat/ndarray_fromnumeric.go
@@ -7,3 +7,83 @@ func (self NDArray[T]) ArgMax() int {
 func (self NDArray[T]) ArgMin() int {
 	return ArgMin2(self)
 }
+
+func (self NDArray[T]) Add(x any) Series {
+	length := self.Len()
+	var b []DType
+	switch sx := x.(type) {
+	case Series:
+		b = sx.DTypes()
+	case int:
+		b = Repeat[DType](DType(sx), length)
+	case DType:
+		b = Repeat[DType](sx, length)
+	//case int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, uintptr, float32, float64:
+	//	b = Repeat[DType](DType(sx), length)
+	default:
+		panic(Throw(x))
+	}
+	a := self.DTypes()
+	s := Add(a, b)
+	return NDArray[DType](s)
+}
+
+func (self NDArray[T]) Sub(x any) Series {
+	length := self.Len()
+	var b []DType
+	switch sx := x.(type) {
+	case Series:
+		b = sx.DTypes()
+	case int:
+		b = Repeat[DType](DType(sx), length)
+	case DType:
+		b = Repeat[DType](sx, length)
+	//case int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, uintptr, float32, float64:
+	//	b = Repeat[DType](DType(sx), length)
+	default:
+		panic(Throw(x))
+	}
+	a := self.DTypes()
+	s := Sub(a, b)
+	return NDArray[DType](s)
+}
+
+func (self NDArray[T]) Mul(x any) Series {
+	length := self.Len()
+	var b []DType
+	switch sx := x.(type) {
+	case Series:
+		b = sx.DTypes()
+	case int:
+		b = Repeat[DType](DType(sx), length)
+	case DType:
+		b = Repeat[DType](sx, length)
+	//case int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, uintptr, float32, float64:
+	//	b = Repeat[DType](DType(sx), length)
+	default:
+		panic(Throw(x))
+	}
+	a := self.DTypes()
+	s := Mul(a, b)
+	return NDArray[DType](s)
+}
+
+func (self NDArray[T]) Div(x any) Series {
+	length := self.Len()
+	var b []DType
+	switch sx := x.(type) {
+	case Series:
+		b = sx.DTypes()
+	case int:
+		b = Repeat[DType](DType(sx), length)
+	case DType:
+		b = Repeat[DType](sx, length)
+	//case int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, uintptr, float32, float64:
+	//	b = Repeat[DType](DType(sx), length)
+	default:
+		panic(Throw(x))
+	}
+	a := self.DTypes()
+	s := Div(a, b)
+	return NDArray[DType](s)
+}
diff --git a/stat/ndarray_type.go b/stat/ndarray_type.go
index bdf97db46748de70181d781abc60a35fe6e9ecd3..436ea7a70edea266672a46ace9aad3079955b4d5 100644
--- a/stat/ndarray_type.go
+++ b/stat/ndarray_type.go
@@ -13,6 +13,7 @@ type Type = reflect.Kind
 const (
 	SERIES_TYPE_INVAILD = reflect.Invalid // 无效类型
 	SERIES_TYPE_BOOL    = reflect.Bool    // 布尔类型
+	SERIES_TYPE_INT32   = reflect.Int32   // int64
 	SERIES_TYPE_INT64   = reflect.Int64   // int64
 	SERIES_TYPE_FLOAT32 = reflect.Float32 // float32
 	SERIES_TYPE_FLOAT64 = reflect.Float64 // float64
diff --git a/stat/rolling_max.go b/stat/rolling_max.go
index 56360768e0d50ba7fb87b05d24d1dd9b25ceedd7..e8cc2e44b32edefd59c0abcd65fcf9800de9aa75 100644
--- a/stat/rolling_max.go
+++ b/stat/rolling_max.go
@@ -3,17 +3,7 @@ package stat
 func (r RollingAndExpandingMixin) Max() (s Series) {
 	s = r.Series.Empty()
 	for _, block := range r.GetBlocks() {
-		//// 1. 排序处理方式
-		//if block.Len() == 0 {
-		//	s.Append(s.NaN())
-		//	continue
-		//}
-		//sort.Sort(block)
-		//r := RangeFinite(-1)
-		//_s := block.Select(r)
-		//s.Append(_s.Values())
-		// 2. Series.Max方法
-		s.Append(block.Max())
+		s = s.Append(block.Max())
 	}
 	return
 }
diff --git a/stat/rolling_mean.go b/stat/rolling_mean.go
index 8b8bd6dbe1cd9f325ca635ca1ca9673dccb8fb97..99a67622de38261cf4496897405fa1f8e5f66b33 100644
--- a/stat/rolling_mean.go
+++ b/stat/rolling_mean.go
@@ -6,7 +6,6 @@ func (r RollingAndExpandingMixin) Mean() (s Series) {
 	for _, block := range r.GetBlocks() {
 		d = append(d, block.Mean())
 	}
-	//s = pandas.NewSeries(SERIES_TYPE_DTYPE, r.series.Name(), d)
 	s = r.Series.Empty(SERIES_TYPE_DTYPE)
 	s.Rename(r.Series.Name())
 	s = s.Append(d)
diff --git a/stat/rolling_min.go b/stat/rolling_min.go
index 1881d58f4b9f0d0d522843b907559bdd040f561d..8edd010ad25a343224326814fb78fca0a90376dc 100644
--- a/stat/rolling_min.go
+++ b/stat/rolling_min.go
@@ -3,17 +3,7 @@ package stat
 func (r RollingAndExpandingMixin) Min() (s Series) {
 	s = r.Series.Empty()
 	for _, block := range r.GetBlocks() {
-		//// 1. 排序处理方式
-		//if block.Len() == 0 {
-		//	s.Append(s.NaN())
-		//	continue
-		//}
-		//sort.Sort(block)
-		//r := RangeFinite(0, 1)
-		//_s := block.Select(r)
-		//s.Append(_s.Values())
-		// 2. Series.Max方法
-		s.Append(block.Min())
+		s = s.Append(block.Min())
 	}
 	return
 }
diff --git a/stat/rolling_std.go b/stat/rolling_std.go
index 7ef3761aae3d7bfbedb88570837c1de5c7f44769..1bdd0a1d473407e28ced720b4c36ed06a00b308c 100644
--- a/stat/rolling_std.go
+++ b/stat/rolling_std.go
@@ -3,17 +3,7 @@ package stat
 func (r RollingAndExpandingMixin) Std() Series {
 	s := r.Series.Empty()
 	for _, block := range r.GetBlocks() {
-		//// 1. 排序处理方式
-		//if block.Len() == 0 {
-		//	s.Append(s.NaN())
-		//	continue
-		//}
-		//sort.Sort(block)
-		//r := RangeFinite(-1)
-		//_s := block.Select(r)
-		//s.Append(_s.Values())
-		// 2. Series.Max方法
-		s.Append(block.Std())
+		s = s.Append(block.Std())
 	}
 	return s
 }
diff --git a/stat/series.go b/stat/series.go
index 990d0b8b37c5c14cd8f474fda38086454f417b46..3bc6a9a700995314b229175ae3241bd4218e5e76 100644
--- a/stat/series.go
+++ b/stat/series.go
@@ -15,12 +15,9 @@ type Series interface {
 	Type() Type
 	// Values 获得全部数据集
 	Values() any
-
-	// Reverse 序列反转
-	Reverse() Series
-
 	// NaN 输出默认的NaN
 	NaN() any
+
 	// Floats 强制转成[]float32
 	Floats() []float32
 	// DTypes 强制转[]stat.DType
@@ -41,23 +38,44 @@ type Series interface {
 	Empty(t ...Type) Series
 	// Copy 复制
 	Copy() Series
+	// Reverse 序列反转
+	Reverse() Series
+	// Select 选取一段记录
+	Select(r ScopeLimit) Series
+	// Append 增加一批记录
+	Append(values ...any) Series
+
 	// Records returns the elements of a Series as a []string
 	Records() []string
 	// Subset 获取子集
 	Subset(start, end int, opt ...any) Series
 	// Repeat elements of an array.
 	Repeat(x any, repeats int) Series
+	// FillNa Fill NA/NaN values using the specified method.
+	FillNa(v any, inplace bool) Series
+
+	// Ref 引用其它周期的数据
+	Ref(param any) (s Series)
 	// Shift index by desired number of periods with an optional time freq.
 	// 使用可选的时间频率按所需的周期数移动索引.
 	Shift(periods int) Series
 	// Rolling 序列化版本
 	Rolling(param any) RollingAndExpandingMixin
+	// Apply 接受一个回调函数
+	Apply(f func(idx int, v any))
+	// Logic 逻辑处理
+	Logic(f func(idx int, v any) bool) []bool
+	// EWM Provide exponentially weighted (EW) calculations.
+	//
+	//	Exactly one of ``com``, ``span``, ``halflife``, or ``alpha`` must be
+	//	provided if ``times`` is not provided. If ``times`` is provided,
+	//	``halflife`` and one of ``com``, ``span`` or ``alpha`` may be provided.
+	EWM(alpha EW) ExponentialMovingWindow
+
 	// Mean calculates the average value of a series
 	Mean() DType
 	// StdDev calculates the standard deviation of a series
 	StdDev() DType
-	// FillNa Fill NA/NaN values using the specified method.
-	FillNa(v any, inplace bool) Series
 	// Max 找出最大值
 	Max() any
 	// ArgMax Returns the indices of the maximum values along an axis
@@ -66,28 +84,16 @@ type Series interface {
 	Min() any
 	// ArgMin Returns the indices of the minimum values along an axis
 	ArgMin() int
-	// Select 选取一段记录
-	Select(r ScopeLimit) Series
-	// Append 增加一批记录
-	Append(values ...any) Series
-	// Apply 接受一个回调函数
-	Apply(f func(idx int, v any))
-	// Logic 逻辑处理
-	Logic(f func(idx int, v any) bool) []bool
 	// Diff 元素的第一个离散差
 	Diff(param any) (s Series)
-	// Ref 引用其它周期的数据
-	Ref(param any) (s Series)
 	// Std 计算标准差
 	Std() DType
 	// Sum 计算累和
 	Sum() DType
-	// EWM Provide exponentially weighted (EW) calculations.
-	//
-	//	Exactly one of ``com``, ``span``, ``halflife``, or ``alpha`` must be
-	//	provided if ``times`` is not provided. If ``times`` is provided,
-	//	``halflife`` and one of ``com``, ``span`` or ``alpha`` may be provided.
-	EWM(alpha EW) ExponentialMovingWindow
+	Add(x any) Series
+	Sub(x any) Series
+	Mul(x any) Series
+	Div(x any) Series
 }
 
 // DetectTypeBySlice 检测类型
diff --git a/stat/ndarray_convert.go b/stat/series_convert.go
similarity index 44%
rename from stat/ndarray_convert.go
rename to stat/series_convert.go
index a11827f81e015aca9223bdff9beae7317e449517..7e2f9f0f8b7d8250a9e7bcd9df43a30ac59ca6ce 100644
--- a/stat/ndarray_convert.go
+++ b/stat/series_convert.go
@@ -3,7 +3,6 @@ package stat
 import (
 	"github.com/viterin/vek"
 	"github.com/viterin/vek/vek32"
-	"reflect"
 )
 
 // 这里做数组统一转换
@@ -15,69 +14,73 @@ func convert[T GenericType](s Series, v T) {
 	_ = ok
 }
 
+// ToFloat32 转换Float32
 func ToFloat32(s Series) []float32 {
-	length := s.Len()
-	defaultSlice := vek32.Repeat(Nil2Float32, length)
 	values := s.Values()
 	__type := s.Type()
-	if __type == SERIES_TYPE_INVAILD {
-		return defaultSlice
-	} else if __type == SERIES_TYPE_BOOL {
-		return vek32.FromBool(values.([]bool))
-	} else if __type == SERIES_TYPE_INT64 {
-		return vek32.FromInt64(values.([]int64))
-	} else if __type == SERIES_TYPE_FLOAT32 {
-		return values.([]float32)
-	} else if __type == SERIES_TYPE_FLOAT64 {
+	switch __type {
+	case SERIES_TYPE_FLOAT32:
+		return values.([]float32) // TODO:是否复制
+	case SERIES_TYPE_FLOAT64:
 		return vek32.FromFloat64(values.([]float64))
-	} else if __type == reflect.Int32 {
+	case SERIES_TYPE_INT32:
 		return vek32.FromInt32(values.([]int32))
-	} else {
+	case SERIES_TYPE_INT64:
+		return vek32.FromInt64(values.([]int64))
+	case SERIES_TYPE_BOOL:
+		return vek32.FromBool(values.([]bool))
+	default:
+		length := s.Len()
+		defaultSlice := vek32.Repeat(Nil2Float32, length)
 		return defaultSlice
 	}
 }
 
 func ToFloat64(s Series) []float64 {
-	length := s.Len()
-	defaultSlice := vek.Repeat(Nil2Float64, length)
 	values := s.Values()
 	__type := s.Type()
-	if __type == SERIES_TYPE_INVAILD {
-		return defaultSlice
-	} else if __type == SERIES_TYPE_BOOL {
-		return vek.FromBool(values.([]bool))
-	} else if __type == SERIES_TYPE_INT64 {
-		return vek.FromInt64(values.([]int64))
-	} else if __type == SERIES_TYPE_FLOAT32 {
+	switch __type {
+	case SERIES_TYPE_FLOAT32:
 		return vek.FromFloat32(values.([]float32))
-	} else if __type == SERIES_TYPE_FLOAT64 {
-		return values.([]float64) // 是否复制
-	} else if __type == reflect.Int32 {
+	case SERIES_TYPE_FLOAT64:
+		return values.([]float64) // TODO:是否复制
+	case SERIES_TYPE_INT32:
 		return vek.FromInt32(values.([]int32))
-	} else {
+	case SERIES_TYPE_INT64:
+		return vek.FromInt64(values.([]int64))
+	case SERIES_TYPE_BOOL:
+		return vek.FromBool(values.([]bool))
+	default:
+		length := s.Len()
+		defaultSlice := vek.Repeat(Nil2Float64, length)
 		return defaultSlice
 	}
 }
 
 func ToBool(s Series) []bool {
-	length := s.Len()
-	defaultSlice := make([]bool, length)
 	values := s.Values()
 	__type := s.Type()
-	if __type == SERIES_TYPE_INVAILD {
-		return defaultSlice
-	} else if __type == SERIES_TYPE_BOOL {
+	switch __type {
+	case SERIES_TYPE_FLOAT32:
+		return __NumberToBool_S(values.([]float32))
+	case SERIES_TYPE_FLOAT64:
+		return __NumberToBool_S(values.([]int64))
+	case SERIES_TYPE_INT32:
+		return __NumberToBool_S(values.([]int32))
+	case SERIES_TYPE_INT64:
+		return __NumberToBool_S(values.([]int64))
+	case SERIES_TYPE_BOOL:
 		return values.([]bool)
-	} else if __type == SERIES_TYPE_INT64 {
-		return __toBool(values.([]int64))
-	} else if __type == SERIES_TYPE_FLOAT32 {
-		return __toBool(values.([]float32))
-	} else {
+	case SERIES_TYPE_STRING:
+		return __StringToBool_S(values.([]string))
+	default:
+		length := s.Len()
+		defaultSlice := make([]bool, length)
 		return defaultSlice
 	}
 }
 
-func __toBool[T Number](values []T) []bool {
+func __NumberToBool_S[T Number](values []T) []bool {
 	length := len(values)
 	vs := make([]bool, length)
 	for i, v := range values {
@@ -89,3 +92,21 @@ func __toBool[T Number](values []T) []bool {
 	}
 	return vs
 }
+
+func __StringToBool_S(values []string) []bool {
+	length := len(values)
+	vs := make([]bool, length)
+	for i, v := range values {
+		if StringIsTrue(v) {
+			vs[i] = true
+		} else {
+			vs[i] = false
+		}
+	}
+	return vs
+}
+
+func __NumberToSeries[T Number](x T, n int) Series {
+	s := Repeat[T](x, n)
+	return NDArray[T](s)
+}
diff --git a/stat/ndarray_convert_test.go b/stat/series_convert_test.go
similarity index 100%
rename from stat/ndarray_convert_test.go
rename to stat/series_convert_test.go
diff --git a/stat/type.go b/stat/type.go
index a239602064bf02fb376b5bf5b045ebe9f3d87ce8..2d925bdbd25123986f8dcb9590725217d1a5f992 100644
--- a/stat/type.go
+++ b/stat/type.go
@@ -203,7 +203,7 @@ func __anyToNumber[T Number](v any) T {
 	case float64:
 		return T(val)
 	case bool:
-		return T(bool2Int(val))
+		return T(BoolToInt(val))
 	case string:
 		vt := ParseFloat64(val, v)
 		if Float64IsNaN(vt) {
diff --git a/stat/type_bool.go b/stat/type_bool.go
index 7aefcc6c5fbd82ba885ca850d9c84e5b26296d8a..d9f1ed2cbbabdbd82844c0d8d93a28091fa213e4 100644
--- a/stat/type_bool.go
+++ b/stat/type_bool.go
@@ -19,7 +19,7 @@ const (
 	StringFalse2Bool = false // 字符串false转bool
 )
 
-func isTrue(s string) bool {
+func StringIsTrue(s string) bool {
 	if s == "true" || s == "TRUE" || s == "True" || s == "1" || s == "真" || s == "对" || s == "好" {
 		return true
 	} else {
@@ -27,7 +27,7 @@ func isTrue(s string) bool {
 	}
 }
 
-func isFalse(s string) bool {
+func StringIsFalse(s string) bool {
 	if s == "false" || s == "FALSE" || s == "False" || s == "0" || s == "假" || s == "错" || s == "坏" {
 		return true
 	} else {
@@ -35,37 +35,37 @@ func isFalse(s string) bool {
 	}
 }
 
-func bool2Int(b bool) int8 {
+func BoolToInt(b bool) int8 {
 	if b {
 		return int8(1)
 	}
 	return int8(0)
 }
 
-func boolToInt32(b bool) int32 {
+func BoolToInt32(b bool) int32 {
 	if b {
 		return True2Int32
 	}
 	return False2Int32
 }
 
-func boolToInt64(b bool) int64 {
+func BoolToInt64(b bool) int64 {
 	if b {
 		return True2Int64
 	}
 	return False2Int64
 }
 
-// bool转float32
-func boolToFloat32(b bool) float32 {
+// BoolToFloat32 bool转float32
+func BoolToFloat32(b bool) float32 {
 	if b {
 		return True2Float32
 	}
 	return False2Float32
 }
 
-// bool转float64
-func boolToFloat64(b bool) float64 {
+// BoolToFloat64 bool转float64
+func BoolToFloat64(b bool) float64 {
 	if b {
 		return True2Float64
 	}
@@ -73,7 +73,8 @@ func boolToFloat64(b bool) float64 {
 }
 
 // ParseBool 字符串转bool
-// 任意组合的nan字符串都会被解析成NaN
+//
+//	任意组合的nan字符串都会被解析成NaN
 func ParseBool(s string, v any) bool {
 	defer func() {
 		// 解析失败以后输出日志, 以备检查
@@ -138,9 +139,9 @@ func AnyToBool(v any) bool {
 		if IsEmpty(*val) {
 			return Nil2Bool
 		}
-		if isTrue(*val) {
+		if StringIsTrue(*val) {
 			return StringTrue2Bool
-		} else if isFalse(*val) {
+		} else if StringIsFalse(*val) {
 			return StringFalse2Bool
 		}
 		f := ParseBool(*val, v)
@@ -149,9 +150,9 @@ func AnyToBool(v any) bool {
 		if IsEmpty(val) {
 			return Nil2Bool
 		}
-		if isTrue(val) {
+		if StringIsTrue(val) {
 			return StringTrue2Bool
-		} else if isFalse(val) {
+		} else if StringIsFalse(val) {
 			return StringFalse2Bool
 		}
 		f := ParseBool(val, v)
diff --git a/stat/type_float32.go b/stat/type_float32.go
index dd70c573f7ce522d17246b356076002a3c06e739..1fb7250321ed0275789fe6bacbd9032d5abdb023 100644
--- a/stat/type_float32.go
+++ b/stat/type_float32.go
@@ -106,9 +106,9 @@ func ParseFloat32(s string, v any) float32 {
 		// TODO:NaN是针对64位, 这样直接转换应该有问题, 需要进一步确认
 		return Nil2Float32
 	}
-	if isTrue(s) {
+	if StringIsTrue(s) {
 		return StringTrue2Float32
-	} else if isFalse(s) {
+	} else if StringIsFalse(s) {
 		return StringFalse2Float32
 	}
 
@@ -128,6 +128,6 @@ func AnyToFloat32(v any) float32 {
 		v = vv
 	}
 
-	f := valueToNumber(v, Nil2Float32, boolToFloat32, ParseFloat32)
+	f := valueToNumber(v, Nil2Float32, BoolToFloat32, ParseFloat32)
 	return f
 }
diff --git a/stat/type_float64.go b/stat/type_float64.go
index 0085e15a4c421c5c767d92cbf17e6cdcc7fd0b4a..d583634da16d5afce0d188b7c842014fd2bc2ad0 100644
--- a/stat/type_float64.go
+++ b/stat/type_float64.go
@@ -58,9 +58,9 @@ func ParseFloat64(s string, v any) float64 {
 	if IsEmpty(s) {
 		return Nil2Float64
 	}
-	if isTrue(s) {
+	if StringIsTrue(s) {
 		return StringTrue2Float64
-	} else if isFalse(s) {
+	} else if StringIsFalse(s) {
 		return StringFalse2Float64
 	}
 	f, err := strconv.ParseFloat(s, 64)
@@ -79,7 +79,7 @@ func AnyToFloat64(v any) float64 {
 		v = vv
 	}
 
-	f := valueToNumber(v, Nil2Float64, boolToFloat64, ParseFloat64)
+	f := valueToNumber(v, Nil2Float64, BoolToFloat64, ParseFloat64)
 	return f
 }
 
diff --git a/stat/type_int32.go b/stat/type_int32.go
index e8296690ffc768de067fb659367b3bf197016269..5f3185639ac1d313897588229ff7586a38bda4d4 100644
--- a/stat/type_int32.go
+++ b/stat/type_int32.go
@@ -30,9 +30,9 @@ func ParseInt32(s string, v any) int32 {
 	if IsEmpty(s) {
 		return Nil2Int32
 	}
-	if isTrue(s) {
+	if StringIsTrue(s) {
 		return StringTrue2Int32
-	} else if isFalse(s) {
+	} else if StringIsFalse(s) {
 		return StringFalse2Int32
 	}
 	i, err := strconv.ParseInt(s, 10, 32)
@@ -66,6 +66,6 @@ func AnyToInt32(v any) int32 {
 		v = vv
 	}
 
-	f := valueToNumber[int32](v, Nil2Int32, boolToInt32, ParseInt32)
+	f := valueToNumber[int32](v, Nil2Int32, BoolToInt32, ParseInt32)
 	return f
 }
diff --git a/stat/type_int64.go b/stat/type_int64.go
index f23cfed0c6f8c475e0218f885dc28b998a960bfa..c63863cc68f471a139ec774e7dc0b97fa1b57e16 100644
--- a/stat/type_int64.go
+++ b/stat/type_int64.go
@@ -30,9 +30,9 @@ func ParseInt64(s string, v any) int64 {
 	if IsEmpty(s) {
 		return Nil2Int64
 	}
-	if isTrue(s) {
+	if StringIsTrue(s) {
 		return StringTrue2Int64
-	} else if isFalse(s) {
+	} else if StringIsFalse(s) {
 		return StringFalse2Int64
 	}
 	i, err := strconv.ParseInt(s, 10, 64)
@@ -66,6 +66,6 @@ func AnyToInt64(v any) int64 {
 		v = vv
 	}
 
-	f := valueToNumber[int64](v, Nil2Int64, boolToInt64, ParseInt64)
+	f := valueToNumber[int64](v, Nil2Int64, BoolToInt64, ParseInt64)
 	return f
 }