# 金融 / 行情 / 区间

## `dateOfStockHigh(beg_t, end_t)`

声明：function

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数       | 类型   | 说明             |
| ---------- | ------ | ---------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数       | 类型        | 说明             |
| ---------- | ----------- | ---------------- |
| `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(beg_t, end_t)`

声明：function

返回系统证券在指定区间内的 5 日、20 日、60 日和 120 日南华指数波动率序列。

<!-- tags: 金融 行情 区间 南华指数 波动率 5日 20日 60日 120日 序列 -->

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

返回：table_array

依赖系统参数：`pn_stock()`。

### 示例

范例01：获取 NHECI 在 2020-09-01 至 2020-09-28 的波动率记录数

```tsl
setSysParam(pn_stock(), 'NHECI');
ret := indexnhvixqk2(20200901T, 20200928T);
return length(ret);
// 输出：20
```

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

声明：function

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数         | 类型       | 说明                              |
| ------------ | ---------- | --------------------------------- |
| `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

返回区间市场交易日期列表

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型 | 说明           |
| ------- | ---- | -------------- |
| `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(beg_t, end_t)`

声明：function

返回系统市场指数在指定区间内的交易日序列，包括历史交易日和未来预估交易日。

<!-- tags: 金融 行情 区间 交易日 交易日历 历史交易日 未来预估 系统证券 -->

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

返回：array

依赖系统参数：`pn_stock()` 和 `pn_cycle()`。

### 示例

范例01：取得期货指数在 2025-07-01 至 2025-07-30 的交易日数量

```tsl
setSysParam(pn_stock(), 'QI000001');
setSysParam(pn_cycle(), cy_day());
ret := marketTradedayQK3(20250701T, 20250730T);
return length(ret);
// 输出：22
```

## `markettradedayqk5(beg_t, end_t)`

声明：function

根据系统市场指数从交易日历表返回 A 股、港股或沪深港通市场的交易日序列。

<!-- tags: 金融 行情 区间 交易日 交易日历 A股 港股 沪深港通 系统证券 -->

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

返回：array

依赖系统参数：`pn_stock()`。

### 示例

范例01：取得港股市场在 2025-07-01 至 2025-07-30 的交易日数量

```tsl
setSysParam(pn_stock(), 'HKHSI001');
ret := markettradedayqk5(20250701T, 20250730T);
return length(ret);
// 输出：21
```

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

声明：function

返回多只证券在指定区间内的市场交易情况表。

<!-- tags: 金融 行情 区间 多证券 交易情况 交易日 表格 股票 期货 -->

| 参数    | 类型       | 说明         |
| ------- | ---------- | ------------ |
| `beg_t` | t_datetime | 开始日期     |
| `end_t` | t_datetime | 截止日期     |
| `stks`  | array      | 证券代码数组 |

返回：table

### 示例

范例01：返回万科 A 与 IF1109 在 2011-09-05 至 2011-09-09 的交易情况行数

```tsl
beg_t := intToDate(20110905);
end_t := intToDate(20110909);
stocks := array('SZ000002', 'IF1109');
ret := marketTradeDayQkOfStks(beg_t, end_t, stocks);
return length(ret);
// 输出：5
```

## `marketTradeDays(beg_t, end_t)`

声明：function

返回区间市场交易天数

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型 | 说明           |
| ------- | ---- | -------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数   | 类型 | 说明          |
| ------ | ---- | ------------- |
| `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_resampling(begt, endt, cy, if_name, type)`

声明：function

按指定周期将市场交易日区间重新采样并分割为多个子区间

<!-- tags: 金融 行情 交易日 区间 分割 重采样 周期 resampling split -->

| 参数      | 类型        | 说明                                 |
| --------- | ----------- | ------------------------------------ |
| `begt`    | t_date_time | 开始日期                             |
| `endt`    | t_date_time | 截止日期                             |
| `cy`      | string      | 采样周期                             |
| `if_name` | boolean     | 可选。是否为区间生成名称，默认 false |
| `type`    | integer     | 可选。区间边界方式，默认 0，取值见下 |

type 取值

- `0` — 取包含指定起止日期的最小区间
- `1` — 取位于指定起止日期内的最大区间

返回：array

### 示例

范例01：按年度分割市场交易日区间

```tsl
return mqKsplit_resampling(20100101T, 20110101T, cy_year());
```

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

声明：function

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数          | 类型        | 说明                          |
| ------------- | ----------- | ----------------------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数          | 类型        | 说明                          |
| ------------- | ----------- | ----------------------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `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

返回区间异常波动频数

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数          | 类型        | 说明              |
| ------------- | ----------- | ----------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `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

返回区间成交金额总和(万)

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `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

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

<!-- tags: 金融 行情 区间 -->

| 参数      | 类型     | 说明              |
| --------- | -------- | ----------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

返回区间平均换手率(%)

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

返回区间日平均成交量(手)

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明     |
| ------- | ----------- | -------- |
| `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

计算区间平均涨幅(%)，公式为区间每日涨幅%/区间交易天数（已复权）

<!-- tags: 金融 行情 区间 计算 求解 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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)指定时间段内区间平均收盘

<!-- tags: 金融 行情 区间 返回 获取 -->

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

返回：real

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

声明：function

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数       | 类型        | 说明          |
| ---------- | ----------- | ------------- |
| `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

计算区间超额收益率(%)，公式为股票收益率(%)-指数收益率(%)（已复权）

<!-- tags: 金融 行情 区间 计算 求解 -->

