
# 算术函数
本文介绍算术函数的语法规则，包括参数解释、函数示例等。
#### 函数列表
如果值为负数，请使用op_neg(positive value)函数，例如：要表示-1，请使用op_neg(1)。
表1算术函数列表 
| **类型** | **函数**                                                                                                                                   | **说明**           |
|:---|:---|:---|
| 多值计算比较 | [op_sum]       | 对传入值进行求和操作。      |
| 基础计算   | [op_abs]        | 对传入值进行绝对值操作。     |
| 基础计算   | [op_div_floor]  | 对传入值进行整除操作。      |
| 基础计算   | [op_div_true] | 对传入值进行除法操作。      |
| 基础计算   | [op_pow]       | 对值进行幂值计算操作。      |
| 基础计算   | [op_mul]      | 对传入值进行乘法运算。      |
| 基础计算   | [op_neg]      | 计算传入值的相反数。       |
| 基础计算   | [op_mod]        | 对传入值进行模计算。       |
| 基础计算   | [op_sub]      | 对传入值进行减法运算。      |
| 基础计算   | [op_round]    | 对传入值进行四舍五入操作。    |
| 数学计算   | [mat_ceil]     | 对传入值进行向上取整操作。    |
| 数学计算   | [mat_exp]    | 以常数e为底的指数函数。     |
| 数学计算   | [mat_fabs]     | 计算传入值的绝对值。       |
| 数学计算   | [mat_floor]    | 对传入值进行向下取整操作。    |
| 数学计算   | [mat_log]     | 计算传入值的对数。        |
| 数学计算   | [mat_log10]    | 计算以10为基数的传入值的对数。 |
   
 #### op_sum
对传入值进行求和操作。
- **函数格式**
  ```
  op_sum(value1, value2, ...)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 数字或数字字符串 | 是        | 待计算的值。 |
  | value2   | 数字或数字字符串 | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回多个传入值的求和结果。
  
- **函数示例**
  计算course_price和goods_price总价。
  - 测试数据
    ```
    {
     "course_price": 12,
     "goods_price": 2
    }
    ```
    
  
  - 加工规则
    ```
    e_set("account", op_sum(v("course_price"), v("goods_price")))
    ```
    
  
  - 加工结果
    ```
    course_price: 12
    goods_price: 2
    account: 14
    ```
    
   
 
 #### op_abs
对传入值进行绝对值操作。
- **函数格式**
  ```
  op_abs(value)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value    | 数字或数字字符串 | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回传入值的绝对值。
  
- 函数示例
  - 测试数据
    ```
    {
     "course_price": -4
    }
    ```
    
  
  - 加工规则
    ```
    e_set("op_abs", op_abs(v("course_price")))
    ```
    
  
  - 加工结果
    ```
    course_price: -4
    op_abs: 4
    ```
    
   
 
 #### op_div_floor
