# 金融 / 行情 / 区间

## `dateOfStockHigh(beg_t, end_t)`

声明：function

创阶段新高日期，与系统参数(证券代码)相关

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `beg_t` | t_date_time | 日期。开始日期 |
| `end_t` | t_date_time | 日期。截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
setSysParam(pn_stock(), 'SZ000002');
return dateOfStockHigh(20230101T, 20231231T);
// 输出：44932(2023-01-06)
```

## `dateOfStockLow(beg_t, end_t)`

声明：function

创阶段新低日期，与系统参数(证券代码)相关

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `beg_t` | t_date_time | 日期。开始日期 |
| `end_t` | t_date_time | 日期。截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
setSysParam(pn_stock(), 'SZ000002');
return dateOfStockLow(20230101T, 20231231T);
// 输出：45287(2023-12-27)
```

## `indexCapitalFlow(index_id, begt, endt)`

声明：function

指数资金流向。（单位：元）

| 参数       | 类型   | 说明             |
| ---------- | ------ | ---------------- |
| `index_id` | string | 字符串，指数代码 |
| `begt`     | tdate  | 日期，开始日     |
| `endt`     | t_date | 日期，截止日     |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回沪深300在2021年11月12日的资金流向情况
return indexCapitalFlow('SH000300', 20211112T, 20211112T);
```

## `indexCapitalFlowData(index_id, begt, endt)`

声明：function

指数资金流向数据，与系统参数(周期)相关。支持高频，

| 参数       | 类型        | 说明             |
| ---------- | ----------- | ---------------- |
| `index_id` | string      | 字符串。指数代码 |
| `begt`     | t_date_time | 日期。开始日期   |
| `endt`     | t_date_time | 日期。结束日期   |

返回：array

### 示例

范例01：调用函数

```tsl
// SH000300在20230403资金流向数据
setSysParam(PN_Cycle(), cy_1m());
return indexCapitalFlowData("SH000300", 20230403T, 20230403T);
```

## `indexnhvixqk2(begt, endt)`

声明：function

获取区间南华指数波动率

| 参数   | 类型 | 说明   |
| ------ | ---- | ------ |
| `begt` | date | 开始日 |
| `endt` | date | 截止日 |

返回：real

### 示例

范例01：调用函数

```tsl
// 获取"NHECI"南华能化指数20200901到20200928的波动率。
setSysParam(pn_stock(), "NHECI");
return indexnhvixqk2(20200901T, 20200928T);
执行结果：
```

## `indexPjCj(begttime, endttime, price_type)`

声明：function

区间指数平均成交价(明细数据)。与系统参数（证券代码）相关

| 参数         | 类型       | 说明                              |
| ------------ | ---------- | --------------------------------- |
| `begttime`   | t_datetime | 日期时间。开始日期时间            |
| `endttime`   | t_datetime | 日期时间。截止日期时间            |
| `price_type` | integer    | 用户自定义。平均价算法，取值如下: |

返回：real

### 示例

范例01：调用函数

```tsl
// 沪深300指数20241108 10:00的5分钟平均成交价(成交量加权平均)
setSysParam(pn_stock(), "SH000300");
return indexPjCj(20241108.0955T, 20241108.10T, 1);
// 输出：4163.1544
```

## `marketTradeDayQk(beg_t, end_t)`

声明：function

区间市场交易日期列表

| 参数    | 类型 | 说明           |
| ------- | ---- | -------------- |
| `beg_t` | date | 日期，开始日期 |
| `end_t` | date | 日期，截止日期 |

返回：table

### 示例

范例01：调用函数

```tsl
// 取得大盘从20120415至20120420的区间交易日列表
setSysParam(pn_cycle(), cy_day());
beg_t := intToDate(20120416);
end_t := intToDate(20120420);
return marketTradeDayQk(beg_t, end_t);
Ctrl + D =
```

## `marketTradedayQK3(begt, endt)`

声明：function

获取市场交易日序列(包括历史和未来预估的）

| 参数    | 类型 | 说明          |
| ------- | ---- | ------------- |
| `begt`  | date | date 开始日期 |
| `endt`  | date | date 截止日期 |

返回：array

### 示例

范例01：取得期货指数在20250701-20250730的交易日序列，执行日期为20250630

```tsl
// 取得期货指数在20250701-20250730的交易日序列，执行日期为20250630

SetSysParam(PN_Stock(), "QI000001");

SetSysParam(pn_cycle(), cy_day());