| 参数       | 类型        | 说明                     |
| ---------- | ----------- | ------------------------ |
| `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(每日最高价)

<!-- tags: 金融 行情 区间 计算 求解 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

返回区间最高成交金额

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

返回区间最高收盘

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

返回区间最高开盘

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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(每日成交量)

<!-- tags: 金融 行情 区间 计算 求解 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

返回区间最高成交量发生日期

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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%

<!-- tags: 金融 行情 区间 计算 求解 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数      | 类型        | 说明                   |
| --------- | ----------- | ---------------------- |
| `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

返回区间对数收益率(%)

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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(每日最低价)

<!-- tags: 金融 行情 区间 计算 求解 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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
```

## `stockLowAmount(beg_t, end_t)`

声明：function

返回指定区间内每日成交金额的最小值，与系统参数中的证券代码相关

<!-- tags: 金融 行情 区间 最低成交金额 成交额 minimum turnover amount -->

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

返回：real

### 示例

范例01：查询万科 A 在指定区间内的最低成交金额

```tsl
setSysParam(pn_stock(), "SZ000002");
return stockLowAmount(20110905T, 20110909T);
// 输出：145404758.24
```

## `stockLowClose(beg_t, end_t)`

声明：function

返回区间最低收盘

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

返回区间最开收盘

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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(每日成交量)

<!-- tags: 金融 行情 区间 计算 求解 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

返回区间最大跌幅发生日期

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数      | 类型     | 说明              |
| --------- | -------- | ----------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `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(n)`

声明：function

返回系统证券截至系统日期最近 `n` 个交易日的最大回撤幅度。

<!-- tags: 金融 行情 风险 最大回撤 最近N日 滚动窗口 系统证券 系统日期 -->

| 参数 | 类型    | 说明             |
| ---- | ------- | ---------------- |
| `n`  | integer | 最近交易日的数量 |

返回：real

依赖系统参数：`pn_stock()`、`pn_date()` 和 `pn_cycle()`。

### 示例

范例01：计算紫金矿业截至 2021-11-23 最近 250 个交易日的最大回撤

```tsl
setSysParam(pn_stock(), 'SH601899');
setSysParam(pn_date(), 20211123T);
setSysParam(pn_cycle(), cy_day());
return stockMaxDrawDown2(250);
// 输出：-36.021873
```

## `stockMaxDrawDownDatas(beg_t, end_t)`

声明：function

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型 | 说明               |
| ------- | ---- | ------------------ |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型 | 说明           |
| ------- | ---- | -------------- |
| `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

返回区间最大涨幅发生日期

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

返回区间最高价发生时间

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数      | 类型     | 说明              |
| --------- | -------- | ----------------- |
| `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%（已复权）

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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%（已复权）

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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日期区间

<!-- tags: 金融 行情 区间 获取 查询 ST -->

返回：array

### 示例

范例01：调用函数

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

## `stockOpen(beg_t, end_t)`

声明：function

计算区间开盘，公式为开始日的开盘价

<!-- tags: 金融 行情 区间 计算 求解 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

返回区间平均成交价，计算公式为区间成交金额 / 区间成交量

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数   | 类型 | 说明     |
| ------ | ---- | -------- |
| `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

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

<!-- tags: 金融 行情 区间 计算 求解 -->

| 参数     | 类型        | 说明                             |
| -------- | ----------- | -------------------------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型    | 说明                            |
| ------- | ------- | ------------------------------- |
| `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

返回区间资金流向（买）

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

计算区间资金流向（净买卖），公式为区间累计主买金额和-区间累计主卖金额和

<!-- tags: 金融 行情 区间 计算 求解 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

返回区间资金流向（卖）

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

返回系统证券在指定区间内的交易情况表。

<!-- tags: 金融 行情 区间 证券 交易情况 交易日 表格 系统证券 系统周期 -->

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

返回：table_array

依赖系统参数：`pn_stock()` 和 `pn_cycle()`。

### 示例

范例01：返回万科 A 在 2011-08-20 至 2011-09-01 的交易情况行数

```tsl
setSysParam(pn_stock(), 'SZ000002');
setSysParam(pn_cycle(), cy_day());
beg_t := intToDate(20110820);
end_t := intToDate(20110901);
ret := stockTradeDayQk(beg_t, end_t);
return length(ret);
// 输出：9
```

## `stockTradeDays(beg_t, end_t)`

声明：function

返回区间交易天数

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

返回区间成交量(手)

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

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

<!-- tags: 金融 行情 区间 -->

| 参数      | 类型     | 说明              |
| --------- | -------- | ----------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型 | 说明           |
| ------- | ---- | -------------- |
| `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%（已复权）

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数      | 类型        | 说明                   |
| --------- | ----------- | ---------------------- |
| `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

计算区间波动值，公式为区间最高-区间最低

<!-- tags: 金融 行情 区间 计算 求解 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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%（已复权）

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明               |
| ------- | ----------- | ------------------ |
| `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()无关。调用时需注意设置系统参数

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数         | 类型        | 说明                   |
| ------------ | ----------- | ---------------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

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

返回：real

## `stockZf8(beg_t, endt)`

声明：function

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

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型        | 说明           |
| ------- | ----------- | -------------- |
| `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

返回区间涨幅排名

<!-- tags: 金融 行情 区间 排序 sort 返回 获取 -->

| 参数          | 类型     | 说明                 |
| ------------- | -------- | -------------------- |
| `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%（已复权）

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型     | 说明               |
| ------- | -------- | ------------------ |
| `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%

<!-- tags: 金融 行情 区间 返回 获取 -->

| 参数    | 类型     | 说明             |
| ------- | -------- | ---------------- |
| `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

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

<!-- tags: 金融 行情 区间 返回 获取 -->

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

返回：real

### 示例

范例01：调用函数

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