# Builtin - 基础 / 类型转换

## 类型转换

### `floatN(r, n)`

使用银行家算法进行四舍五入,精确到10Adigit位。“四舍六入五考虑，五后非零就进一，五后皆零看奇偶，五前为偶应舍去，五前为奇要进一”

| 参数 | 类型    | 说明                     |
| ---- | ------- | ------------------------ |
| `r`  | real    | 实数                     |
| `n`  | integer | 整型数据，保留的小数位数 |

返回：real

#### 示例

```tsl
return floatN(12.6578, 2);
// 结果：12.66
```

### `dataType(data, n)`

根据Data的数据类型返回对应的值。当Data为数组时，N生效，支持对数组中的每个维度或每个单元格进行数据类型的判断。

| 参数   | 类型    | 说明           |
| ------ | ------- | -------------- |
| `data` | any     | 任意类型数据。 |
| `n`    | integer | 整数，可选参数 |

返回：integer|array

#### 示例

```tsl
// 当参数为数组型变量时，返回数组类型对应的整数5。
a := Array(34, 12); // 定义a为一个数组
result := dataType(a);
return result; // 5
// 当参数为整数型变量时，返回整数类型对应的整数0。
a := 23; // 定义a为一个整数
result := dataType(a);
return result; // 0
// 对数组第一维度数据进行类型判断
t := array(1, 3.14, "A", (1, 2, 3), nil);
return dataType(t, -1);
// 输出：
// 对数组中每一数据进行类型判断
t := array(1, 3.14, "A", (1, 2, 3), nil);
return dataType(t, 1);
// 输出：
// array(0,1,2,
// (0,0,0),10)
```

### `createBinary(len)`

创建一个Binary类型。

| 参数  | 类型    | 说明                     |
| ----- | ------- | ------------------------ |
| `len` | integer | 整数，二进制类型的长度。 |

返回：binary

### `ifNone(data, none_value)`

判别是否是None类型，以及判别值是否是指定NoneValue的None类型

| 参数         | 类型    | 说明                                                                                                               |
| ------------ | ------- | ------------------------------------------------------------------------------------------------------------------ |
| `data`       | any     | 任意类型                                                                                                           |
| `none_value` | integer | 整型，可选参数，指定None类型里包含的值，如对象set重载应用中，当包none类型包含值-1时，则表示set出错后重新进入的状态 |

返回：bool

### `createComObject(guid, obj)`

创建COM对象。如果创建成功则返回真，否则返回假。

| 参数   | 类型   | 说明             |
| ------ | ------ | ---------------- |
| `guid` | string | 对象的类GUID串。 |
| `obj`  | comobj | 保存创建的对象。 |

返回：bool

### `DataBaseRatioId_Jy()`

Jy常用的财务比率分析数据

返回：array

### `DataBaseRatioId_Wind()`

Wind常用的财务比率分析数据

返回：array

### `DataBaseRatioId_Tinysoft(id)`

Tinysoft常用的财务比率分析数据

| 参数 | 类型 | 说明     |
| ---- | ---- | -------- |
| `id` | any  | 整数类型 |

返回：array

### `DataBaseRatioId_tdhy()`

泰达荷银-常用的财务数据

返回：array

### `DataBaseRatioId_Jy2(id)`

Jy常用的财务比率分析数据

| 参数 | 类型 | 说明     |
| ---- | ---- | -------- |
| `id` | any  | 整数类型 |

返回：array

### `DataBaseRatioId_Ht(id)`

海通常用的财务比率分析数据

| 参数 | 类型 | 说明     |
| ---- | ---- | -------- |
| `id` | any  | 整数类型 |

返回：array

### `DataBaseRatioId_Genius(id)`

Genius常用的财务比率分析数据

| 参数 | 类型 | 说明     |
| ---- | ---- | -------- |
| `id` | any  | 整数类型 |

返回：array

### `DataBaseRatioId_Wind2()`

Wind常用的财务比率分析数据

返回：array

### `DataBaseRatioId_ghjj()`

国海基金-常用的财务数据

返回：array

### `DataBaseRatioId_nfjj()`

南方基金-常用的财务数据

返回：array

### `IF_1(c)`

条件语句if教学函数。传入参数C，如果C大于10则返回整数20，否则返回10。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `c`  | float | 实数 |

返回：any

### `IF_2(q)`

