• boost高质量随机数库 zhuan


    shared_ptr<int> tmp2(new int(10)) ;
    int * test=tmp2.get();
    std::cout<<*test<<" "<<*tmp2<<" "<< * ( (int*)( tmp2.get() ) );

    10 10 1011

    not 10 10 10

    why?

    一. 概念
    随机数被用在很多场合, 比如数值计算, 游戏, 加密, 测试.

    根据场合的不同, 需求的随机数发生器也不尽相同. 可以分为一下三种.

    non-deterministic random number generator 
    pseudo-random number generator 
    quasi-random number generator 

    [数字发生器{number generator)]

    一个数字发生器是一个函数对象, 对他直接调用operator()就可以.

    [随机数发生器(uniform random number generator)]

    基于数字发生器, 但是产生的是随机数. 可以通过has_fixed_range指定随机数
    是否该有产生范围, 可以通过min_value和max_value来指定随机数产生的范围界
    限.

    [非确定性随机数发生器(Non-deterministic Uniform Random Number Generator)] 

    这是真正的"随机数"发生器. 基本上没有可能在标准C++范围之内完成, 所以使
    用的random_device类的构造函数需要传入一个字符串来指明随机数发生设备的
    位置. 在很多unix下面,就是/dev/urandom.

    [伪随机数发生器(Pseudo-Random Number Generator)]

    基于随机数发生器. 通过特定的算法和内部状况, 产生确定性的伪随机数序列. 可以通过seed来设定种子.

    [Quasi-Random Number Generators(不知道怎么称呼)]

    实际上就是对于已知的随机数种子根据特定算法算出来的确定数组, 这在很多场
    合就足够的了.

    二. 使用
    random的文件组织相对复杂, 一般情况下, 直接包含random.hpp是最简单直接的办法.

    要声明一个generator来产生随机数, 比如boost::hellekalek1995 generator(13);
    boost::hellekalek1995是一个随机数产生器, 13是个随机数种子.

    然后声明一个随机数分布(uniform random number distribution)来产生随机数. 
    比如
    boost::uniform_smallint<boost::hellekalek1995> die_gen(generator,1, 6)

    然后就可以不停的读取die_gen, 比如
      std::cout << dir_gen() << std::endl;

    一个最简单的例子比如:

    #include <iostream>
    #include <boost/random.hpp>

    int main()
    {
            boost::hellekalek1995 generator(17);
            boost::uniform_smallint<boost::hellekalek1995> die_gen(generator, 1, 6);
            
            for( int i = 1; i <= 10; i++ )
            {
                    std::cout << die_gen() << std::endl;
            }
            
            return 0;
    }

    usidc5 2011-07-18 12:04
    传统随机数生成器的问题
    传统随机数生成器具有几个问题。它们无法生成在用户指定范围内均匀分布的随机数,或者符合高斯或二项式分布的随机数。本文仅在可将随机数映射到某个范围内的上下文中讨论随机数。


    Boost 随机数生成器位于 boost/random 文件夹中。此外,为方便起见,boost/ 目录中的 random.hpp 头文件包括了 boost/random 文件夹中的所有其他头文件。
    Boost 随机接口划分为两个部分:随机数生成器和随机数必须位于其中的分布。本文讨论 uniform_int 和 uniform_real random-number 分布以及 mt19937 随机数生成器。清单 11 使用了 uniform_int 和 uniform_real 分布。


    清单 11. 将 variate_generator 与 mt19937 引擎和 uniform_int 分布一起使用
                    
    #include <iostream>
    #include <boost/random.hpp>
    using namespace std;
    using namespace boost;


    int main ( )
      {
      uniform_int<> distribution(1, 100) ;
      mt19937 engine ;
      variate_generator<mt19937, uniform_int<> > myrandom (engine, distribution);


      for (int i=0; i<100; ++i)
        cout << myrandom() << endl;


      return 0;
      }


    此代码生成介于 1 和 100 之间(包括 1 和 100)的随机数;用于实现随机化的基础引擎是 mt19937。variate_generator 为您组合了该引擎和分布。
    清单 12 使用了另一个引擎: kreutzer1986.


    清单 12:组合 uniform_real 分布和 kreutzer1986 引擎
                    
    #include <iostream>
    #include <boost/random.hpp>
    using namespace std;
    using namespace boost;


    int main ( )
      {
      uniform_real<> distribution(1, 2) ;
      kreutzer1986 engine ;
      variate_generator<kreutzer1986, uniform_real<> > myrandom (engine, distribution);


      for (int i=0; i<100; ++i)
        cout << myrandom() << endl;


      return 0;
      }
              


    除了 uniform_int 和 uniform_real 分布以外,Boost 还提供了几个其他分布,包括二项式、泊松和正态分布。
    usidc5 2011-07-18 12:08

    随机单例的头文件如下

    #ifndef _RANDOMHELPER_H
    #define _RANDOMHELPER_H

    #include <boost/random.hpp>
    #include <ctime>
    #include <boost/pool/detail/singleton.hpp>
    using namespace boost;
    using boost::details::pool::singleton_default;

    template<typename T> class rng_wrapper//模板类型是随机数发生器
    {
    private:
        T rng;//随机数发生器成员变量
    public:
        rng_wrapper():rng((typename T::result_type)time(0))
        {
        }

        typename T::result_type operator()(const int &min,const int &max)//重载调用操作符
        {
            uniform_int<> ui(min,max);
            return ui(rng);
        }

        T GetEngine()
        {
            return rng;
        }
    };
    typedef singleton_default< rng_wrapper<mt19937> > rng_t;

    class RandomHelper
    {
    public:
        RandomHelper(){}
        static int Random(const int &min,const int &max)
        {
            rng_t::object_type &rng = rng_t::instance();        
            return rng(min,max);
        }
    };

    #endif
    调用示例如下:


    #include <iostream>


    #include "RandomHelper.h"
    using namespace std;

    int main(void)
    {    
        for(int i = 0; i < 100 ; i++)
        {        
            cout << RandomHelper::Random(1,100)<< endl;
        }    
        return 0;
    }
    欢迎大家多提意见,这里只是实现了整数的随机,其他各类的随机数,只需要修改对应的分布器即可。
    关于分布器,可以参考:
    http://laokaddk.blog.51cto.com/368606/323858

    usidc5 2011-07-18 12:16
    简介
    概览
    uniform_smallint 类模板
    uniform_int 类模板
    uniform_01 类模板
    uniform_real 类模板
    bernoulli_distribution 类模板
    geometric_distribution 类模板
    triangle_distribution 类模板
    exponential_distribution 类模板
    normal_distribution 类模板
    lognormal_distribution 类模板
    uniform_on_sphere 类模板
    简介
    除了 随机数生成器 之外,本库还提供了把一种分布 (通常是生成器产生的均匀分布) 映射到另一种分布的分布函数。(译注:在本节中,“分布”指统计学意义上的分布,而“分布函数”指的是类模板。内部的随机数生成器有时会更一般地被称为“随机数源”。)
    对于某一映射通常会有多种实现方案:有的需要较多的空间和对内部随机数源的调用,而有的需要进行较多的费时的运算 (如三角函数)。以下给出的对接口的描述是与具体实现无关的;然而,如果某一实现不能覆盖特定分布的全部值域,或者不符合该分布的统计学性质,该实现是无效的。
    分布    描述    实例
    uniform_smallint    在小整数集 (远小于内部生成器的值域) 上的离散均匀分布    罐中取物
    uniform_int    在整数集上的离散均匀分布;可能会多次调用内部生成器以获得足够多的“随机性”    罐中取物
    uniform_01    区间 [0,1) 上的连续均匀分布;此分布是其它分布的重要基础    -
    uniform_real    实数区间 [min, max) 上的连续均匀分布    随机投下一木棍,其偏转角的弧度数是 [0, 2pi) 上的这种分布 (假设偏转角的分布是均匀的)
    bernoulli_distribution    伯努利试验 (Bernoulli experiment):布尔离散分布,概率可配置    投掷硬币 (p=0.5)
    geometric_distribution    几何分布:重复伯努利试验,直到出现某一结果的试验次数    抛掷骰子,记录“6”首次出现时的试验次数
    triangle_distribution    ?    ?
    exponential_distribution    指数分布    放射性物质发射 alpha 粒子的间隔时间
    normal_distribution    无穷次重复伯努利试验的结果计数    投掷硬币 10000 次,记录正面出现的次数
    lognormal_distribution    对数正态分布 (lognormal distribution) (有时用于模拟)    流水线工人的工作完成时间
    uniform_on_sphere    任意给定维数空间的单位球面上的均匀分布    在地球 (近似看作是球体) 表面任选一点去旅游
    分布函数的模板参数总按照下列顺序排列:
    内部随机数源
    返回类型,其默认值为一合适的类型 (可能无这一参数)
    分布函数不再满足输入迭代器 (input iterator) 的需求 (std:24.1.1 [lib.input.iterators]),因为这对于生成器(Generator)接口来说是多余的,还会对所有用户带来运行时的开销。而且,一个诉诸于随机数生成的生成器接口更为"自然"。如果你需要把生成器包装进一个输入迭代器接口,可以使用 迭代器适配器(iterator adaptor)。
    下面描述的所有分布函数都保存对随机数源的一个非 const 引用;因此分布函数不是 Assignable;不过它们是 CopyConstructible。复制分布函数将会复制参数值;副本和原分布函数将会使用同一内部随机数源,因此两者会从同一序列中取得随机数。
    对于在 概念文档 中已经给出定义的成员,在下面的描述中不会详细说明。
    <boost/random.hpp> 中的分布:概览
    namespace boost {
      template<class IntType = int>
      class uniform_smallint;
      template<class IntType = int>
      class uniform_int;
      template<class RealType = double>
      class uniform_01;
      template<class RealType = double>
      class uniform_real;


      // discrete distributions
      template<class RealType = double>
      class bernoulli_distribution;
      template<class IntType = int>
      class geometric_distribution;


      // continuous distributions
      template<class RealType = double>
      class triangle_distribution;
      template<class RealType = double>
      class exponential_distribution;
      template<class RealType = double>
      class normal_distribution;
      template<class RealType = double>
      class lognormal_distribution;
      template<class RealType = double,
        class Cont = std::vector<RealType> >
      class uniform_on_sphere;
    }
    uniform_smallint 类模板
    概览
    #include <boost/random/uniform_smallint.hpp>


    template<class IntType = int>
    class uniform_smallint
    {
    public:
      typedef IntType input_type;
      typedef IntType result_type;
      static const bool has_fixed_range = false;
      uniform_smallint(IntType min, IntType max);
      result_type min() const;
      result_type max() const;
      void reset();
      template<class UniformRandomNumberGenerator>
      result_type operator()(UniformRandomNumberGenerator& urng);
    };
    描述
    分布函数 uniform_smallint 是 随机分布 的模型。每次调用都将返回在整数集 {min, min+1, min+2, ..., max} 上均匀分布的随机整数。它假设目的区间长度 (max-min+1) 比内部随机数源小得多,因此不考虑量子化 (quantization) 问题。
    令 rout=(max-min+1) 为目的区间 (或其长度),rbase 为随机数源的区间 (或其长度)。今要求产生一均匀分布,即 rout 中任意数 i 的理论概率为 pout(i) = 1/rout。类似地,内部随机数源产生 rbase 上的均匀分布,故有 pbase(i) = 1/rbase。令概率函数 pout_s(i) 描述 uniform_smallint 实际产生的分布函数。对 rout 中的各 i ,(pout_s(i)/pout(i) -1)2 的和应不大于 rout/rbase2 (rbase mod rout)(rout - rbase mod rout)。
    模板参数 IntType 应为一类整数的值类型。
    注记:上述和式是要求的分布函数 pout(i) 和实际产生的分布函数 pout_s(i) 中各数概率相对差的平方和。其值可由计算 (base_rng mod rout) 来得到,如下:令 r = rbase mod rout。rbase 上的基础分布被折叠到区间 rout 上。数字 i < r 快已被赋以基础分布的 (rbase div rout)+1 个数字,只剩下 (rbase div rout)。因此,对于 i < r,pout_s(i) = ((rbase div rout)+1) / rbase,而对于其它 i,pout_s(i) = (rbase div rout)/rbase。在以上求和公式中替换这一部分,可得到希望的结果。
    注记:(rbase mod rout)(rout - rbase mod rout) 的上限是 rout2/4。对于 rout3/(4*rbase2) 的相对量化误差的平方和的上限, 明智的方法是,要么选择一个满足 rbase > 10*rout2 的 rbase,要么确保 rbase 可被 rout 整除。
    成员
    uniform_smallint(IntType min, IntType max)
    效果:构造一 uniform_smallint 函子。min 和 max 分别为输出值域的上下界。
    uniform_int 类模板
    概览
    #include <boost/random/uniform_int.hpp>


    template<class IntType = int>
    class uniform_int
    {
    public:
      typedef IntType input_type;
      typedef IntType result_type;
      static const bool has_fixed_range = false;
      explicit uniform_int(IntType min = 0, IntType max = 9);
      result_type min() const;
      result_type max() const;
      void reset();
      template<class UniformRandomNumberGenerator>
      result_type operator()(UniformRandomNumberGenerator& urng);
      template<class UniformRandomNumberGenerator>
      result_type operator()(UniformRandomNumberGenerator& urng, result_type n);
    };
    描述
    分布函数 uniform_int 是 随机分布 的模型。每次调用都将返回在整数集 {min, min+1, min+2, ..., max} 上均匀分布的随机整数。
    模板参数 IntType 应为一类整数的值类型。
    成员
        uniform_int(IntType min = 0, IntType max = 9)
    需求: min <= max
    效果:构造一 uniform_int 对象。min 和 max 为分布的参数。
        result_type min() const
    返回:分布的 "min" 参数。
        result_type max() const
    返回:分布的 "max" 参数。
        result_type operator()(UniformRandomNumberGenerator& urng, result_type n)
    返回:在值域 0 <= x < n 内均匀分布的随机数 x。[注记:可以将一个带有 uniform_int 分布的 variate_generator 对象用于 std::random_shuffe,请见 [lib.alg.random.shuffle]. ]
    uniform_01 类模板
    概览
    #include <boost/random/uniform_01.hpp>


    template<class UniformRandomNumberGenerator, class RealType = double>
    class uniform_01
    {
    public:
      typedef UniformRandomNumberGenerator base_type;
      typedef RealType result_type;
      static const bool has_fixed_range = false;
      explicit uniform_01(base_type rng);
      result_type operator()();
      result_type min() const;
      result_type max() const;
    };
    描述
    分布函数 uniform_01 是 随机分布 的模型。每次调用都将返回在区间 [0...1) 上均匀分布的随机浮点数。这一数值是用 std::numeric_limits<RealType>::digits 个随机二进制位构造而成的,也即浮点数的尾数全都是随机的二进制位。[注记:是否要使这一行为可配置?]
    警告:因为偶然的历史原因,此类的构造函数取一 UniformRandomNumberGenerator,且 传值。通常需要的是引用语义,从而生成器可以被“就地”地修改;如果需要引用语义,用引用类型作为 UniformRandomNumberGenerator 的模板参数。
    模板参数 RealType 应为一类浮点的值类型,支持双目运算符 +, - 和 /。rng.max()-rng.min()+1 的值必须在其可表示范围内。
    base_type::result_type 必须为一类数字的值类型,必须支持到 RealType 的 static_cast<>和双目运算符 -。
    注意:当前的实现是有 bug 的,因为在某些情况下不会把尾数全部填充为随机的二进制位。目前尚不知道如何把 (未实现的) boost::bigfloat 类有效地用随机位填满。可能需要一个 traits 类。
    成员
    explicit uniform_01(base_type rng)
    效果:构造一 uniform_01 函子,使用给定的随机数生成器作为内部随机数源。
    uniform_real 类模板
    概览
    #include <boost/random/uniform_real.hpp>


    template<class RealType = double>
    class uniform_real
    {
    public:
      typedef RealType input_type;
      typedef RealType result_type;
      static const bool has_fixed_range = false;
      uniform_real(RealType min = RealType(0), RealType max = RealType(1));
      result_type min() const;
      result_type max() const;
      void reset();
      template<class UniformRandomNumberGenerator>
      result_type operator()(UniformRandomNumberGenerator& urng);
    };
    描述
    分布函数 uniform_real 是 随机分布 的模型。每次调用都将返回在区间 [min..max) 上均匀分布的随机浮点数。这一数值是用 std::numeric_limits<RealType>::digits 个随机二进制位构造而成的,也即浮点数的尾数全都是随机的二进制位。
    注意:当前的实现是有 bug 的,因为在某些情况下不会把尾数全部填充为随机的二进制位。
    成员
        uniform_real(RealType min = RealType(0), RealType max = RealType(1))
    需求: min <= max
    效果:构造一 uniform_real 对象。min 和 max 是分布的参数。
        result_type min() const
    返回:分布的 "min" 参数。
        result_type max() const
    返回:分布的 "max" 参数。
    bernoulli_distribution 类模板
    概览
    #include <boost/random/bernoulli_distribution.hpp>


    template<class RealType = double>
    class bernoulli_distribution
    {
    public:
      typedef int input_type;
      typedef bool result_type;


      explicit bernoulli_distribution(const RealType& p = RealType(0.5));
      RealType p() const;
      void reset();
      template<class UniformRandomNumberGenerator>
      result_type operator()(UniformRandomNumberGenerator& urng);
    };
    描述
    bernoulli_distribution 类模板的实例是 随机分布 的模型。此分布产生 bool 值,概率满足 P(true) = p 且 P(false) = 1-p。p 是分布的参数。
    成员
        bernoulli_distribution(const RealType& p = RealType(0.5))
    需求: 0 <= p <= 1
    效果:构造一 bernoulli_distribution 对象。p 是分布的参数。
        RealType p() const
    返回:分布的 "p" 参数。
    geometric_distribution 类模板
    概览
    #include <boost/random/geometric_distribution.hpp>


    template<class UniformRandomNumberGenerator, class IntType = int>
    class geometric_distribution
    {
    public:
      typedef RealType input_type;
      typedef IntType result_type;


      explicit geometric_distribution(const RealType& p = RealType(0.5));
      RealType p() const;
      void reset();
      template<class UniformRandomNumberGenerator>
      result_type operator()(UniformRandomNumberGenerator& urng);
    };
    描述
    geometric_distribution 类模板的实例是 随机分布 的模型。对整数 i >= 1,产生 i 的概率 p(i) = (1-p) * pi-1,其中 p 是分布的参数。对 UniformRandomNumberGenerator 的每次调用应产生在 [0,1) 上均匀分布的浮点数。
    成员
        geometric_distribution(const RealType& p = RealType(0.5))
    需求: 0 < p < 1
    效果:构造一 geometric_distribution 对象。p 是分布的参数。
       RealType p() const
    返回:分布的 "p" 参数。
    triangle_distribution 类模板
    概览
    #include <boost/random/triangle_distribution.hpp>


    template<class RealType = double>
    class triangle_distribution
    {
    public:
      typedef RealType input_type;
      typedef RealType result_type;
      triangle_distribution(result_type a, result_type b, result_type c);
      result_type a() const;
      result_type b() const;
      result_type c() const;
      void reset();
      template<class UniformRandomNumberGenerator>
      result_type operator()(UniformRandomNumberGenerator& urng);
    };
    描述
    triangle_distribution 类模板的实例是 随机分布 的模型。返回的浮点数 x 满足 a <= x <= c; x 服从三角形分布 (triangle distribution),其中 b 为密度最大的点。对 UniformRandomNumberGenerator 的每次调用应产生在 [0,1) 上均匀分布的浮点数。
    成员
    triangle_distribution(result_type a, result_type b, result_type c)
    效果:构造一 triangle_distribution 函子。a, b, c 是分布的参数。
    exponential_distribution 类模板
    概览
    #include <boost/random/exponential_distribution.hpp>


    template<class RealType = double>
    class exponential_distribution
    {
    public:
      typedef RealType input_type;
      typedef RealType result_type;
      explicit exponential_distribution(const result_type& lambda);
      RealType lambda() const;
      void reset();
      template<class UniformRandomNumberGenerator>
      result_type operator()(UniformRandomNumberGenerator& urng);
    };
    描述
    exponential_distribution 类模板的实例是 随机分布 的模型。对实数 x > 0,其密度 p(x) = lambda * exp(-lambda * x),其中 lambda 是分布的参数。对 UniformRandomNumberGenerator 的每次调用应产生在 [0,1) 上均匀分布的浮点数。
    成员
        exponential_distribution(const result_type& lambda = result_type(1))
    需求: lambda > 0
    效果:构造一 exponential_distribution 对象。lambda 是分布的参数。
        RealType lambda() const
    返回:分布的 "lambda" 参数。
    normal_distribution 类模板
    概览
    #include <boost/random/normal_distribution.hpp>


    template<class RealType = double>
    class normal_distribution
    {
    public:
      typedef RealType input_type;
      typedef RealType result_type;
      explicit normal_distribution(const result_type& mean = 0,
                                   const result_type& sigma = 1);
      RealType mean() const;
      RealType sigma() const;
      void reset();
      template<class UniformRandomNumberGenerator>
      result_type operator()(UniformRandomNumberGenerator& urng);
    };
    描述
    normal_distribution 类模板的实例是 随机分布 的模型。对任意实数 x,其密度 p(x) = 1/sqrt(2*pi*sigma) * exp(- (x-mean)2 / (2*sigma2) ),其中 mean 和 sigma 是分布的参数。对 UniformRandomNumberGenerator 的每次调用应产生在 [0,1) 上均匀分布的浮点数。
    成员
        explicit normal_distribution(const result_type& mean = 0,
                                     const result_type& sigma = 1);
    需求: sigma > 0
    效果:构造一 normal_distribution。mean 和 sigma 是分布的参数。
        RealType mean() const
    返回:分布的 "mean" 参数。
        RealType sigma() const
    返回:分布的 "sigma" 参数。
    lognormal_distribution 类模板
    概览
    #include <boost/random/lognormal_distribution.hpp>


    template<class RealType = double>
    class lognormal_distribution
    {
    public:
      typedef typename normal_distribution<RealType>::input_type
      typedef RealType result_type;
      explicit lognormal_distribution(const result_type& mean = 1.0,
                                      const result_type& sigma = 1.0);
      RealType& mean() const;
      RealType& sigma() const;                                 
      void reset();
      template<class UniformRandomNumberGenerator>
      result_type operator()(UniformRandomNumberGenerator& urng);
    };
    描述
    lognormal_distribution 类模板的实例是 随机分布 的模型。对实数 x > 0,其密度 p(x) = 1/(x * normal_sigma * sqrt(2*pi)) * exp( -(log(x)-normal_mean)2 / (2*normal_sigma2) ),其中 normal_mean = log(mean2/sqrt(sigma2 + mean2)) 且 normal_sigma = sqrt(log(1 + sigma2/mean2))。对 UniformRandomNumberGenerator 的每次调用应产生在 [0,1) 上均匀分布的浮点数。
    成员
    lognormal_distribution(const result_type& mean,
                           const result_type& sigma)
    效果:构造一 lognormal_distribution 函子。mean 和 sigma 是分布的参数。
    uniform_on_sphere 类模板
    概览
    #include <boost/random/uniform_on_sphere.hpp>


    template<class RealType = double,
      class Cont = std::vector<RealType> >
    class uniform_on_sphere
    {
    public:
      typedef RealType input_type;
      typedef Cont result_type;
      explicit uniform_on_sphere(int dim = 2);
      void reset();
      template<class UniformRandomNumberGenerator>
      const result_type & operator()(UniformRandomNumberGenerator& urng);
    };
    描述
    uniform_on_sphere 类模板的实例是 随机分布 的模型。这一分布产生在 dim 维空间的单位球面上均匀分布的随机坐标。模板参数 Cont 应为一类 STL 的容器,其 begin 和 end 返回 Cont::iterator 类型的非 const 前向迭代器 (non-const forward iterator)。对 UniformRandomNumberGenerator 的每次调用应产生在 [0,1) 上均匀分布的浮点数。
    成员
    explicit uniform_on_sphere(int dim = 2)
    效果:构造一 uniform_on_sphere 函子。dim 是空间的维度。



    代码实例:



    #include "boost/scoped_ptr.hpp"
    #include <boost/foreach.hpp>
    #include <string>
    #include <iostream>
    #include <vector>
    #include <list>
    #include <deque>
    #include <boost/array.hpp>
    #include <boost/random.hpp>
    #include "boost/weak_ptr.hpp"

    uniform_int<> distribution(1, 100) ;
    mt19937 engine ;
    int iCount = 0;
    variate_generator<mt19937, uniform_int<> > myrandom (engine, distribution);
    for (int i=0; i<100; ++i)
    {
      iCount =  myrandom() ;
      TRACE("%d ",iCount);
    }

  • 相关阅读:
    我觉得 一个 单片机 代码 程序猿 连一个链表都不会写的 话 ,太说不过去了 ,学习 一下
    peripheralStateNotificationCB
    SimpleProfile_GetParameter && SimpleProfile_SetParameter
    performPeriodicTask
    如何在IAR工程中创建和使用模板
    英语 单词 收集
    KD-树(下)
    KD-树(上)
    KNN
    命令方式联网与界面network-manager方式联网
  • 原文地址:https://www.cnblogs.com/huashiyiqike/p/3878084.html
Copyright © 2020-2023  润新知