# 数学函数 / 优化

## `nonLP_fmincon(fun, x_0, a, b, aeq, beq, nonlcon)`

声明：function

使用起作用集法求解带线性约束和非线性约束的优化问题

<!-- tags: 数学 优化 非线性规划 约束优化 nonlinear constrained optimization -->

| 参数      | 类型   | 说明                               |
| --------- | ------ | ---------------------------------- |
| `fun`     | string | 目标函数名称                       |
| `x_0`     | array  | 初始点                             |
| `a`       | array  | 线性不等式约束矩阵                 |
| `b`       | array  | 线性不等式约束向量                 |
| `aeq`     | array  | 线性等式约束矩阵                   |
| `beq`     | array  | 线性等式约束向量                   |
| `nonlcon` | string | 非线性约束函数名称，空字符串表示无 |

返回：array

### 示例

范例01：调用无显式约束的目标函数

```tsl
empty_matrix := array();
return nonLP_fmincon(
    "sum", array(1.0), empty_matrix, empty_matrix,
    empty_matrix, empty_matrix, "");
```

## `Fmin(fun, x0, a, b, aeq, beq, lb, ub, nonlcon)`

声明：function

用起作用集法求任意形式的非线性优化问题，返回最优点和最优值。新的非线性规划代码建议使用 `Prog_N`。

来源：天软金融分析.NET函数大全 > TSL函数 > 数学函数 > 优化 > Fmin

Source ID：21143

| 参数      | 类型   | 说明                                 |
| --------- | ------ | ------------------------------------ |
| `fun`     | string | 目标函数名                           |
| `x0`      | array  | 初值向量                             |
| `a`       | array  | 线性不等式约束系数矩阵               |
| `b`       | array  | 线性不等式约束右侧向量               |
| `aeq`     | array  | 线性等式约束系数矩阵                 |
| `beq`     | array  | 线性等式约束右侧向量                 |
| `lb`      | array  | 变量下界                             |
| `ub`      | array  | 变量上界                             |
| `nonlcon` | string | 非线性约束回调名；无约束时传空字符串 |

返回：array

### 示例

```tsl
return Fmin(
    "sum",
    array(0.0),
    array(),
    array(),
    array(),
    array(),
    array(-1.0),
    array(1.0),
    ""
);
// 输出：返回包含最优点和最优值的数组
```

## `H_J_CallBack(x, r)`

声明：function

H_J算法回调

<!-- tags: H_J -->

| 参数 | 类型  | 说明             |
| ---- | ----- | ---------------- |
| `x`  | array | 一维数字数组类型 |
| `r`  | float | 实数类型         |

返回：float

## `H_J_Method_Pgm(call_back)`

声明：function

H_J算法测试

<!-- tags: H_J -->

| 参数        | 类型   | 说明                         |
| ----------- | ------ | ---------------------------- |
| `call_back` | string | 字符串类型，计算目标值的回调 |

返回：array

## `Hooke_Jeeves_Method(x0, d0, d_min, r, call_back)`

声明：function

H-J法求解无约束最优化问题

| 参数        | 类型   | 说明                         |
| ----------- | ------ | ---------------------------- |
| `x0`        | array  | 一维数字数组类型             |
| `d0`        | array  | 一维数字数组类型             |
| `d_min`     | array  | 一维数字数组类型             |
| `r`         | float  | 实数类型                     |
| `call_back` | string | 字符串类型，计算目标值的回调 |

返回：array

### 示例

```tsl
return Hooke_Jeeves_Method(
    array(2.0),
    array(1.0),
    array(0.01),
    0.5,
    "H_J_CallBack"
);
// 输出：返回包含 1 个元素的最优解数组
```

## `intLinProg(f, a, b, aeq, beq, int_par)`

声明：function

（线性规划，包括整数规划，01规划建议统一使用prog_L函数）解决如下整数规划模型问题