条件语句if教学函数。传入参数q，对q的值进行判断来返回相应的字符串。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `q`  | float | 实数 |

返回：string

### `IF_3(a)`

条件语句if教学函数。传入参数a，对a的值进行判断来返回相应的字符串。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `a`  | any  | 整数 |

返回：string

### `createComObj(guid, obj)`

创建COM对象。如果创建成功则返回真，否则返回假。

| 参数   | 类型   | 说明             |
| ------ | ------ | ---------------- |
| `guid` | string | 对象的类GUID串。 |
| `obj`  | object | 保存创建的对象。 |

返回：bool

### `dataisequal(v1, v2)`

判断2个变量是否相等

| 参数 | 类型 | 说明           |
| ---- | ---- | -------------- |
| `v1` | any  | 任意类型,变量1 |
| `v2` | any  | 任意类型,变量2 |

返回：bool

### `DataProcess_MF(arr, fwm)`

极值处理(多因子),对数据表以列为单位处理奇异值。其中arr为数据表，fwm为处理方法。

| 参数  | 类型   | 说明                 |
| ----- | ------ | -------------------- |
| `arr` | array  | 数据表类型           |
| `fwm` | string | 用户自定义，处理方法 |

返回：any

### `create(url, header, onmessage, u, p, s, reconn)`

构造方法

| 参数        | 类型      | 说明                                                            |
| ----------- | --------- | --------------------------------------------------------------- |
| `url`       | string    | TS-OPS服务注册地址                                              |
| `header`    | string    | TS-OPS服务注册时需要指定的头部信息，比如TS-OPS-CALL等           |
| `onmessage` | tfunction | 消息处理过程，指向一个函数。可通过Findfunction("函数名")产生    |
| `u`         | string    | 用户名                                                          |
| `p`         | string    | 用户密码                                                        |
| `s`         | string    | 租户Session Key；使用特殊租户（调用功能列表为\*）替代用户时指定 |
| `reconn`    | bool      | 是否启用断开自动重连机制                                        |

返回：any

### `ifInt(value, n)`

判断value是否是一个32位整数类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任何类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

#### 示例

范例一：

```tsl
// 判断是否为32位整数类型
r1 := ifInt(1);
r2 := ifInt(3.14);
r3 := ifInt("A");
r4 := ifInt(array(1, 2, 3));
return array(r1, r2, r3, r4);
// 结果：array(1,0,0,0)
```

范例二：

```tsl
// 对数组第一维度数据进行类型判断
t := array(1, 3.14, "A", (1, 2, 3), nil);
return ifInt(t, -1);
// 结果：array(1,0,0,0,0)
```

范例三：

```tsl
// 对数组中每一数据进行类型判断
t := array(1, 3.14, "A", (1, 2.1, 3), nil);
return ifInt(t, 1);
// 结果：array(1,0,0,(1,0,1),0)
```

### `ifInt64(value, n)`

判断value是否是一个64位整数类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任何类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

#### 示例

```tsl
// 当参数为整数类型变量时，返回true。
a := 23L; // 定义a为一个64位整数
return ifInt64(a);
// 当参数为非整数型变量时，返回false。
a := 2.3; // 定义a为一个非64位整数
return ifInt64(a);
// 对数组第一维度数据进行类型判断
t := array(1, 3L, "A", (1, 2, 3), nil);
return ifInt64(t, -1);
// 结果：array(0,1,0,0,0)
// 对数组中每一数据进行类型判断
t := array(1, 3L, "A", (1, 2L, 3), nil);
return ifInt64(t, 1);
// 结果：array(0,1,0,(0,1,0),0)
```

### `ifReal(value, n)`

判断value是否是一个实数类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任何类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

#### 示例

```tsl
// 当参数为实数类型变量时，返回true。
a := 2.233; // 定义a为一个实数
result := ifReal(a);
return result;
// 当参数为非整数型变量时，返回false。
a := array(23, 54, 67); // 定义a为一个非实数
result := ifReal (a);
return result;
// 对数组第一维度数据进行类型判断
t := array(1, 3.56, "A", (1, 2, 3), nil);
return ifInt64(t, -1);
// 结果：array(0,1,0,0,0)
// 对数组中每一数据进行类型判断
t := array(1, 3.56, "A", (1, 2.14, 3), nil);
return ifInt64(t, 1);
// 结果：array(0,1,0,(0,1,0),0)
```