return MarketTradedayQK3(20250701t, 20250730t);
```

## `markettradedayqk5(begt, endt)`

声明：function

A股市场、港股市场、沪深港通板块获取市场交易日序列。该函数仅从交易日历表获得市场交易日。系统参数：市场指数代码

| 参数   | 类型 | 说明          |
| ------ | ---- | ------------- |
| `begt` | date | date,开始日期 |
| `endt` | date | ,截止日期     |

返回：array

### 示例

范例01：调用函数

```tsl
// 取得港股市场在20250701-20250730的交易日序列，执行日期为20250630
setSysParam(PN_Stock(), "HKHSI001");
return markettradedayqk5(20250701t, 20250730t);
ctrl+d
```

## `marketTradeDayQkOfStks(beg_t, end_t, stks)`

声明：function

市场区间交易情况

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |
| `stks`  | table       | 数组，证券列表     |

返回：table

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）、IF1109从20110905到20110909的的市场区间交易情况
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
stks := array('SZ000002', 'IF1109');
return marketTradeDayQkOfStks(beg_t, end_t, stks);
ctrl + D
```

## `marketTradeDays(beg_t, end_t)`

声明：function

区间市场交易天数

| 参数    | 类型 | 说明           |
| ------- | ---- | -------------- |
| `beg_t` | date | 日期，开始日期 |
| `end_t` | date | 日型，截止日期 |

返回：int

### 示例

范例01：调用函数

```tsl
// 取得大盘从20120415至20120420的区间交易天数
setSysParam(pn_cycle(), cy_day());
beg_t := intToDate(20120416);
end_t := intToDate(20120420);
return marketTradeDays(beg_t, end_t);
// 输出：5
```

## `marketTradeDays2(begt, endt)`

声明：function

区间交易天数（考虑未来交易日）,涉及到未来交易日(估算)

| 参数   | 类型 | 说明          |
| ------ | ---- | ------------- |
| `begt` | date | 日期,开始日期 |
| `endt` | date | 日期,截止日期 |

返回：整数类型

### 示例

范例01：调用函数

```tsl
// 获取A股市场2021-2-26至2021-3-31市场交易天数
setSysParam(pn_stock(), "SH000001");
begt := 20210226T;
endt := 20210331T;
return marketTradeDays2(beg_t, end_t);
// 输出：24
```

## `mqKsplit_stepN(endt, n, cy, option, m, is_complete)`

声明：function

市场交易日区间采样分割（固定间隔/固定分组数）

| 参数          | 类型        | 说明                          |
| ------------- | ----------- | ----------------------------- |
| `endt`        | datetime    | 日期，截止日                  |
| `n`           | integer     | 整数，前推期数                |
| `cy`          | user_define | 用户自定义，采样周期          |
| `option`      | user_define | 用户自定义，模式选择，默认为0 |
| `m`           | integer     | 整数，间隔数或分组数          |
| `is_complete` | bool        | 布尔，是否补齐数据            |

返回：array

### 示例

范例01：调用 MQKsplit_StepN

```tsl
Endt := 20230509T;

N := 10;

cy := cy_day();

return MQKsplit_StepN(Endt, N, cy, 0, 3, 0);
```

## `mqKsplit_stepQK(begt, endt, cy, option, m, is_complete)`

声明：function

市场交易日区间采样分割（固定间隔/固定分组数）

| 参数          | 类型        | 说明                          |
| ------------- | ----------- | ----------------------------- |
| `begt`        | datetime    | 日期，开始日                  |
| `endt`        | datetime    | 日期，截止日                  |
| `cy`          | user_define | 用户自定义，采样周期          |
| `option`      | user_define | 用户自定义，模式选择，默认为0 |
| `m`           | integer     | 整数，间隔数或分组数          |
| `is_complete` | bool        | 布尔，是否补齐数据            |

返回：array

### 示例

范例01：调用 MQKsplit_StepQK

```tsl
Begt := 20220509T;

Endt := 20230509T;

cy := cy_day();

return MQKsplit_StepQK(Begt, Endt, cy, 1, 3, 0);
```

## `repoZf(beg_t, endt)`

声明：function

回购区间收益率(%)，与系统参数(股票)相关

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `beg_t` | t_date_time | 日期。开始日期 |
| `endt`  | t_date_time | 日期。结束日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// "SH204007"在20230901T至20230907T收益率
setSysParam(PN_Stock(), "SH204007");
begt := 20230901T;
endt := 20230907T;
return repoZf(beg_t:t_date_time, end_t:t_date_time);
// 输出：0.0398
```

## `stockAbnormalTransactionDays(beg_t, end_t, criterion, method_type, return_type)`

声明：function

区间异常波动频数

| 参数          | 类型        | 说明              |
| ------------- | ----------- | ----------------- |
| `beg_t`       | t_date_time | 日期，开始日期    |
| `end_t`       | t_date_time | 日期，截止日期    |
| `criterion`   | real        | 实数，评估标准(%) |
| `method_type` | integer     | 整数，评估方式    |
| `return_type` | integer     | 整数，返回类型    |

返回：integer /table_array

### 示例

范例01：A:返回SZ000002（万科A）从20110801到20110901的区间异常波动频数 (只考虑涨幅大于等于评估标准的,返回波动天数)

```tsl
// A:返回SZ000002（万科A）从20110801到20110901的区间异常波动频数 (只考虑涨幅大于等于评估标准的,返回波动天数)