| 参数      | 类型          | 说明                                                                                         |
| --------- | ------------- | -------------------------------------------------------------------------------------------- |
| `f`       | array of real | 一维实数数组，表示整数规划模型的目标函数系数；                                               |
| `a`       | array of real | 二维实数数组，表示整数规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b`       | array of real | 一维实数数组，表示整数规划模型带“”约束方程的约束值；                                         |
| `aeq`     | array of real | 二维实数数组，表示整数规划模型带“=”约束方程系数矩阵；                                        |
| `beq`     | array of real | 一维实数数组，表示整数规划模型带“=”约束方程的约束值；                                        |
| `int_par` | array of real | 一维整数数组，表示要取整数的变量，缺省时表示全部变量取整；                                   |

返回：array

### 示例

求解模型：最大化 `40x1 + 90x2`，约束为 `9x1 + 7x2 <= 56`、`7x1 + 20x2 <= 70`，且 `x1`、`x2` 为非负整数。

范例01：整数线性规划

```tsl
f := array(-40, -90);
a := array((9, 7), (7, 20));
b := array(56, 70);
aeq := array();
beq := array();
int_par := array();
return intLinProg(f, a, b, aeq, beq, int_par);
// 输出：x1=4,x2=2,f(x)=-340
```

## `linearProgramming(f, a, b, aeq, beq)`

声明：function

（线性规划，包括整数规划，01规划建议统一使用prog_L函数）,解决如下线性规划模型问题

| 参数  | 类型          | 说明                                                                                         |
| ----- | ------------- | -------------------------------------------------------------------------------------------- |
| `f`   | array of real | 一维实数数组，表示线性规划模型的目标函数系数；                                               |
| `a`   | array of real | 二维实数数组，表示线性规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b`   | array of real | 一维实数数组，表示线性规划模型带“”约束方程的约束值；                                         |
| `aeq` | array of real | 二维实数数组，表示线性规划模型带“=”约束方程系数矩阵；                                        |
| `beq` | array of real | 一维实数数组，表示线性规划模型带“=”约束方程的约束值；                                        |

返回：any

### 示例

求解模型：最小化 `-5x1 - 4x2 - 6x3`，约束为 `x1 - x2 + x3 <= 20`、`3x1 + 2x2 + 4x3 <= 42`、`3x1 + 2x2 <= 30`，且各变量非负。

范例01：线性规划

```tsl
f := array(-5, -4, -6);
a := array((1, -1, 1), (3, 2, 4), (3, 2, 0));
b := array(20, 42, 30);
aeq := array();
beq := array();
return linearProgramming(f, a, b, aeq, beq);
// 输出：x1=0,x2=15,x3=3,f(x)=-78
```

## `NonLP_BSearch(fun, x0, h)`

声明：function

一维盲人搜索方法，目标函数既可以是单峰，也可以是多峰。返回最优点和最优值。（中间函数）

<!-- tags: 查找 搜索 lookup -->

| 参数  | 类型   | 说明                         |
| ----- | ------ | ---------------------------- |
| `fun` | string | 目标函数表达式，为字符串类型 |
| `x0`  | float  | 初值，为实数类型；           |
| `h`   | float  | 步长，为实数类型；           |

返回：array

## `NonLP_Fibonacci(fun, a, b)`

声明：function

（一维最小值搜索建议统一使用NonLP_Fminbnd函数），斐波那契法，用斐波那契数列去搜索\[a,b\]区间内目标函数的最小值，返回最优点和最优值

<!-- tags: 查找 搜索 lookup -->

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `a`   | float  | 区间左侧，为实数类型；         |
| `b`   | float  | 区间右侧，为实数类型           |

返回：array

## `NonLP_Fminbnd(fun, a, b, methods)`

声明：function

一维最小值搜索，求解模型如下： min fun(x)

<!-- tags: 查找 搜索 lookup -->

| 参数      | 类型   | 说明                                                                           |
| --------- | ------ | ------------------------------------------------------------------------------ |
| `fun`     | string | 目标函数(函数名字符串)                                                         |
| `a`       | float  | 下界，实数                                                                     |
| `b`       | float  | 上界，实数                                                                     |
| `methods` | any    | 方法选择0 :黄金分割法+抛物线法（默认）1 : 盲人收索法2 :黄金分割法3 :斐波那契法 |

返回：array

### 示例