### `ifNumber(value, n)`

判断value是否是一个数字类型(32位整数、64位整数或者实数)。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任何类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

#### 示例

```tsl
// 当参数为数字类型(整数或者实数)变量时，返回true。
a := 2.233; // 定义a为一个实数
result := ifNumber (a);
return result;
// 当参数为非数字类型(整数或者实数)变量时，返回false。
a := array(23, 54, 67); // 定义a为一个非数字类型
result := ifNumber (a);
return result;
// 对数组第一维度数据进行类型判断
t := array(1, 3.56, "A", (1, 2, 3), nil);
return ifNumber(t, -1);
// 结果：array(1,1,0,0,0)
// 对数组中每一数据进行类型判断,nan也为数字类型
t := array(1, 3.56, "A", (nan, 2.14, "C"), nil);
return ifNumber(t, 1);
// 结果：array(1,1,0,(1,1,0),0)
```

### `ifString(value, n)`

判断value是否是一个字符串类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任何类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

#### 示例

```tsl
// 当参数为字符串类型变量时，返回true。
a := 'test'; // 定义a为一个字符串
result := ifString (a);
return result;
// 当参数为非字符串类型变量时，返回false。
a := array(23, 54, 67); // 定义a为一个非字符串
result := ifString (a);
return result;
// 对数组第一维度数据进行类型判断
t := array(1, 3.56, "A", (1, 2, 3), nil);
return ifString(t, -1);
// 结果：array(0,0,1,0,0)
// 对数组中每一数据进行类型判断
t := array(1, 3.56, "A", (nan, 2.14, "C"), nil);
return ifString(t, 1);
// 结果：array(0,0,1,(0,0,1),0)
```

### `ifArray(value, n)`

判断value是否是一个数组类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任何类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

#### 示例

```tsl
// 当参数为数组类型变量时，返回true。
a := array(23, 54, 67); // 定义a为一个数组
result := ifArray (a);
return result;
// 当参数为非数组类型变量时，返回false。
a := 34; // 定义a为一个非数组
result := ifArray (a);
return result;
// 对数组第一维度数据进行类型判断
t := array(1, 3.56, "A", (1, "C", 3.14), nil);
return ifArray(t, -1);
// 结果：array(0,0,0,1,0)
// 对数组中每一数据进行类型判断
t := array(1, 3.56, "A", (nan, 2.14, "C"), nil);
return ifArray(t, 1);
// 结果：array(0,0,0,(0,0,0),0)
```

### `ifNil(value, n)`

判断value是否为空。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据。                   |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

#### 示例

```tsl
// 当参数为空时，返回true。
result := ifNil (nil); // 函数参数为空
return result;
// 当参数不为空时，返回false。
a := 34; // 函数参数不为空
result := ifNil (a);
return result;
// 对数组第一维度数据进行类型判断
t := array(1, 3.16, "A", (nil, "C", 3.14), nil);
return ifNil(t, -1);
// 结果：array(0,0,0,0,1)
// 对数组中每一数据进行类型判断
t := array(1, 3.56, "A", (nil, 2.14, "C"), nil);
return ifNil(t, 1);
// 结果：array(0,0,0,(1,0,0),1)
```

### `ifExp(value, n)`

判断value是否是一个表达式类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

#### 示例

```tsl
// 当参数是一个表达式类型时，返回true。
a := @'dfhdv'+'dbf'; // 函数参数a为一个表达式
result := ifExp (a);
return result;
// 当参数不是一个表达式类型时，返回false。
a := 'sdhv'+'dbf'; // 函数参数a不为表达式
result := ifExp (a);
return result;
// 对数组第一维度数据进行类型判断
t := array(1, 3.16, @"A", (nil, @"C", 3.14), nil);
return ifExp(t, -1);
// 结果：array(0,0,1,0,0)
// 对数组中每一数据进行类型判断
t := array(1, 3.56, @"A", (nil, 2.14, @"C"), nil);
return ifExp(t, 1);
// 结果：array(0,0,1,(0,0,1),0)
```

### `ifBinary(value, n)`

判断value是否是一个二进制类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

#### 示例