SetSysParam(PN_Stock(), 'SZ000002');

BegT := inttodate(20110801);

EndT := inttodate(20110901);

return StockAbnormalTransactionDays(BegT, EndT, 2, 0, 0);
// 输出：2
```

范例02：B:返回SZ000002（万科A）从20110801到20110901的区间异常波动频数 (只考虑涨幅大于等于评估标准的,返回波动发生的日期)

```tsl
// B:返回SZ000002（万科A）从20110801到20110901的区间异常波动频数 (只考虑涨幅大于等于评估标准的,返回波动发生的日期)

SetSysParam(PN_Stock(), 'SZ000002');

BegT := inttodate(20110801);

EndT := inttodate(20110901);

return StockAbnormalTransactionDays(BegT, EndT, 2, 0, 1);
```

## `stockAmountPercent(beg_t, end_t)`

声明：function

区间成交金额占市场总成交额比例(%)

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `beg_t` | t_date_time | 日期，开始日期 |
| `end_t` | t_date_time | 日期，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间成交金额占市场总成交额比例(%)
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockAmountPercent(beg_t, end_t);
// 输出：0.427
```

## `stockAmountSum(beg_t, end_t)`

声明：function

区间成交金额总和(万)

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `beg_t` | t_date_time | 日期，开始日期 |
| `end_t` | t_date_time | 日期，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间成交金额(万)
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockAmountSum(beg_t, end_t);
// 输出：777422.4032
```

## `stockamountsum6(begtime, endtime)`

声明：function

时点区间成交金额<单位：万元>

| 参数      | 类型     | 说明              |
| --------- | -------- | ----------------- |
| `begtime` | datetime | datetime,开始时间 |
| `endtime` | datetime | datetime,截止时间 |

返回：real

### 示例

范例01：调用函数

```tsl
// 统计2020-04-01日，万科A在10点半到10点40时之间的总成交金额
setSysParam(pn_stock(), 'SZ000002');
setSysParam(pn_rate(), 0); // 不复权
return stockamountsum6(20200401.1030T, 20200401.1040T);
// 输出：11812.18784
```

## `stockAmountSumChange(beg_t, end_t)`

声明：function

区间成交金额变动比(%)

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `beg_t` | t_date_time | 日期，开始日期 |
| `end_t` | t_date_time | 日期，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间成交金额变动比(%)
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockAmountSumChange(beg_t, end_t);
// 输出：-29.79
```

## `stockAveAmountSum(beg_t, end_t)`

声明：function

区间日平均成交金额(万)＝区间成交金额/区间交易天数

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间日平均成交金额(万)
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockAveAmountSum(beg_t, end_t);
// 输出：32392.6001
```

## `stockAveHsl(beg_t, end_t)`

声明：function

区间平均换手率(%)

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间平均换手率(%)
setSysParam(PN_Stock(), 'SZ000002');
setSysParam(PN_Rate(), 1);
setSysParam(PN_RateDay(), intToDate(20110901));
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockAveHsl(beg_t, end_t);
// 输出：0.4043
```

## `stockAveVolSum(beg_t, end_t)`

声明：function

区间日平均成交量(手)

| 参数    | 类型        | 说明     |
| ------- | ----------- | -------- |
| `beg_t` | t_date_time | 开始日期 |
| `end_t` | t_date_time | 截止日期 |

返回：real

### 示例

范例01：调用 StockAveVolSum

```tsl
SetSysParam(PN_Stock(), 'SZ000002');

BegT := inttodate(20110801);

EndT := inttodate(20110901);

return StockAveVolSum(BegT, EndT); // 390414.9975
```

## `stockAveZf(beg_t, end_t)`

声明：function

