Math API

模块

定义使用更高抽象的基本数学运算.

  • void multeq_i128 (uint128_t self, const uint128_t other)

    • 乘以两个128位无符号位整数。 如果指针无效，则抛出异常。

  • void (uint128_t self, const uint128_t other)

    • 将两个128位无符号位整数相除，并在无效指针时引发异常.

  • uint64_t double_add (uint64_t a, uint64_t b)

    • double类型之间相加。

  • uint64_t (uint64_t a, uint64_t b)

    • double类型之间相乘

  • uint64_t double_div (uint64_t a, uint64_t b)

    • double类型之间相除

  • uint32_t (uint64_t a, uint64_t b)

    • double类型小于比较。

  • uint32_t double_eq (uint64_t a, uint64_t b)

    • double类型相等比较。

  • uint32_t (uint64_t a, uint64_t b)

    • double类型大于比较。

  • uint64_t double_to_i64 (uint64_t a)

    • 将double转换为64位无符号整数。

  • uint64_t (uint64_t a)
    • 将64位无符号整数转换为double（解释为64位无符号整数）。
  • diveq_i128()
    • 参数
      • self 指向分子的指针。它将被替换为结果
      • other 指向分母的指针　　　

例子:

  2. uint128_t other(100);
  3. diveq_i128(&self, &other);
  4. printi128(self); // Output: 1
  • double_add()

    uint64_t double_add( uint64_t a, uint64_t b) 

    1.   获得两个double之间的加法结果，解析为64位无符号整数此函数首先将两个输入重新解码为双精度（50个十进制数字精度），将它们相加，然后reinterpret_cast将结果重新解析为64位无符号整数。　　　
    • 参数
      • a 双精度解释为64位无符号整数
      • b 双精度解释为64位无符号整数
    • 返回
      • reinterpret_cast将相加得到的64位无符号整数的结果 　　　　