```tsl
return NonLP_Fminbnd("abs", -2.0, 3.0, 0);
// 输出：返回包含 X、opt 和 Iter 的结果数组
```

## `NonLP_Fminsearch(fun, x0, methods)`

声明：function

无约束最小值求解,求解模型如下： min fun(x)

<!-- tags: 查找 搜索 lookup -->

| 参数      | 类型   | 说明                                                                       |
| --------- | ------ | -------------------------------------------------------------------------- |
| `fun`     | string | 目标函数，函数名字符串                                                     |
| `x0`      | array  | 初始值，一维数字数组                                                       |
| `methods` | any    | 方法选择0 单纯形法1 转轴法2 模式搜索法3 拟牛顿下山法（默认方法，推荐使用） |

返回：array

## `NonLP_Golden(fun, a, b)`

声明：function

（一维最小值搜索建议统一使用NonLP_Fminbnd函数），黄金分割法搜索\[a,b\]区间内目标函数的最小值，返回最优点和最优值

<!-- tags: 查找 搜索 lookup -->

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `a`   | float  | 区间左侧，为实数类型；         |
| `b`   | float  | 区间右侧，为实数类型           |

返回：array

## `NonLP_GP(fun, a, b)`

声明：function

（一维最小值搜索建议统一使用NonLP_Fminbnd函数），黄金分割+抛物线插值法：一维优化方法，返回最优点和最优值

<!-- tags: 查找 搜索 lookup -->

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `a`   | float  | 区间左侧，为实数类型；         |
| `b`   | float  | 区间右侧，为实数类型；         |

返回：array

## `NonLP_Hooke_Jeeves(fun, x0)`

声明：function

（无约束最小值求解建议统一使用NonLP_Fminsearch函数）模式搜索法，又叫Hooke-Jeeves法，求解无约束多维极值问题，返回最优点和最优值

<!-- tags: 查找 搜索 lookup -->

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0`  | array  | 初值向量，为一维数组类型       |

返回：array

## `NonLP_minFactor(fun, x0, aeq, beq, nonlcon)`

声明：function

（非线性规划建议统一使用prog_n函数）,乘子法求等式约束问题，可求解如下问题

| 参数      | 类型   | 说明                                 |
| --------- | ------ | ------------------------------------ |
| `fun`     | string | 目标函数表达式，为字符串类型；       |
| `x0`      | array  | 初值向量，为一维数组类型；           |
| `aeq`     | array  | 线性矩阵等式约束，为二维数组类型；   |
| `beq`     | array  | 线性向量等式约束值，为一维数组类型； |
| `nonlcon` | string | 非线性约束回调，为字符串类型；       |

返回：array

## `NonLP_minPS(fun, x0, a, b, nonlcon)`

声明：function

（非线性规划建议统一使用prog_n函数）,坐标轮换法求不等式约束问题，初值必须在可行域内！可求解如下问题

| 参数      | 类型   | 说明                                   |
| --------- | ------ | -------------------------------------- |
| `fun`     | string | 目标函数表达式，为字符串类型；         |
| `x0`      | array  | 初值向量，为一维数组类型；             |
| `a`       | array  | 线性矩阵不等式约束，为二维数组类型；   |
| `b`       | array  | 线性向量不等式约束值，为一维数组类型； |
| `nonlcon` | string | 非线性约束回调，为字符串类型；         |

返回：array

## `NonLP_minSUMT(fun, x0, a, b, aeq, beq, nonlcon, methods)`

声明：function

（非线性规划建议统一使用prog_n函数）混合惩罚函数+转轴法/模式搜索法：可解所有优化问题，返回最优点、最优值和迭代次数。可求解如下问题

<!-- tags: 查找 搜索 lookup -->

| 参数      | 类型   | 说明                                   |
| --------- | ------ | -------------------------------------- |
| `fun`     | string | 目标函数表达式，为字符串类型；         |
| `x0`      | array  | 初值向量，为一维数组类型；             |
| `a`       | array  | 线性矩阵不等式约束，为二维数组类型；   |
| `b`       | array  | 线性向量不等式约束值，为一维数组类型； |
| `aeq`     | array  | 线性矩阵等式约束，为二维数组类型；     |
| `beq`     | array  | 线性向量等式约束值，为一维数组类型；   |
| `nonlcon` | string | 非线性约束回调，为字符串类型；         |
| `methods` | string | 方法选择,’NM’,’Rb’,’HJ’                |

返回：array

## `NonLP_Nelder(fun, x0)`

声明：function

（无约束最小值求解建议统一使用NonLP_Fminsearch函数）内德-米德法，无约束多维的非线性规划方法，即单纯形法。返回最优点和最优值

<!-- tags: 查找 搜索 lookup -->

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0`  | array  | 初值向量，为一维数组类型       |