区间平均涨幅(%) = 区间每日涨幅%/区间交易天数（已复权）

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间平均涨幅(%)
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockAveZf(beg_t, end_t);
// 输出：0.0382
```

## `stockavgclose(begt, endt)`

声明：function

mean(close)指定时间段内区间平均收盘

| 参数   | 类型 | 说明     |
| ------ | ---- | -------- |
| `begt` | date | 开始日期 |
| `endt` | date | 截止日期 |

返回：real

## `stockCumulativeReturn(beg_t, end_t, index_id)`

声明：function

指定时间段内股票对指数的日超额收益的复合收益率（%）

| 参数       | 类型        | 说明          |
| ---------- | ----------- | ------------- |
| `beg_t`    | t_date_time | 日期,开始日期 |
| `end_t`    | t_date_time | 日期,截止日期 |
| `index_id` | string      | 指数,标的指数 |

返回：实数

### 示例

范例01：调用函数

```tsl
// "SH600000"在2025-01-01到2025-12-31对沪深300指数SH000300超额收益的复合收益率
setSysParam(pn_stock(), "SH600000");
beg_t := 20250101T;
end_t := 20251231T;
index_id := "SH000300";
return stockCumulativeReturn(beg_t, end_t, index_id);
// 输出：4.51
```

## `stockExtraZf(beg_t, end_t, index_id, type)`

声明：function

区间超额收益率(%)=股票收益率(%)-指数收益率(%)（已复权）

| 参数       | 类型        | 说明                     |
| ---------- | ----------- | ------------------------ |
| `beg_t`    | t_date_time | 日期类型，开始日期       |
| `end_t`    | t_date_time | 日期类型，截止日期       |
| `index_id` | string      | 字符串类型，指数代码     |
| `type`     | integer     | 整数类型，收益率计算方法 |

返回：real

### 示例

范例01：A：返回SZ000002（万科A）相对于上证指数从20110801到20110901的区间超额收益率(%) :收益率计算方法为涨幅(%)

```tsl
// A：返回SZ000002（万科A）相对于上证指数从20110801到20110901的区间超额收益率(%) :收益率计算方法为涨幅(%)

SetSysParam(PN_Stock(), 'SZ000002');

BegT := inttodate(20110801);

EndT := inttodate(20110901);

return StockExtraZf(BegT, EndT, 'SH000001', 0);
// 输出：5.2697
```

范例02：B：返回SZ000002（万科A）相对于上证指数从20110801到20110901的区间超额收益率(%) :收益率计算方法为对数收益率(%)

```tsl
// B：返回SZ000002（万科A）相对于上证指数从20110801到20110901的区间超额收益率(%) :收益率计算方法为对数收益率(%)

SetSysParam(PN_Stock(), 'SZ000002');

BegT := inttodate(20110801);

EndT := inttodate(20110901);

return StockExtraZf(BegT, EndT, 'SH000001', 1);
// 输出：5.2696
```

## `stockHigh(beg_t, end_t)`

声明：function

区间最高= Max(每日最高价)

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最高
setSysParam(PN_Stock(), 'SZ000002');
setSysParam(PN_Rate(), 1);
setSysParam(PN_RateDay(), intToDate(20110909));
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockHigh(beg_t, end_t);
// 输出：8.2
```

## `stockHighAmount(beg_t, end_t)`

声明：function

区间最高成交金额

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最高成交金额
setSysParam(PN_Stock(), 'SZ000002');
setSysParam(PN_Rate(), 1);
setSysParam(PN_RateDay(), intToDate(20110909));
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockHighAmount(beg_t, end_t);
// 输出：320160192
```

## `stockHighAmountDate(beg_t, end_t)`

声明：function

区间最高成交金额发生日期

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：integer

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最高成交金额发生日期
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockHighAmountDate(beg_t, end_t);
// 输出：20110907
```

## `stockHighClose(beg_t, end_t)`

声明：function

区间最高收盘

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最高收盘
setSysParam(PN_Stock(), 'SZ000002');
setSysParam(PN_Rate(), 1);
setSysParam(PN_RateDay(), intToDate(20110909));
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockHighClose(beg_t, end_t);
// 输出：8.12
```

## `stockHighOpen(beg_t, end_t)`

声明：function

区间最高开盘

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最高开盘
setSysParam(PN_Stock(), 'SZ000002');
setSysParam(PN_Rate(), 1);
setSysParam(PN_RateDay(), intToDate(20110909));
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockHighOpen(beg_t, end_t);
// 输出：8.13
```

## `stockHighVol(beg_t, end_t)`

声明：function

区间最高成交量= Max(每日成交量)

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最高成交量
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockHighVol(beg_t, end_t);
// 输出：39555388
```

## `stockHighVolDate(beg_t, end_t)`

声明：function

区间最高成交量发生日期

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：integer

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最高成交量发生日期
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockHighVolDate(beg_t, end_t);
// 输出：20110907
```

## `stockHsl(beg_t, end_t)`

声明：function

区间换手率(%) =(区间成交量和 / 截止日流通股本) \* 100%

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间换手率(%)
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockHsl(beg_t, end_t);
// 输出：9.7012
```

## `stockHsl6(begtime, endtime)`

声明：function

指定时间段内换手率，该函数与系统参数证券相关

| 参数       | 类型        | 说明                   |
| ---------- | ----------- | ---------------------- |
| `begtime`  | t_date_time | 日期时间类型，开始时间 |
| `endtime`  | t_date_time | 日期时间类型，截止时间 |

返回：real

### 示例

范例01：调用函数

```tsl
// 计算20-04-01日，万科A在9点45到11点半之间的换手率(%)
setSysParam(pn_stock(), 'SZ000002');
return stockHsl6(20200401.0945T, 20200401.1130T);
// 输出：0.471966643888417
```

## `stockLnZf(beg_t, end_t)`

声明：function

区间对数收益率(%)

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间对数收益率(%)
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockLnZf(beg_t, end_t);
// 输出：-0.1228
```