```tsl
// 当参数是一个二进制类型时，返回true。
a := binary('111111'); // 函数参数a为二进制类型
result := ifBinary (a);
return result;
// 当参数不是一个二进制类型时，返回false。
a := 'sdhv'; // 函数参数a不为二进制类型
result := ifBinary (a);
return result;
// 对数组第一维度数据进行类型判断
b := binary("3.14");
t := array(1, b, "A", (nil, b, 3.14), nil);
return ifBinary(t, -1);
// 结果：array(0,1,0,0,0)
// 对数组中每一数据进行类型判断
b := binary("3.14");
t := array(1, b, "A", (nil, 2.14, b), nil);
return ifBinary(t, 1);
// 结果：array(0,1,0,(0,0,1),0)
```

### `ifFmarray(value)`

判断是否为 FMArray 类型。

| 参数    | 类型 | 说明     |
| ------- | ---- | -------- |
| `value` | any  | 输入数据 |

返回：bool

### `ifCache(value)`

判断值是否仍是全局缓存引用。

| 参数    | 类型 | 说明       |
| ------- | ---- | ---------- |
| `value` | any  | 待判断的值 |

返回：bool

## 随机函数

### `ifGraph(value, n)`

判断value是否是一个图形类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

#### 示例

```tsl
// 当参数是一个图形类型时，返回true。
g_data := nDay2('MA5' , ma( close() , 5 ) );
g1 := graph( gtLine() , "MA5" , gdata , gfColor() , clBlue() );
result := ifGraph (g1);
return result;
// 当参数不是一个图形类型时，返回false。
a := 'sdhv'+'dbf'; // 函数参数a不为图形类型
result := ifGraph (a);
return result;
```

### `ifGraphgroup(value, n)`

判断value是否是一个图形组合类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

#### 示例

```tsl
// 当参数是一个图形组合类型时，返回true。
vol_data := nDay2(gfVol() , vol() , gfColor() , ifThen ( close() > open() , clRed() , clGreen() ) );
mavol := nDay2('MA5', ma ( vol() , 5 ) );
vol_graph := graph(gtBar(), 'VOLGraph', vol_data);
mavol_graph := graph(gtLine(), 'MA5Graph', mavol, gfColor(), clBlue());
g1 := graphGroup(vol_graph, mavol_graph, gfMinValue(), 0);
// 调用函GraphGroup创建一个图形组合类型变量g1
result := ifGraphGroup (g1);
return result;
g_data := nDay2('MA5' , ma( close() , 5 ) );
g1 := graph( gtLine() , "MA5" , gdata , gfColor() , clBlue() );
result := ifGraphGroup (g1);
return result;
// 返回0
```

### `ifMatrix(value, n)`

判断value是否是一个Matrix类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

#### 示例

```tsl
// 当参数是一个Matrix类型时，返回true。
a := createMatrix(3, 4); // 使用CreateMatrix创建一个Matrix类型变量
result := ifMatrix (a);
return result;
// 当参数不是一个Matrix类型时，返回false。
a := 'sdhv'; // 函数参数a不为Matrix类型
result := ifMatrix (a);
return result;
```

### `ifObj(value, n)`

判断value是否是一个ComObj对象或者一个TSL的对象类型。可通过可选参数N对数组中的行或元素进行判断。

| 参数    | 类型    | 说明                             |
| ------- | ------- | -------------------------------- |
| `value` | any     | 任意类型数据                     |
| `n`     | integer | 可选参数，整数。具体参考返回说明 |

返回：bool

#### 示例

```tsl
// 当参数是一个对象类型时，返回true。
type function14=class() // 声明类
function SetName(new_name);
begin
name := new_name;
end;
end;
obj := CreateObject('Function14'); // 使用CreateObject函数创建上面类Function14的对象
result := ifObj (obj);
return result;
// 当参数不是一个对象类型时，返回false。
a := 'sdhv'; // 函数参数a不为对象类型
result := ifObj (a);
return result;
```

### `getOleObject(class_name, method, obj)`

获取一个ComObj对象类型。

| 参数         | 类型    | 说明                                                                                                          |
| ------------ | ------- | ------------------------------------------------------------------------------------------------------------- |
| `class_name` | string  | 字符串，对象的类名。                                                                                          |
| `method`     | integer | 整数，产生方法的方法，1:获取一个存在的对象，2:新建一个对象，其他值:如果存在则获取一个存在对象，不存在则创建。 |
| `obj`        | comobj  | 保存返回的对象。                                                                                              |

返回：bool