对传入值进行整除操作。
- **函数格式**
  ```
  op_div_floor(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 数字或数字字符串 | 是        | 待计算的值。 |
  | value2   | 数字或数字字符串 | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回值1与值2整除的结果。
  
- **函数示例**
  根据course_price字段和count字段计算单价。
  - 测试数据
    ```
    {
     "course_price": 4,
     "count": 2
    }
    ```
    
  
  - 加工规则
    ```
    e_set("op_div_floor", op_div_floor(v("course_price"), v("count")))
    ```
    
  
  - 加工结果
    ```
    course_price: 4
    count: 2
    op_div_floor: 2
    ```
    
   
 
 #### op_div_true
对传入值进行除法操作。
**说明** 该函数支持自动转换数据类型，输入string或者int类型的数据即可。
- **函数格式**
  ```
  op_div_true(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** |   **参数类型**    | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 数字字符串/ Number | 是        | 待计算的值。 |
  | value2   | 数字字符串/ Number | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回值1/值2的结果。
  
- **函数示例**
  1. 示例1：根据fruit_price和count字段计算单价。
     - 测试数据
       ```
       {
        "fruit_price": 9,
        "count": 2
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_div_true", op_div_true(v("fruit_price"), v("count")))
       ```
       
     
     - 加工结果
       ```
       fruit_price: 9
       count: 2
       op_div_true: 4.5
       ```
       
      
  
  2. 示例2：计算加速度（四舍五入），计算公式为a = (one_speed-two_speed)/time 。
     - 测试数据
       ```
       {
        "one_speed": 9,
        "two_speed": 2,
        "time": 3
       }
       ```
       
     
     - 加工规则
       ```
       e_set("a", op_round(op_div_true(op_sub(v("one_speed"), v("two_speed")), v("time")), 2))
       ```
       
     
     - 加工结果
       ```
       a:2.33
       one_speed:9
       time:3
       two_speed:2
       ```
       
      
   
 
 #### op_pow
对值进行幂值计算操作。
- **函数格式**
  ```
  op_pow(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 数字或数字字符串 | 是        | 待计算的值。 |
  | value2   | 数字或数字字符串 | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回值1的值2次方的结果。
  
- **函数示例**
  计算course的pow次方的值。
  - 测试数据
    ```
    {
     "course": 100,
     "pow": 2
    }
    ```
    
  
  - 加工规则
    ```
    e_set("pow_course", op_pow(v("course"), v("pow")))
    ```
    
  
  - 加工结果
    ```
    course: 100
    pow: 2
    pow_course: 10000
    ```
    
   
 
 #### op_mul
对传入值进行乘法运算。
- **函数格式**
  ```
  op_mul(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** |   **参数类型**    | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 数字、字符串、元祖、列表等 | 是        | 待计算的值。 |
  | value2   | 数字            | 是        | 待计算的值。 |
     
  
- **返回结果**
  - 若值1和值2为数字，返回相乘的结果。
  
  - 若值1和值2为字符串、元祖、列表等，返回扩大倍数的原类型。
   
- **函数示例**
  1. 示例1：根据course和price字段计算总价。
     - 测试数据
       ```
       {
        "course": 10,
        "price": 23
       }
       ```
       
     
     - 加工规则
       ```
       e_set("account", op_mul(ct_int(v("course")), ct_int(v("price"))))
       ```
       
     
     - 加工结果
       ```
       course: 10
       price: 23
       account: 230
       ```
       
      
  
  2. 示例2：将course字段扩大3倍。
     - 测试数据
       ```
       {
        "course": "abc"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("course", op_mul(v("course"), 3))
       ```
       
     
     - 加工结果
       ```
       course: abcabcabc
       ```
       
      
   
 
 #### op_neg
计算传入值的相反数。
- **函数格式**
  ```
  op_neg(value)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value    | 数字或数字字符串 | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回传入值的相反数。
  
- **函数示例**
  - 测试数据
    ```
    {
     "course": -100
    }
    ```
    
  
  - 加工规则
    ```
    e_set("account", op_neg(v("course")))
    ```
    
  
  - 加工结果
    ```
    course: -100
    account: 100
    ```
    
   
 
 #### op_mod
对传入值进行模计算。
- **函数格式**
  ```
  op_mod(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 数字或数字字符串 | 是        | 待计算的值。 |
  | value2   | 数字或数字字符串 | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回值1对值2取模的结果。
  
- **函数示例**
  - 测试数据
    ```
    {
     "course": 4,
     "count": 3
    }
    ```
    
  
  - 加工规则
    ```
    e_set("op_mod", op_mod(v("course"), v("count")))
    ```
    
  
  - 加工结果
    ```
    course: 4
    count: 3
    op_mod: 1
    ```
    
   
 
 #### op_sub
对传入值进行减法运算。
- **函数格式**
  ```
  op_sub(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 数字或数字字符串 | 是        | 待计算的值。 |
  | value2   | 数字或数字字符串 | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回值1减去值2的结果。
  
- **函数示例**
  计算count减count_apple的结果。
  - 测试数据
    ```
    {
     "count": 6,
     "count_apple": 3
    }
    ```
    
  
  - 加工规则
    ```
    e_set("sub_number", op_sub(v("count"),v("count_apple")))
    ```
    
  
  - 加工结果
    ```
    count: 6
    count_apple: 3
    sub_number:  3
    ```
    
   
 
 #### op_round
对传入值进行四舍五入操作。
- **函数格式**
  ```
  op_round(value, number)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** |         **说明**         |
  |---|---|---|---|
  | value    | 数字或数字字符串 | 是        | 待计算的值。                 |
  | number   | 数字       | 是        | 表示四舍五入后保留的小数点位数，默认值为0。 |
     
  
- **返回结果**
  返回传入值的四舍五入的结果。
  
- **函数示例**
  返回price小数点后1位数。
  - 测试数据
    ```
    {
     "price": 4.56
    }
    ```
    
  
  - 加工规则
    ```
    e_set("round_price", op_round(v("price"),1))
    ```
    
  
  - 加工结果
    ```
    price: 4.56
    round_price: 4.6
    ```
    
   
 
 #### mat_ceil
对传入值进行向上取整操作。
- **函数格式**
  ```
  mat_ceil(value)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value    | 数字或数字字符串 | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回大于或者等于指定值的最小整数。
  
- **函数示例**
  - 测试数据
    ```
    {
     "price": 4.1
    }
    ```
    
  
  - 加工规则
    ```
    e_set("mat_ceil", mat_ceil(v("price")))
    ```
    
  
  - 加工结果
    ```
    price: 4.1
    mat_ceil: 5
    ```
    
   
 
 #### mat_exp
以常数e为底的指数函数，返回e的次幂结果。
- **函数格式**
  ```
  mat_exp(value)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value    | 数字或数字字符串 | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回e的次幂结果。
  
- **函数示例**
  - 测试数据
    ```
    {
     "number": 2
    }
    ```
    
  
  - 加工规则
    ```
    e_set("e_x", mat_exp(v("number")))
    ```
    
  
  - 加工结果
    ```
    number: 2
    e_x: 7.38905609893065
    ```
    
   
 
 #### mat_fabs
计算传入值的绝对值。
- **函数格式**
  ```
  mat_fabs(value)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value    | 数字或数字字符串 | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回传入值的绝对值。
  
- **函数示例**
  - 测试数据
    ```
    {
     "course_price": -10
    }
    ```
    
  
  - 加工规则
    ```
    e_set("mat_fabs", mat_fabs(v("course_price")))
    ```
    
  
  - 加工结果
    ```
    course_price: -10
    mat_fabs: 10.0
    ```
    
   
 
 #### mat_floor
对传入值进行向下取整操作。
- **函数格式**
  ```
  mat_floor(value)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value    | 数字或数字字符串 | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回小于或者等于指定值的最大整数。
  
- **函数示例**
  - 测试数据
    ```
    {
     "course_price": 4.9
    }
    ```
    
  
  - 加工规则
    ```
    e_set("mat_floor", mat_floor(v("course_price")))
    ```
    
  
  - 加工结果
    ```
    course_price: 4.9
    mat_floor: 4
    ```
    
   
 
 #### mat_log
计算传入值的对数。
- **函数格式**
  ```
  mat_log(value1,value2)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 数字或数字字符串 | 是        | 待计算的值。 |
  | value2   | 数字或数字字符串 | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回传入值的对数。
  
- **函数示例**
  - 测试数据
    ```
    {
     "number1": 100,
     "number2": 10
    }
    ```
    
  
  - 加工规则
    ```
    e_set("mat_log", mat_log(v("number1"),v("number2")))
    ```
    
  
  - 加工结果
    ```
    number1: 100
    number2: 10
    mat_log: 2.0
    ```
    
   
 
 #### mat_log10
计算以10为基数的传入值的对数。
- **函数格式**
  ```
  mat_log10(value)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value    | 数字或数字字符串 | 是        | 待计算的值。 |
     
  
- **返回结果**
  返回以10为基数的传入值的对数结果。
  
- **函数示例**
  - 测试数据
    ```
    {
     "number": 100
    }
    ```
    
  
  - 加工规则
    ```
    e_set("number2", mat_log10(v("number")))
    ```
    
  
  - 加工结果
    ```
    number: 100
    numbe2: 2.0
    ```
    
   
 