## `stockLow(beg_t, end_t)`

声明：function

区间最低 = Min(每日最低价)

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最低
setSysParam(PN_Stock(), 'SZ000002');
setSysParam(PN_Rate(), 1);
setSysParam(PN_RateDay(), intToDate(20110909));
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockLow(beg_t, end_t);
// 输出：7.95
```

## `stockLowClose(beg_t, end_t)`

声明：function

区间最低收盘

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最低收盘
setSysParam(PN_Stock(), 'SZ000002');
setSysParam(PN_Rate(), 1);
setSysParam(PN_RateDay(), intToDate(20110909));
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockLowClose(beg_t, end_t);
// 输出：8
```

## `stockLowOpen(beg_t, end_t)`

声明：function

区间最开收盘

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最低开盘
setSysParam(PN_Stock(), 'SZ000002');
setSysParam(PN_Rate(), 1);
setSysParam(PN_RateDay(), intToDate(20110909));
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockLowOpen(beg_t, end_t);
// 输出：8
```

## `stockLowVol(beg_t, end_t)`

声明：function

区间最低成交量=Max(每日成交量)

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最低成交量
setSysParam(PN_Stock(), 'SZ000002');
setSysParam(PN_Rate(), 1);
setSysParam(PN_RateDay(), intToDate(20110909));
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockLowVol(beg_t, end_t);
// 输出：17932168
```

## `stockMaxDownDate(beg_t, end_t)`

声明：function

区间最大跌幅发生日期

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：integer

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最大跌幅发生日期
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockMaxDownDate(beg_t, end_t);
// 输出：20110906
```

## `stockmaxdowndate6(begtime, endtime)`

声明：function

区间最低价第一次发生的时间

| 参数      | 类型     | 说明              |
| --------- | -------- | ----------------- |
| `begtime` | datetime | datetime,开始时间 |
| `endtime` | datetime | datetime,截止时间 |

返回：t_date_time

### 示例

范例01：调用函数

```tsl
// 获取华联综超在2020-4-1日9点45分至11点半区间的最大跌幅首次发生的时间
setSysParam(pn_stock(), 'SH600361');
return stockmaxdowndate6(20200401.0945T, 20200401.1130T);
// 输出：2020-04-01 09:56:52
```

## `stockMaxDrawDown(beg_t, endt)`

声明：function

区间最大回撤(%)，与系统参数(证券代码,时间)相关

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `beg_t` | t_date_time | 日期。开始日期 |
| `endt`  | t_date_time | 日期。结束日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// "SZ399997"在2021-05-01至2021-09-15区间最大回撤(%)
setSysParam(pn_stock(), "SZ399997");
return stockMaxDrawDown(20210501T, 20210915T);
// 输出：-32.5
```

## `stockMaxDrawDown2(beg_t, end_t)`

声明：function

返回指定证券区间最大回撤幅度，与系统参数(证券代码)相关

| 参数    | 类型 | 说明               |
| ------- | ---- | ------------------ |
| `beg_t` | date | 日期类型，开始时间 |
| `end_t` | date | 日期类型，截止时间 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回紫金矿业在区间2019-06-24至2021-11-23的最大回撤幅度
setSysParam(pn_stock(), 'SH601899');
return stockMaxDrawDown2(20190624T, 20211123T);
// 输出：-36.02
```

## `stockMaxDrawDownDatas(beg_t, end_t)`

声明：function

返回指定证券区间最大回撤数据，与系统参数(证券代码)相关

| 参数    | 类型 | 说明               |
| ------- | ---- | ------------------ |
| `beg_t` | date | 日期类型，开始时间 |
| `end_t` | date | 日期类型，截止时间 |

返回：array

### 示例

范例01：调用函数

```tsl
// 返回紫金矿业在区间2019-06-24至2021-11-23的最大回撤数据
setSysParam(pn_stock(), 'SH601899');
return stockMaxDrawDownDatas(20190624T, 20211123T);
```

## `stockMaxDrawUp(beg_t, end_t)`

声明：function

区间最大上涨(%)，与系统参数(证券代码、时间)相关

| 参数    | 类型 | 说明           |
| ------- | ---- | -------------- |
| `beg_t` | date | 日期。开始日期 |
| `end_t` | date | 日期。结束日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// "SZ399997"在2021-05-01至2021-09-15区间最大上涨(%)
setSysParam(pn_stock(), "SZ399997");
return stockMaxDrawUp(20210501T, 20210915T);
// 输出：26.038
```

## `stockMaxRateDate(beg_t, end_t)`

声明：function

