update comments

update comments in all of files in convenient to generate package information using `godoc` command or give tips in LiteIDE editor when the cursor keeps resting on a function or method.

Author: chfenger

Anm.go

@@ -13,13 +13,27 @@
     n       整数
     m       整数, m <= n
 输出   :
-    
+
 ------------------------------------------------------
 */
 
 package goNum
 
+// Anm
+//              m
+//    计算排列 A  的值
+//              n
 func Anm(n, m int) int {
+	/*
+	                m
+	       计算排列 A  的值
+	                n
+	   ------------------------------------------------------
+	   输入   :
+	       n       整数
+	       m       整数, m <= n
+	   输出   :
+	*/
 	//不直接使用阶乘计算可以稍许增加速度
 	temp0 := 1
 	for i := n; i >= n-m+1; i-- {

Bisection.go

@@ -27,18 +27,22 @@ import (
 	"math"
 )
 
+// Bisection 此程序设计使用二分法来求解连续、单自变量、单调函数（区间
+//内）指定有限区间上的解
 func Bisection(fn func(float64) float64, a, b float64, N int, tol float64) (float64, bool) {
 	/*
-		用二分法来求解连续、单自变量、单调函数（区间内）指定有限区间上的解
-		输入   :
-		    fn      函数，定义为等式左侧部分，右侧为零
-		    a, b    求解区间
-		    N       步数上限
-		    tol     误差上限
-		输出   :
-		    sol     解值
-		    err     解出标志：false-未解出或达到步数上限；
-		                     true-全部解出
+	       此程序设计使用二分法来求解连续、单自变量、单调函数（区间
+	   内）指定有限区间上的解
+	       线性收敛
+	   输入   :
+	       fn      函数，定义为等式左侧部分，右侧为零
+	       a, b    求解区间
+	       N       步数上限
+	       tol     误差上限
+	   输出   :
+	       sol     解值
+	       err     解出标志：false-未解出或达到步数上限；
+	                        true-全部解出
 	*/
 	var sol float64
 	var err bool = false

Bisection_test.go

@@ -28,18 +28,22 @@ import (
 	"testing"
 )
 
+// Bisection 此程序设计使用二分法来求解连续、单自变量、单调函数（区间
+//内）指定有限区间上的解
 func Bisection(fn func(float64) float64, a, b float64, N int, tol float64) (float64, bool) {
 	/*
-		用二分法来求解连续、单自变量、单调函数（区间内）指定有限区间上的解
-		输入   :
-		    fn      函数，定义为等式左侧部分，右侧为零
-		    a, b    求解区间
-		    N       步数上限
-		    tol     误差上限
-		输出   :
-		    sol     解值
-		    err     解出标志：false-未解出或达到步数上限；
-		                     true-全部解出
+	       此程序设计使用二分法来求解连续、单自变量、单调函数（区间
+	   内）指定有限区间上的解
+	       线性收敛
+	   输入   :
+	       fn      函数，定义为等式左侧部分，右侧为零
+	       a, b    求解区间
+	       N       步数上限
+	       tol     误差上限
+	   输出   :
+	       sol     解值
+	       err     解出标志：false-未解出或达到步数上限；
+	                        true-全部解出
 	*/
 	var sol float64
 	var err bool = false

Cnm.go

@@ -10,16 +10,29 @@
              n
 ------------------------------------------------------
 输入   :
-    n       正整数
-    m       正整数， m <= n
+    n       整数
+    m       整数，m <= n
 输出   :
-    
+
 ------------------------------------------------------
 */
 
 package goNum
 
+// Cnm
+//             m
+//    计算组合 C  的值
+//             n
 func Cnm(n, m int) int {
+	/*
+	                m
+	       计算组合 C  的值
+	                n
+	   输入   :
+	       n       整数
+	       m       整数，m <= n
+	   输出   :
+	*/
 	//不直接使用阶乘计算可以稍许增加速度
 	return Anm(n, m) / Factorial(m)
 }

DerivativePoly.go

@@ -21,16 +21,17 @@
 
 package goNum
 
+// DerivativePoly 求单变量多项式n阶导数
 func DerivativePoly(A Matrix, n int) (Matrix, bool) {
 	/*
-		求单变量多项式n阶导数
-		输入   :
-		    A       按幂次连续增加的系数向量,(N+1)x1,N为最高幂次
-		    n       求导次数
-		输出   :
-		    sol     解,(N+1-n)x1
-		    err     解出标志：false-未解出或达到边界；
-		                     true-全部解出
+	       求单变量多项式n阶导数
+	   输入   :
+	       A       按幂次连续增加的系数向量,(Nn+1)x1,Nn为最高幂次
+	       n       求导次数
+	   输出   :
+	       sol     解,(Nn+1-n)x1
+	       err     解出标志：false-未解出或达到边界；
+	                        true-全部解出
 	*/
 	//判断求导次数与最高幂次关系
 	Nn := A.Rows - 1

DerivativePoly_test.go

@@ -27,16 +27,17 @@ import (
 	"github.com/chfenger/goNum"
 )
 
+// DerivativePoly 求单变量多项式n阶导数
 func DerivativePoly(A goNum.Matrix, n int) (goNum.Matrix, bool) {
 	/*
-		求单变量多项式n阶导数
-		输入   :
-		    A       按幂次连续增加的系数向量,(N+1)x1,N为最高幂次
-		    n       求导次数
-		输出   :
-		    sol     解,(N+1-n)x1
-		    err     解出标志：false-未解出或达到边界；
-		                     true-全部解出
+	       求单变量多项式n阶导数
+	   输入   :
+	       A       按幂次连续增加的系数向量,(Nn+1)x1,Nn为最高幂次
+	       n       求导次数
+	   输出   :
+	       sol     解,(Nn+1-n)x1
+	       err     解出标志：false-未解出或达到边界；
+	                        true-全部解出
 	*/
 	//判断求导次数与最高幂次关系
 	Nn := A.Rows - 1

DetA.go

@@ -25,17 +25,17 @@ import (
 	"math"
 )
 
+// DetA 求矩阵行列式值的列主元消去法
 func DetA(a [][]float64) (float64, bool) {
 	/*
-		求矩阵行列式值的列主元消去法
-		输入   :
-		    a       矩阵
-		输出   :
-		    sol     解值，值
-		    err     解出标志：false-未解出或达到步数上限；
-		                     true-全部解出
+	       求矩阵行列式值的列主元消去法
+	   输入   :
+	       a       矩阵
+	   输出   :
+	       sol     解值，值
+	       err     解出标志：false-未解出或达到步数上限；
+	                        true-全部解出
 	*/
-
 	var sol float64 = 1.0
 	var err bool = false
 	var count0 int

DetA_test.go

@@ -28,6 +28,7 @@ import (
 	"github.com/chfenger/goNum"
 )
 
+// DetA 求矩阵行列式值的列主元消去法
 func DetA(a [][]float64) (float64, bool) {
 	/*
 		求矩阵行列式值的列主元消去法

E_Mat.go

@@ -18,17 +18,17 @@
 
 package goNum
 
+// E_Mat 返回n阶单位矩阵
 func E_Mat(n int) ([][]float64, bool) {
 	/*
-		返回n阶单位矩阵
-		输入   :
-		    n       阶数
-		输出   :
-		    sol     解值
-		    err     解出标志：false-未解出或达到步数上限；
-		                     true-全部解出
+	       返回n阶单位矩阵
+	   输入   :
+	       n       阶数
+	   输出   :
+	       sol     解值
+	       err     解出标志：false-未解出或达到步数上限；
+	                        true-全部解出
 	*/
-
 	sol := make([][]float64, n)
 	for i := 0; i < n; i++ {
 		sol[i] = make([]float64, n)

ErrorEvaluation.go

@@ -37,6 +37,7 @@ import (
 	"math"
 )
 
+// MaxError 最大误差
 func MaxError(FY Matrix) float64 {
 	//最大误差
 	//判断FY的维数
@@ -53,6 +54,7 @@ func MaxError(FY Matrix) float64 {
 	return maxE
 }
 
+// MeanError 平均误差
 func MeanError(FY Matrix) float64 {
 	//平均误差
 	//判断FY的维数
@@ -68,6 +70,7 @@ func MeanError(FY Matrix) float64 {
 	return meanE
 }
 
+// RMSError 均方根误差
 func RMSError(FY Matrix) float64 {
 	//均方根误差
 	//判断FY的维数

Factorial.go

@@ -18,6 +18,7 @@
 
 package goNum
 
+// Factorial 计算自然数n的阶乘
 func Factorial(n int) int {
 	//判断n
 	if n < 0 {

Fibonacci.go

@@ -18,6 +18,7 @@
 
 package goNum
 
+// Fibonacci 求Fibonacci数列
 func Fibonacci(n int) int {
 	/*
 	   求Fibonacci数列

FittingBezier.go

@@ -38,7 +38,7 @@
 
 package goNum
 
-//Bernstein Polynomial
+//BernsteinPoly Bernstein Polynomial
 func BernsteinPoly(i, N int) Matrix {
 	cni := Cnm(N, i)
 	sol := ZeroMatrix(N+1, 1)
@@ -62,6 +62,7 @@ func BernsteinPoly(i, N int) Matrix {
 	return sol
 }
 
+// FittingBezier Bezier曲线拟合控制点
 func FittingBezier(XY Matrix) (Matrix, bool) {
 	/*
 		Bezier曲线拟合控制点

FittingBezier_test.go

@@ -44,7 +44,7 @@ import (
 	"github.com/chfenger/goNum"
 )
 
-//Bernstein Polynomial
+//BernsteinPoly Bernstein Polynomial
 func BernsteinPoly(i, N int) goNum.Matrix {
 	cni := goNum.Cnm(N, i)
 	sol := goNum.ZeroMatrix(N+1, 1)
@@ -68,6 +68,7 @@ func BernsteinPoly(i, N int) goNum.Matrix {
 	return sol
 }
 
+// FittingBezier Bezier曲线拟合控制点
 func FittingBezier(XY goNum.Matrix) (goNum.Matrix, bool) {
 	/*
 		Bezier曲线拟合控制点

FittingLSQ.go

@@ -33,6 +33,7 @@
 
 package goNum
 
+// FittingLSQ 线性最小二乘拟合
 func FittingLSQ(XY Matrix) (Matrix, bool) {
 	/*
 		线性最小二乘拟合

FittingLSQ_test.go

@@ -39,6 +39,7 @@ import (
 	"github.com/chfenger/goNum"
 )
 
+// FittingLSQ 线性最小二乘拟合
 func FittingLSQ(XY goNum.Matrix) (goNum.Matrix, bool) {
 	/*
 		线性最小二乘拟合

FittingPolynomial.go

@@ -42,6 +42,7 @@ import (
 	"math"
 )
 
+// FittingPolynomial 多项式拟合
 func FittingPolynomial(xy Matrix, m int) (Matrix, float64, float64, bool) {
 	/*
 		多项式拟合

FittingPolynomial_test.go

@@ -45,6 +45,7 @@ import (
 	"github.com/chfenger/goNum"
 )
 
+// FittingPolynomial 多项式拟合
 func FittingPolynomial(xy goNum.Matrix, m int) (goNum.Matrix, float64, float64, bool) {
 	/*
 		多项式拟合

FittingTriPoly.go

@@ -40,6 +40,7 @@ import (
 	"math"
 )
 
+// FittingTriPoly 基于傅立叶（Fourier）级数的三角多项式拟合
 func FittingTriPoly(XY Matrix, M int) (Matrix, bool) {
 	/*
 		基于傅立叶（Fourier）级数的三角多项式拟合

FittingTriPoly_test.go

@@ -43,6 +43,7 @@ import (
 	"github.com/chfenger/goNum"
 )
 
+// FittingTriPoly 基于傅立叶（Fourier）级数的三角多项式拟合
 func FittingTriPoly(XY goNum.Matrix, M int) (goNum.Matrix, bool) {
 	/*
 		基于傅立叶（Fourier）级数的三角多项式拟合

InconsistentLSQ.go

@@ -32,6 +32,7 @@
 
 package goNum
 
+// InconsistentLSQ 求解矛盾方程组的最小二乘法（Least Square Method）
 func InconsistentLSQ(A, b Matrix) (Matrix, bool) {
 	/*
 		求解矛盾方程组的最小二乘法（Least Square Method）

InconsistentLSQ_test.go

@@ -38,6 +38,7 @@ import (
 	"github.com/chfenger/goNum"
 )
 
+// InconsistentLSQ 求解矛盾方程组的最小二乘法（Least Square Method）
 func InconsistentLSQ(A, b goNum.Matrix) (goNum.Matrix, bool) {
 	/*
 		求解矛盾方程组的最小二乘法（Least Square Method）

IntegralCompositeNewtonCotes.go

@@ -47,6 +47,7 @@
 
 package goNum
 
+// IntegralCompositeNewtonCotes 1-8级复化Newton-Cotes求积分公式
 func IntegralCompositeNewtonCotes(fun func(float64) float64, a, b float64, n, Nn int) (float64, bool) {
 	/*
 		1-8级复化Newton-Cotes求积分公式

IntegralCompositeNewtonCotesHalf.go

@@ -53,6 +53,7 @@ import (
 	"math"
 )
 
+// IntegralCompositeNewtonCotesHalf 1-8级逐次分半复化Newton-Cotes求积分公式
 func IntegralCompositeNewtonCotesHalf(fun func(float64) float64, a, b, tol float64, n, Nmax int) (float64, bool) {
 	/*
 		1-8级逐次分半复化Newton-Cotes求积分公式