例子:

  1. uint64_t a = double_div( i64_to_double(5), i64_to_double(10) );
  2. uint64_t b = double_div( i64_to_double(5), i64_to_double(2) );
  3. uint64_t res = double_add( a, b );
  4. printd(res); // Output: 3

  • double_div()

    uint64_t double_div(uint64_t a, uint64_t b ) 

    1.   得到两个双精度解的结果，解释为64位无符号整数该函数首先将两个输入重新解码为双精度（50位十进制数字精度），用分母分隔分子，然后将结果重新解释为64位无符号整数。 如果b为零（在reinterpret_cast加倍后）将引发错误.
    • 参数
      • b 双分母被解释为64位无符号整数
    • 返回
      • 相除的结果reinterpret_cast转换为64位无符号整数　
        　　
        例子:
  1. uint64_t a = double_div( i64_to_double(10), i64_to_double(100) );
  2. printd(a); // Output: 0.1

  • double_eq()

    uint32_t double_eq(uint64_t a, uint64_t b ) 

    1.   获取两个double之间的相等检查结果在进行相等检查之前，此函数将首先重新解释两个输入以重复（50位十进制数字精度）
    • 参数
      • a 双精度解析为64位无符号整数
      • b 双精度解析为64位无符号整数
    • 返回
      • 如果第一个输入等于第二个输入，则为1，否则为0　　
        　
        例子:
  1. int64_t a = double_div( i64_to_double(10), i64_to_double(10) );
  2. uint64_t b = double_div( i64_to_double(5), i64_to_double(2) );
  3. uint64_t res = double_eq( a, b );
  4. printi(res); // Output: 0

  • double_gt()

    1.   两个双精度进行大于比较获得大的一个，此函数首先将两个输入重新解释为双精度（50个十进制数精度）。
    • 参数
      • a 双精度解析为64位无符号整数
      • b 双精度解析为64位无符号整数
    • 返回
      • 如果第一个输入大于于第二个输入，则为1，否则为0　　
        　
        例子:
  1. uint64_t a = double_div( i64_to_double(10), i64_to_double(10) );
  2. uint64_t b = double_div( i64_to_double(5), i64_to_double(2) );
  4. printi(res); // Output: 0

  • double_lt()

    uint32_t double_lt(uint64_t a, uint64_t b )

    • 参数
      • a 双精度解析为64位无符号整数
      • b 双精度解析为64位无符号整数
    • 返回
      • 如果第一个输入小于于第二个输入，则为1，否则为0
        　　　　
        例子:
  1. uint64_t a = double_div( i64_to_double(10), i64_to_double(10) );
  2. uint64_t b = double_div( i64_to_double(5), i64_to_double(2) );
  3. uint64_t res = double_lt( a, b );
  4. printi(res); // Output: 1

  • double_mult()

    uint64_t double_mult(uint64_t a, uint64_t b ) 

    1.   获得两个double之间的乘法结果，解释为64位无符号整数此函数首先将两个输入重新解码为双精度（50位十进制精度），然后将它们相乘，然后reinterpret_cast将结果重新解析为64位无符号整数。
    • 参数
      • a 双精度解析为64位无符号整数
      • b 双精度解析为64位无符号整数
    • 返回
      • 相乘的结果reinterpret_cast转换为64位无符号整数
        　　　
        例子:
  1. uint64_t a = double_div( i64_to_double(10), i64_to_double(10) );
  2. uint64_t b = double_div( i64_to_double(5), i64_to_double(2) );
  3. uint64_t res = double_mult( a, b );
  4. printd(res); // Output: 2.5

  • double_to_i64()

    uint64_t double_to_i64(uint64_t a )

      • 参数
        • a 双精度解析为64位无符号整数
      • 返回
        -　64位无符号整数转换结果　
        　　
        例子:
    1. uint64_t a = double_div( i64_to_double(5), i64_to_double(2) );
    2. uint64_t res = double_to_i64( a );
    3. printi(res); // Output: 2

    • i64_to_double()

      1.   将double（解释为64位无符号整数）转换为64位无符号整数。 该函数首先将输入重新解码为双精度（50位十进制数字精度），然后将其转换为双精度，然后将其重新解码为64位无符号整数。
      • 参数
        • a 双精度解析为64位无符号整数
      • 返回
        -　double类型转换结果　　　

    例子:

    1. uint64_t res = i64_to_double( 3 );
    2. printd(res); // Output: 3
    multeq_i128()

    > uint64_t multeq_i128(uint128_t self, const uint128_t other )

    将两个128位无符号整数相乘，并将该值赋给第一个参数。
    - 参数
    - self 指向要相乘的值的指针。它将被替换为结果
    - other 指向要相乘的值的指针。
    - 返回
    -　double类型转换结果　　　

    例子:

    c++ uint128_t self(100); uint128_t other(100); multeq_i128(&self, &other); printi128(self); // Output: 10000


    ## Math CPP API

    定义常用的数学函数和帮助器类型.

    Fixed Point
    1. 定点变量的32,64,128,256位版本
    Real number

    struct eosio::uint128


    封装了uint128整数并定义常见运算符重载的结构。

    void eosio::multeq (uint128_t& self, const uint128_t& other)
    void (uint128_t& self, const uint128_t& other)
    1.  封装了diveq_i128 Math C API。

    template

    T eosio::min (const T& a, const T& b)

    1.  定义了类似std::min()函数。

    template

    T (const T& a, const T& b)

    1.  定义了类似std::max()函数。

    diveq()

    void eosio::diveq (uint128_t& self,const uint128_t& other) | inline 

    1. 将两个128位无符号整数相除，并将该值赋给第一个参数。 如果other值为零，它将抛出异常。 封装了Math C API的diveq_i128
    • Parameters
      • self 分子. 它的值将被结果替代。
      • other 分母。
        示例:
        1. uint128_t self(100);
        2. uint128_t other(100);
        3. diveq(self, other);
        4. std::cout << self; // Output: 1

    max()

    template
    T eosio::max(const T& a,const T& b ) 

    1.     获取最大值。
    • 参数
      • a　比较值
      • b　比较值
    • 返回
      获取a和b中更大的一个. 如果相等返回a
      示例:
      1. uint128_t a(1);
      2. uint128_t b(2);
      3. std::cout << max(a, b); // Output: 2

    min()

    template
    T eosio::min(const T& a, const T& b) 

    1. 获取更小的一个值
    • 参数
      • a 比较值
      • b 比较值
    • 返回
      获取a和b中更小的一个. 如果相等返回a
      示例:
      1. uint128_t a(1);
      2. uint128_t b(2);
      3. std::cout << min(a, b); // Output: 1

    multeq()

    • 参数
      • self 相乘的值. 它的值将被结果替代。
      • other 相乘的值.
        示例:
        1. uint128_t self(100);
        2. uint128_t other(100);
        3. multeq(self, other);