区间最大涨幅发生日期

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：integer

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最大涨幅发生日期
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockMaxRateDate(beg_t, end_t);
// 输出：20110909
```

## `stockmaxratedate6(begtime, endtime)`

声明：function

区间最高价发生时间

| 参数      | 类型     | 说明              |
| --------- | -------- | ----------------- |
| `begtime` | datetime | datetime,开始时间 |
| `endtime` | datetime | datetime,截止时间 |

返回：string别名:时点区间最大涨幅发生时间

### 示例

范例01：调用函数

```tsl
// 获取华联综超在2020-4-1日9点45分至11点半区间的最大涨幅首次发生的时间
setSysParam(pn_stock(), 'SH600361');
return stockmaxratedate6(20200401.0945T, 20200401.1130T);
// 输出：2020-04-01 09:45:00
```

## `stockMaxRateDown(beg_t, end_t)`

声明：function

区间最大跌幅(%)＝(区间最低-前收盘)/前收盘\*100%（已复权）

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最大跌幅(%)
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockMaxRateDown(beg_t, end_t);
// 输出：-1.8519
```

## `stockMaxRateUp(beg_t, end_t)`

声明：function

区间最大涨幅(%)＝(区间最高-前收盘)/前收盘\*100%（已复权）

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间最大涨幅(%)
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockMaxRateUp(beg_t, end_t);
// 输出：1.2346
```

## `stockObtainAllSpecialTreatmentDates()`

声明：function

获取个股所有的ST日期区间

返回：array

### 示例

范例01：调用函数

```tsl
// 获取股票"SZ000005"所有的ST日期区间
setSysParam(pn_stock(), "SZ000005");
return stockObtainAllSpecialTreatmentDates();
```

## `stockOpen(beg_t, end_t)`

声明：function

区间开盘 = 开始日的开盘价

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间开盘
setSysParam(PN_Stock(), 'SZ000002');
setSysParam(PN_Rate(), 1);
setSysParam(PN_RateDay(), intToDate(20110901));
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockOpen(beg_t, end_t);
// 输出：8.15
```

## `stockpjcj(begt, endt)`

声明：function

:区间平均成交,区间成交金额/区间成交量

| 参数   | 类型 | 说明     |
| ------ | ---- | -------- |
| `begt` | date | 开始日期 |
| `endt` | date | 截止日期 |

返回：real

### 示例

范例01：返回SZ000002（万科A）从20110801到20110901的区间平均成交

```tsl
SetSysParam(PN_Stock(), 'SZ000002');

BegT := inttodate(20110801);

EndT := inttodate(20110901);

return StockPjCj(BegT, EndT);
// 输出：8.297
```

范例02：计算期货合约FB2009在20190920到20200110区间的平均成交价

```tsl
// 计算期货合约FB2009在20190920到20200110区间的平均成交价。

setsysparam(pn_stock(), ' FB2009');

begt := 20190920T;

endt := 20200110T;

setsysparam(pn_date(), endt);

return StockPjCj(BegT, EndT);
// 输出：1406.422
```

## `stockPjCj6(stk_id, beg_t, end_t)`

声明：function

计算区间段的成交量加权平均价

| 参数     | 类型        | 说明                             |
| -------- | ----------- | -------------------------------- |
| `stk_id` | string      | 字符串，股票代码                 |
| `beg_t`  | t_date_time | 时间日期，开始时间，可以精确到秒 |
| `end_t`  | t_date_time | 时间日期，截止时间，可以精确到秒 |

返回：real

### 示例

范例01：调用函数

```tsl
// 计算"SZ000002"在2019年9月25日九点半到十点成交量加权平均价
stk_id := "SZ000002";
begt := strToDateTime("2019-9-25 09:30:00");
endt := strToDateTime("2019-9-25 10:00:00");
return stockPjCj6(stk_id, begt, endt);
// 输出：26.00209696
```

## `stockPrevClose(beg_t, end_t)`

声明：function

区间前收＝开始日前一天的收盘价

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间前收
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockPrevClose(beg_t, end_t);
// 输出：8.15
```

## `stockProfitLossRatio(beg_t, end_t, ctype)`

声明：function

区间盈亏比，跟系统参数（证券代码）相关

| 参数    | 类型    | 说明                            |
| ------- | ------- | ------------------------------- |
| `beg_t` | date    | 日期。开始日期                  |
| `end_t` | date    | 日期。结束日期                  |
| `ctype` | integer | 用户自定义。计算方式，取值如下: |

返回：real

### 示例

范例01：调用函数

```tsl
// "SH000300"在20241128T的20241101T至20241128T区间盈亏比(涨跌幅-算术平均)
setSysParam(pn_stock(), "SH000300");
setSysParam(pn_date(), 20241128T);
n := 20;
return stockProfitLossRatio(20241101T, 20241128T, 0);
// 输出：1.1928
```

## `stockSectionalBuyAmount(beg_t, end_t)`

声明：function

区间资金流向（买）

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间资金流向（买）
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockSectionalBuyAmount(beg_t, end_t);
// 输出：619245949.67
```