返回：array

## `NonLP_Range(fun, x0, h)`

声明：function

进退法，可一维优化问题的确定搜索区间，但目标函数必须是单峰函数，返回结果为上下界的取值。（中间函数）

<!-- tags: 查找 搜索 lookup -->

| 参数  | 类型   | 说明                         |
| ----- | ------ | ---------------------------- |
| `fun` | string | 目标函数表达式，为字符串类型 |
| `x0`  | float  | 初值，为实数类型；           |
| `h`   | float  | 步长，为实数类型；           |

返回：array

## `NonLP_Rosenbrock(fun, x0)`

声明：function

（无约束最小值求解建议统一使用NonLP_Fminsearch函数）Rosenbrock求无约束多维极值问题，返回最优点和最优值

<!-- tags: 查找 搜索 lookup -->

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0`  | array  | 初值向量，为一维数组类型       |

返回：array

## `ozProg(f, a, b)`

声明：function

（线性规划，包括整数规划，01规划建议统一使用prog_L函数）,0-1规划，解决如下0-1整数规划模型问题 返回该0-1规划模型的最小值及其对应变量的取值,其中可以转化为和

| 参数 | 类型  | 说明                                                                                        |
| ---- | ----- | ------------------------------------------------------------------------------------------- |
| `f`  | array | 一维实数数组，表示0-1规划模型的目标函数系数；                                               |
| `a`  | array | 二维实数数组，表示0-1规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b`  | array | 一维实数数组，表示0-1规划模型带“”约束方程的约束值；                                         |

返回：array

### 示例

```tsl
f := array(-3, 2, -5);
a := array((1, 2, -1), (1, 4, 1), (1, 1, 0), (4, 0, 1));
b := array(2, 4, 3, 6);
ozProg(f, a, b);
// 输出：x1=1,x2=0,x3=1,f(x)=-8
```

## `Prog_L(f, a, b, aeq, beq, lb, ub, x0, options, ozarr, intarr)`

声明：function

使用单纯形法，和起作用集法，系统默认作用集形法求解线性规划问题，即求解目标都为线性和约束条件都为线性的规划问题 Prog_L(f,A,b) 求解不等式约束 Prog_L(f,A,b,Aeq,beq) 求解不等式约束、等式约束 Prog_L(f,A,b,Aeq,beq,LB,UB) 求解不等式约束、等式约束、上下界限约束 Prog_L(f,A,b,Aeq,beq,LB,UB,x0,options) 求解不等式约束、等式约束，上下限约束，加入用户算法设置 Prog_L(f,A,b,Aeq,beq,LB,UB,x0,options,ozarr) 求解不等式约束、等式约束、上下限约束、0-1 约束 Prog_L(f,A,b,Aeq,beq,LB,UB,x0,options,ozarr,intarr) 求解不等式约束、等式约束、上下限约束、0-1 约束、整数约束 模型表达： min= sum(f\*x) st. A:\*x<=b Aeq :\* x = Beq lb<x<ub x = (0 or 1) x = integer

<!-- tags: LB UB -->