## `stockSectionalNetBuyAmount(beg_t, end_t)`

声明：function

区间资金流向（净买卖）=区间累计主买金额和-区间累计主卖金额和

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间资金流向（净买卖）
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockSectionalNetBuyAmount(beg_t, end_t);
// 输出：7042832.38
```

## `stockSectionalSellAmount(beg_t, end_t)`

声明：function

区间资金流向（卖）

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间资金流向（卖）
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockSectionalSellAmount(beg_t, end_t);
// 输出：612203117.29
```

## `stockTradeDayQk(beg_t, end_t)`

声明：function

区间交易情况

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：table_array

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110820到20110901的区间交易情况
setSysParam(PN_Stock(), 'SZ000002');
setSysParam(PN_Cycle(), cy_day());
beg_t := intToDate(20110820);
end_t := intToDate(20110901);
return stockTradeDayQk(beg_t, end_t);
ctrl+D
```

## `stockTradeDays(beg_t, end_t)`

声明：function

区间交易天数

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：integer

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间交易天数
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockTradeDays(beg_t, end_t);
// 输出：24
```

## `stockVolPercent(beg_t, end_t)`

声明：function

区间成交股数占市场总成交股数比例(%)

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间成交股数占市场总成交股数比例(%)
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockVolPercent(beg_t, end_t);
// 输出：0.0076
```

## `stockVolSum(beg_t, end_t)`

声明：function

区间成交量(手)

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间成交量(手)
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockVolSum(beg_t, end_t);
// 输出：9369959.94
```

## `stockvolsum6(begtime, endtime, right)`

声明：function

时点区间成交量 <单位：股>

| 参数      | 类型     | 说明              |
| --------- | -------- | ----------------- |
| `begtime` | datetime | datetime,开始时间 |
| `endtime` | datetime | datetime,截止时间 |
| `right`   | boolean  | bool,是否复权     |

返回：real

### 示例

范例01：调用函数

```tsl
// 统计2020-04-01日，万科A在10点半到10点40时之间的总成交量
setSysParam(pn_stock(), 'SZ000002');
return stockvolsum6(20200401.1030T, 20200401.1040T);
// 输出：4425788
```

## `stockWinRate(beg_t, end_t)`

声明：function

区间胜率(%)，跟系统参数（证券代码、时间）相关

| 参数    | 类型 | 说明           |
| ------- | ---- | -------------- |
| `beg_t` | date | 日期。开始日期 |
| `end_t` | date | 日期。结束日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// "SH000300"在20241128T的20241101T至20241128T区间胜率
setSysParam(pn_stock(), "SH000300");
return stockWinRate(20241101T, 20241128T);
// 输出：45
```

## `stockZdf(beg_t, end_t)`

声明：function

区间振幅(%)＝(区间最高-区间最低)/区间最低\*100%（已复权）

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间振幅(%)
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockZdf(beg_t, end_t);
// 输出：3.1447
```

## `stockZdf6(begtime, endtime)`

声明：function

时点区间振幅(%)，与系统参数证券相关

| 参数       | 类型        | 说明                   |
| ---------- | ----------- | ---------------------- |
| `begtime`  | t_date_time | 日期时间类型，开始时间 |
| `endtime`  | t_date_time | 日期时间类型，截止时间 |

返回：real

### 示例

范例01：调用函数

```tsl
// 计算华联综超在2020-4-1日9点45分至11点半区间的振幅(%)
setSysParam(pn_stock(), 'SH600361');
return stockZdf6(20200401.0945T, 20200401.1130T);
// 输出：4.86111111111111
```

## `stockZdValue(beg_t, end_t)`

声明：function

区间波动值= 区间最高-区间最低

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110801到20110901的区间波动值
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110801);
end_t := intToDate(20110901);
return stockZdValue(beg_t, end_t);
// 输出：0.74
```

## `stockZf(beg_t, end_t)`

声明：function

区间涨幅(%)＝(截止日收盘价-前收盘价) /前收盘\*100%（已复权）

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `beg_t` | t_date_time | 日期类型，开始日期 |
| `end_t` | t_date_time | 日期类型，截止日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// 返回SZ000002（万科A）从20110905到20110909的区间涨幅(%)
setSysParam(PN_Stock(), 'SZ000002');
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
return stockZf(beg_t, end_t);
// 输出：-0.2469
```

## `stockZf6(beg_t_time, end_t_time)`

声明：function

时点区间涨幅(%)(已复权)，与系统证券pn_stock()、系统时间pn_date()，与系统周期pn_cycle()无关。调用时需注意设置系统参数