| 参数      | 类型  | 说明                                                                                                                                                                                                                                                                              |
| --------- | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `f`       | array | 线性目标，一维数字数组，不可缺省                                                                                                                                                                                                                                                  |
| `a`       | array | 线性约束，二维数字数组，不可缺省                                                                                                                                                                                                                                                  |
| `b`       | array | 线性约束，一维数字数组，不可缺省                                                                                                                                                                                                                                                  |
| `aeq`     | array | 线性约束，二维数字数组，缺省为空                                                                                                                                                                                                                                                  |
| `beq`     | array | 线性约束，一维数字数组，缺省为空                                                                                                                                                                                                                                                  |
| `lb`      | array | 下界约束，一维数字数组，缺省为空                                                                                                                                                                                                                                                  |
| `ub`      | array | 上界约束，一维数字数组，缺省为空                                                                                                                                                                                                                                                  |
| `x0`      | array | 初始值，一维数组                                                                                                                                                                                                                                                                  |
| `options` | array | 选项设置，数据表类型，缺省为:；array( 'algorithm' :'activeset'，//'simplex' 单纯形，'activeset' 作用集法；//(当整数、0-1 约束时推荐使用)；'maxiter': 400 , //最大迭代次数；'tolcon': 1.0e-10, //约束容忍误差；'tolfun' : 1.0e-8 , //目标最小误差；'tolx' : 1.0e-8 //变量最小变化) |
| `ozarr`   | array | 01约束条件，第1个变量为01变量则ozarr := array(0)                                                                                                                                                                                                                                  |
| `intarr`  | array | 整数约束条件，第2,3两个变量为整数变量则 intarr:=array(1,2)；返回结果:；数据表类型；ret\["X"\] : 变量取值，一维数字数组；ret\["Fval"\] :规划目标值，实数；ret\["Error_M"\] : 结果信息，整数；ret\["Iter"\] : 迭代次数,整数                                                         |

返回：array

## `Prog_M(fun, x0, goal, weight, a, b, aeq, beq, lb, ub, nlc, options)`

声明：function

求解多目标规划问题 模型表达： min AttainFactor st. f(x)-AttainFactor\*wight <=goal //目标约束 c(x)<=0; //非线性不等式约束 ceq(x)=0; //非线性等式约束 A\*x<=b; //线性不等式约束 aeq\*x=beq; //线性等式约束 lb<=x<=ub ; //边界约束

| 参数      | 类型   | 说明                                                                                                                                                                                                                                                                                     |
| --------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `fun`     | array  | 目标函数，函数名字符串                                                                                                                                                                                                                                                                   |
| `x0`      | array  | 初始值                                                                                                                                                                                                                                                                                   |
| `goal`    | array  | 目标中各个分目标的差，一维数组和目标个数相同                                                                                                                                                                                                                                             |
| `weight`  | array  | 目标中各个分量的在总体中的比重，一维数组和目标个数相同                                                                                                                                                                                                                                   |
| `a`       | array  | 不等式约束，二维数组                                                                                                                                                                                                                                                                     |
| `b`       | array  | 不等式约束，一维数组                                                                                                                                                                                                                                                                     |
| `aeq`     | array  | 等式约束，二维数组                                                                                                                                                                                                                                                                       |
| `beq`     | array  | 等式约束，一维数组                                                                                                                                                                                                                                                                       |
| `lb`      | array  | 下界，一维数组                                                                                                                                                                                                                                                                           |
| `ub`      | array  | 上界，一维数组                                                                                                                                                                                                                                                                           |
| `nlc`     | string | 非线性约束，约束函数名字符串                                                                                                                                                                                                                                                             |
| `options` | array  | 算法参数设置，默认为:array('maxiter':400, //最大迭代次数'maxfunevals':'100\*numberofvariables', //目标回调最大次数'tolcon':1.0e-6,//约束容忍误差'tolfun' :1.0e-6,//目标最小误差'tolx' :1.0e-6, //变量最小变化'diffmaxchange':1e-1,//差分时最大步长'diffminchange':1e-8)// 差分时最小步长 |

返回：array

## `Prog_N(fun, x0, a, b, aeq, beq, lb, ub, nlc, options)`

声明：function

采用拟牛顿下山方法求解非线性规划求解。 Prog_n(fun,x0) 无约束最小值约束 Prog_n(fun,x0,A,B) 非线性不等式约束求解 Prog_n(fun,A,b,Aeq,beq) 求解不等式约束、等式约束 Prog_n(fun,x0,A,b,Aeq,beq,LB,UB) 求解不等式约束、等式约束、上下界限约束 Prog_n(fun,x0,A,b,Aeq,beq,LB,UB,x0,options) 模型表达 1非线性无约束最小值 min fun(x) 2非线性规划求解 min fun(x) st. c(x)<=0; //非线性不等式约束 ceq(x)=0; //非线性等式约束 A\*x<=b; //线性不等式约束 aeq\*x=beq; //线性等式约束 lb<=x<=ub ; //边界约束

<!-- tags: LB UB -->

| 参数      | 类型  | 说明                                                                                                                                                                                                                                                                                         |
| --------- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `fun`     | array | 目标函数，目标函数名字符串类型，不可缺省。其中，目标函数的返回值必须是一个实数（1x1的矩阵，或长度为1的数组都不允许）                                                                                                                                                                         |
| `x0`      | array | 初始值，一维数字数组，不可缺省                                                                                                                                                                                                                                                               |
| `a`       | array | 不等式约束，二维数组，缺省为空                                                                                                                                                                                                                                                               |
| `b`       | array | 不等式约束，一维数组，缺省为空                                                                                                                                                                                                                                                               |
| `aeq`     | array | 等式约束，二维数组，缺省为空                                                                                                                                                                                                                                                                 |
| `beq`     | array | 等式约束，一维数组，缺省为空                                                                                                                                                                                                                                                                 |
| `lb`      | array | 下界，一维数组，缺省为空                                                                                                                                                                                                                                                                     |
| `ub`      | array | 上界，一维数组，缺省为空                                                                                                                                                                                                                                                                     |
| `nlc`     | array | 非线性约束，函数名，字符串                                                                                                                                                                                                                                                                   |
| `options` | array | 算法参数设置，默认为array('maxiter':400 , //最大迭代次数'maxfunevals':'100\*numberofvariables', //目标回调最大次数'tolcon':1.0e-6 ,//约束容忍误差'tolfun' :1.0e-6 ,//目标最小误差'tolx' :1.0e-6 , //变量最小变化'diffmaxchange':1e-1,//差分时最大步长'diffminchange':1e-8 )// 差分时最小步长 |

返回：array

## `Prog_Q(h, f, a, b, aeq, beq, lb, ub, x0, options)`

声明：function

二次规划问题求解(采用作用集方法) Prog_Q(H,f,A,b) 求解不等式约束 Prog_Q(H,f,A,b,Aeq,beq) 求解不等式约束、等式约束 Prog_Q(H,f,A,b,Aeq,beq,LB,UB) 求解不等式约束、等式约束、上下界限约束 Prog_Q(H,f,A,b,Aeq,beq,LB,UB,x0,options) 模型表达： min= `x\* H\* x /2 + sum(f\*x) st. A:\*x<=b Aeq :\* x = Beq; lb<x<ub

<!-- tags: LB UB -->

| 参数      | 类型  | 说明                                                                                                                                                              |
| --------- | ----- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `h`       | array | 二次型，正定二次型二维数字数组，不可缺省                                                                                                                          |
| `f`       | array | 线性目标，一维数字数组，不可缺省                                                                                                                                  |
| `a`       | array | 线性约束，二维数字数组，不可缺省                                                                                                                                  |
| `b`       | array | 线性约束，一维数字数组，不可缺省                                                                                                                                  |
| `aeq`     | array | 线性约束，二维数字数组，缺省为空                                                                                                                                  |
| `beq`     | array | 线性约束，一维数字数组，缺省为空                                                                                                                                  |
| `lb`      | array | 下界约束，一维数字数组，缺省为空                                                                                                                                  |
| `ub`      | array | 上界约束，一维数字数组，缺省为空                                                                                                                                  |
| `x0`      | array | 初始值，一维数组                                                                                                                                                  |
| `options` | array | 选项设置,数据表类型，缺省为array('maxiter': 400 , //最大迭代次数'tolcon': 1.0e-6, //约束容忍误差'tolfun' : 1.0e-6 , //目标最小误差'tolx' : 1.0e-6 //变量最小变化) |

返回：array

## `quadLagR(h, f, aeq, beq)`

声明：function

(二次规划建议统一使用prog_Q函数)解决如下二次规划模型问题

| 参数  | 类型             | 说明                                                  |
| ----- | ---------------- | ----------------------------------------------------- |
| `h`   | array,tablearray | 二维实数数组，表示二次项目标函数系数，为对称矩阵      |
| `f`   | array,tablearray | 一维实数数组，表示二次规划模型的目标函数系数；        |
| `aeq` | array,tablearray | 二维实数数组，表示二次规划模型带“=”约束方程系数矩阵； |
| `beq` | array,tablearray | 一维实数数组，表示二次规划模型带“=”约束方程的约束值。 |

返回：any

### 示例

求解模型：最小化 `2x1^2 + x2^2 + x1*x2 - x1 - x2`，约束为 `x1 + x2 = 1`。

范例01：带等式约束的二次规划

```tsl
h := Array((4, 1), (1, 2));
f := Array(-1, -1);
aeq := array((1, 1));
beq := array(1);
return quadLagR(h, f, aeq, beq);
// 输出：x1=0.25, x2=0.75, 最小值f(x)=-0.125
```

## `quadprog(h, f, a, b, aeq, beq)`

声明：function

（二次规划建议统一使用prog_Q函数）,解决如下二次规划模型问题

| 参数  | 类型          | 说明                                                                                         |
| ----- | ------------- | -------------------------------------------------------------------------------------------- |
| `h`   | array of real | 二维实数数组，表示二次项目标函数系数，为对称矩阵                                             |
| `f`   | array of real | 一维实数数组，表示二次规划模型的目标函数系数；                                               |
| `a`   | array of real | 二维实数数组，表示二次规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b`   | array of real | 一维实数数组，表示二次规划模型带“”约束方程的约束值；                                         |
| `aeq` | array of real | 二维实数数组，表示二次规划模型带“=”约束方程系数矩阵；                                        |
| `beq` | array of real | 一维实数数组，表示二次规划模型带“=”约束方程的约束值；                                        |

返回：array

### 示例

求解模型：最小化 `1/2*x1^2 + x2^2 - x1*x2 - 2x1 - 6x2`，并满足文中所列不等式及非负约束。

范例01：带不等式约束的二次规划

```tsl
h := Array((1, -1), (-1, 2));
f := Array(-2, -6);
a := Array((1, 1), (-1, 2), (2, 1));
b := array(2, 2, 3);
aeq := array();
beq := array();
return quadprog(h, f, a, b, aeq, beq);
// 输出：x1=0.6667,x2=1.3333,f(x)=-8.2222
```

## `quadTrackRoute(h, f, a, b, aeq, beq, x0)`

声明：function

（二次规划建议统一使用prog_Q函数）解决如下二次规划模型问题

| 参数  | 类型          | 说明                                                                                         |
| ----- | ------------- | -------------------------------------------------------------------------------------------- |
| `h`   | array of real | 二维实数数组，表示二次项目标函数系数，为对称矩阵                                             |
| `f`   |               | 一维实数数组，表示二次规划模型的目标函数系数；                                               |
| `a`   | array of real | 二维实数数组，表示二次规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b`   | array of real | 一维实数数组，表示二次规划模型带“”约束方程的约束值；                                         |
| `aeq` | array of real | 二维实数数组，表示二次规划模型带“=”约束方程系数矩阵；                                        |
| `beq` | array of real | 一维实数数组，表示二次规划模型带“=”约束方程的约束值；                                        |
| `x0`  | array of real | 变量的初始点。                                                                               |

返回：array

### 示例

求解模型：最小化 `2x1^2 + 2x2^2 - x1*x2 + 8x1 - 6x2`，约束为 `x1 + x2 <= 2`、`2x1 - x2 <= 1`。

范例01：指定初始点的二次规划

```tsl
h := Array((4, -1), (-1, 4));
f := Array(8, -6);
a := Array((1, 1), (2, -1));
b := array(2, 1);
aeq := array();
beq := array();
x0 := array(0, 0);
return quadTrackRoute(h, f, a, b, aeq, beq, x0);
// 输出：x1=-1.733333, x2=1.066667, 最小值f(x)=-10.13333
```

## `SUMT_Method(x0, call_back)`

声明：function

SUMT法求解有约束最优化问题

<!-- tags: SUMT -->

| 参数        | 类型   | 说明                               |
| ----------- | ------ | ---------------------------------- |
| `x0`        | array  | 一维数字数组类型，各个变量的初始值 |
| `call_back` | string | 字符串类型，计算目标值的回调       |

返回：array

### 示例

```tsl
return SUMT_Method(array(1.0), "Sumt_Method_CallBack");
// 输出：返回包含 1 个元素的最优解数组
```

## `Sumt_Method__Pgm()`

声明：function

Sumt算法测试

返回：array

## `Sumt_Method_CallBack(x, r)`

声明：function

Sumt算法回调

| 参数 | 类型  | 说明             |
| ---- | ----- | ---------------- |
| `x`  | array | 一维数字数组类型 |
| `r`  | float | 实数类型         |

返回：float

## `tsOptimizer`

声明：class

天软规划求解基类，以面向对象方式封装 `Prog_N`、`Prog_Q` 和 `Prog_L`

<!-- tags: 数学优化 约束求解 最优解 -->

来源：depth=3

Source ID：21162

Source URL：<http://www.tinysoft.com/tsdn/helpdoc/display.tsl?id=21162>

### `Ff`

声明：field

线性目标

可见性：`public`

类型：array

### `Fh`

声明：field

二次型

可见性：`public`

类型：array

### `Fa`

声明：field

线性约束系数矩阵

可见性：`public`

类型：array

### `Fb`

声明：field

线性约束右侧向量

可见性：`public`

类型：array

### `FAeq`

声明：field

线性等式约束系数矩阵

可见性：`public`

类型：array

### `FBeq`

声明：field

线性等式约束右侧向量

可见性：`public`

类型：array

### `FLb`

声明：field

变量下界约束

可见性：`public`

类型：array

### `FUb`

声明：field

变量上界约束

可见性：`public`

类型：array

### `FOzarr`

声明：field

0-1 约束条件

可见性：`public`

类型：array

### `FIntarr`

声明：field

整数约束条件

可见性：`public`

类型：array

### `Fx0`

声明：field

优化初始值

可见性：`public`

类型：array

### `Foptions`

声明：field

算法选项设置

可见性：`public`

类型：array

### `Fresult`

声明：field

优化后的结果

可见性：`public`

类型：array

### `Obj(x)`

声明：function

计算优化目标

<!-- tags: 数学优化 约束求解 -->

可见性：`public`

| 参数 | 类型 | 说明                                 |
| ---- | ---- | ------------------------------------ |
| `x`  | real | 当前优化变量向量，用于计算目标函数值 |

返回：float

### `Con(x)`

声明：function

增加非线性约束

<!-- tags: 定义 非线性约束 优化约束 -->

可见性：`public`

| 参数 | 类型  | 说明                                   |
| ---- | ----- | -------------------------------------- |
| `x`  | array | 当前优化变量向量，用于计算非线性约束值 |

返回：array

### `Prog()`

声明：function

执行优化并返回 `Fresult`

<!-- tags: 调用 数学优化 约束求解 -->

可见性：`public`

返回：array

### `Prog_Debug()`

声明：function

查询优化结果并进行约束校验

<!-- tags: 数学优化 约束求解 约束条件 限制条件 -->

可见性：`public`

返回：array

### `Prog_Debugprint(space)`

声明：function

打印当前优化结果质量

<!-- tags: 输出 数学优化 约束求解 -->

可见性：`public`

| 参数    | 类型 | 说明                                              |
| ------- | ---- | ------------------------------------------------- |
| `space` | int  | 可选。默认 0。优化结果打印时使用的缩进/格式控制值 |

返回：nil

### `Prog_ConsTest_Linear()`

声明：function

检测当前线性约束是否可行

<!-- tags: 检查 线性约束 可行性 -->

可见性：`public`

返回：array