| 参数         | 类型        | 说明                   |
| ------------ | ----------- | ---------------------- |
| `beg_t_time` | t_date_time | 日期类型，开始日期时间 |
| `end_t_time` | t_date_time | 日期类型，截止日期时间 |

返回：real

### 示例

范例01：返回万科A从20110905到20110909的时点区间涨幅(%)-日线

```tsl
SetSysParam(PN_Stock(), 'SZ000002');

BegTTime := inttodate(20110905);

EndTTime := inttodate(20110909);

return StockZf6(BegTTime, EndTTime);
// 输出：万科A从20110905到20110909的时点区间涨幅(%)-日线。
```

范例02：返回万科A从20110905 9:00到15:00的时点区间涨幅(%)-高频

```tsl
SetSysParam(PN_Stock(), 'SZ000002');

BegTTime := strtodatetime("2011-09-05 09:00:00");

EndTTime := strtodatetime("2011-09-05 15:00:00");

return StockZf6(BegTTime, EndTTime);
// 输出：万科A从20110905 9:00到15:00的时点区间涨幅(%)-高频。
```

## `stockzf7(begt, endt)`

声明：function

区间涨幅(%)-适用于期货期权

| 参数   | 类型 | 说明     |
| ------ | ---- | -------- |
| `begt` | date | 开始日期 |
| `endt` | date | 结束日期 |

返回：real

## `stockZf8(beg_t, endt)`

声明：function

区间涨幅(%)(适用多资产)，与系统参数(股票)相关

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `beg_t` | t_date_time | 日期。开始日期 |
| `endt`  | t_date_time | 日期。结束日期 |

返回：real

### 示例

范例01：调用函数

```tsl
// "SH204007"在20230901T至20230907T收益率
setSysParam(PN_Stock(), "SH204007");
begt := 20230901T;
endt := 20230907T;
return stockZf8(beg_t:t_date_time, end_t:t_date_time);
// 输出：0.0398
```

## `stockZf_no(bk_name, beg_t, end_t, sort_by, return_type)`

声明：function

区间涨幅排名

| 参数          | 类型     | 说明                 |
| ------------- | -------- | -------------------- |
| `bk_name`     | string   | 字符串类型，板块名称 |
| `beg_t`       | datetime | 日期类型，开始日期   |
| `end_t`       | datetime | 日期类型，截止日期   |
| `sort_by`     | int      | 整数类型，排序字段   |
| `return_type` | int      | 整数类型，返回类型   |

返回：float

### 示例

范例01：返回SZ000002（万科A）从20110905到20110909在“我的沪深300”中的区间涨幅排名

```tsl
bk := getbkbydate('SH000300', inttodate(20111231));

savebk('我的沪深300', '用户板块', bk);

SetSysParam(PN_Stock(), 'SZ000002');

BegT := inttodate(20110905);

EndT := inttodate(20110909);

return StockZf_No('我的沪深300', BegT, EndT, 0, 0);
// 输出：76
```

## `stockZf_noIpo(beg_t, end_t)`

声明：function

区间涨幅-上市日不计入(%) ＝(截止日收盘价-前收盘价) /前收盘\*100%（已复权）

| 参数    | 类型     | 说明               |
| ------- | -------- | ------------------ |
| `beg_t` | datetime | 日期类型，开始日期 |
| `end_t` | datetime | 日期类型，截止日期 |

返回：float

### 示例

范例01：返回SZ000002（万科A）从20110905到20110909的区间涨幅-上市日不计入(%)

```tsl
SetSysParam(PN_Stock(), 'SZ000002');

BegT := inttodate(20110905);

EndT := inttodate(20110909);

return StockZf_NoIPO(BegT, EndT);
// 输出：-0.2469
```

## `stockZf_settlement(beg_t, end_t)`

声明：function

使用结算价计算，仅适用于期货期权，仅支持日线 区间结算涨幅(%)=(截止日结算价-开始日前结算价）/开始日前结算价\*100%

| 参数    | 类型     | 说明             |
| ------- | -------- | ---------------- |
| `beg_t` | datetime | 日期类型，开始日 |
| `end_t` | datetime | 日期类型，截止日 |

返回：float

### 示例

范例01：调用 StockZf_Settlement

```tsl
BegT := 20240101T;

EndT := 20240105T;

SetSysParam(PN_Stock(), "ZLAL10");

return StockZf_Settlement(BegT, EndT);   // -1.5649
```

## `stockZfNoG(beg_t, endt)`

声明：function

区间涨幅(股权分置不复权)(%)，与系统参数(股票)相关

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `beg_t` | t_date_time | 日期。开始日期 |
| `endt`  | t_date_time | 日期。结束日期 |

返回：real

### 示例

范例01：调用函数

```tsl
setSysParam(pn_stock(), 'SZ000002');
return stockZfNoG(20230101T, 20231231T);
// 输出：-39.57
```