精华内容
下载资源
问答
  • 时间序列分析之ADF检验

    万次阅读 多人点赞 2019-02-06 18:59:09
    The Augmented Dickey-Fuller test can be used to test for a unit root in a univariate process in the presence of serial correlation. Parameters ---------- x : array_like, 1d data series maxlag ...

    ADF检验

    在使用很多时间序列模型的时候,如 ARMA、ARIMA,都会要求时间序列是平稳的,所以一般在研究一段时间序列的时候,第一步都需要进行平稳性检验,除了用肉眼检测的方法,另外比较常用的严格的统计检验方法就是ADF检验,也叫做单位根检验

    ADF检验全称是 Augmented Dickey-Fuller test,顾名思义,ADF是 Dickey-Fuller检验的增广形式。DF检验只能应用于一阶情况,当序列存在高阶的滞后相关时,可以使用ADF检验,所以说ADF是对DF检验的扩展。

    单位根(unit root)

    在做ADF检验,也就是单位根检验时,需要先明白一个概念,也就是要检验的对象——单位根。

    当一个自回归过程中:y_{t} = by_{t-1} + a + \epsilon _{t} ,如果滞后项系数b为1,就称为单位根。当单位根存在时,自变量和因变量之间的关系具有欺骗性,因为残差序列的任何误差都不会随着样本量(即时期数)增大而衰减,也就是说模型中的残差的影响是永久的。这种回归又称作伪回归。如果单位根存在,这个过程就是一个随机漫步(random walk)。

    ADF检验的原理

    ADF检验就是判断序列是否存在单位根:如果序列平稳,就不存在单位根;否则,就会存在单位根。

    所以,ADF检验的 H0 假设就是存在单位根,如果得到的显著性检验统计量小于三个置信度(10%,5%,1%),则对应有(90%,95,99%)的把握来拒绝原假设。

    ADF检验的python实现

    ADF检验可以通过python中的 statsmodels 模块,这个模块提供了很多统计模型。

    使用方法如下:

    导入adfuller函数

    from statsmodels.tsa.stattools import adfuller

    adfuller函数的参数意义分别是:

    1. x:一维的数据序列。
    2. maxlag:最大滞后数目。
    3. regression:回归中的包含项(c:只有常数项,默认;ct:常数项和趋势项;ctt:常数项,线性二次项;nc:没有常数项和趋势项)
    4. autolag:自动选择滞后数目(AIC:赤池信息准则,默认;BIC:贝叶斯信息准则;t-stat:基于maxlag,从maxlag开始并删除一个滞后直到最后一个滞后长度基于 t-statistic 显著性小于5%为止;None:使用maxlag指定的滞后)
    5. store:True  False,默认。
    6. regresults:True 完整的回归结果将返回。False,默认。

    返回值意义为:

    1. adf:Test statistic,T检验,假设检验值。
    2. pvalue:假设检验结果。
    3. usedlag:使用的滞后阶数。
    4. nobs:用于ADF回归和计算临界值用到的观测值数目。
    5. icbest:如果autolag不是None的话,返回最大的信息准则值。
    6. resstore:将结果合并为一个dummy。
    def adfuller(x, maxlag=None, regression="c", autolag='AIC',
                 store=False, regresults=False):
        """
        Augmented Dickey-Fuller unit root test
    
        The Augmented Dickey-Fuller test can be used to test for a unit root in a
        univariate process in the presence of serial correlation.
    
        Parameters
        ----------
        x : array_like, 1d
            data series
        maxlag : int
            Maximum lag which is included in test, default 12*(nobs/100)^{1/4}
        regression : {'c','ct','ctt','nc'}
            Constant and trend order to include in regression
    
            * 'c' : constant only (default)
            * 'ct' : constant and trend
            * 'ctt' : constant, and linear and quadratic trend
            * 'nc' : no constant, no trend
        autolag : {'AIC', 'BIC', 't-stat', None}
            * if None, then maxlag lags are used
            * if 'AIC' (default) or 'BIC', then the number of lags is chosen
              to minimize the corresponding information criterion
            * 't-stat' based choice of maxlag.  Starts with maxlag and drops a
              lag until the t-statistic on the last lag length is significant
              using a 5%-sized test
        store : bool
            If True, then a result instance is returned additionally to
            the adf statistic. Default is False
        regresults : bool, optional
            If True, the full regression results are returned. Default is False
    
        Returns
        -------
        adf : float
            Test statistic
        pvalue : float
            MacKinnon's approximate p-value based on MacKinnon (1994, 2010)
        usedlag : int
            Number of lags used
        nobs : int
            Number of observations used for the ADF regression and calculation of
            the critical values
        critical values : dict
            Critical values for the test statistic at the 1 %, 5 %, and 10 %
            levels. Based on MacKinnon (2010)
        icbest : float
            The maximized information criterion if autolag is not None.
        resstore : ResultStore, optional
            A dummy class with results attached as attributes
        """

     现在我们用一个RB1309的收盘数据来进行ADF检验,看一下结果:

    result = adfuller(rb_price)
    print(result)
    
    
    (-0.45153867687808574, 0.9011315454402649, 1, 198, {'5%': -2.876250632135043, '1%': -3.4638151713286316, '10%': -2.574611347821651}, 1172.4579344852016)
    

    看到 t-statistic 的值 -0.451 要大于10%,所以无法拒绝原假设,另外,p-value的值也很大。

    将数据进行一阶差分滞后,看一下结果如何:

    rb_price = np.diff(rb_price)
    result = adfuller(rb_price)
    print(result)
    
    (-15.436034211511204, 2.90628134201655e-28, 0, 198, {'5%': -2.876250632135043, '1%': -3.4638151713286316, '10%': -2.574611347821651}, 1165.1556545612445)

     看到 t-statistic 的值 -15 要小于5%,所以拒绝原假设,另外,p-value的值也很小。

     

    展开全文
  • Burner control unit BCU 370

    2018-04-27 00:17:23
    • Simple system set-up thanks to optional tightness control and integrated ignition unit • Easy start-up and maintenance thanks to Manual operating mode • Optionally available with integral field ...
  • 什么是std::optional? C++17中新引入了std::optional<T>。类模板std::optional管理一个可选的容纳值。简单说来,std::optional就是一个和类型,常见的用处就是作为函数返回值来处理一个可能失败的函数。 如何...

    什么是std::optional?

    C++17中新引入了std::optional<T>。类模板std::optional管理一个可选的容纳值。简单说来,std::optional就是一个和类型,常见的用处就是作为函数返回值来处理一个可能失败的函数。

    如何处理无参返回?

    此前处理无参返回的函数一般有两种方式。

    第一种:

    bool foo(int param1, int*param2);

    返回参数作为引用/指针型输入参数而存在,传入地址,在执行完毕后访问指定地址得到返回值,而使用真正的返回值来作为函数是否成功的返回。
    这种方式可以实现需求。
    缺点是:

    1. 浪费存储空间——无论是否返回值,都需要做好有值的准备,param2的空间需要事先分配
    2. 可读性/可用性差——同为参数,有的是输入参,有的是输出参,即使以名字取分,使用的时候也比较困难。

    第二种:

    std::pair<T,bool>foo(int param1);

    这是比较常用的方式,解决了问题2——每次使用都知道返回值是pair的第一个值,第二个值专门用于成功与否的判断。
    不过std::optional继续优化了处理方式。

    正如前述,std::optional管理的是可选的容纳值。如果函数成功执行,则实例含值,如果执行失败,实例不含值。

    如何处理多参返回?

    这都不是个问题,classstruct,哪个都比直接放在一个tuple里面或者更过分的直接列在函数参数里面好。

    使用std::optional

    • 定义位置:<optional>
    • T:一个满足可析构的类型
    • 初始化:
      • 使用=用另一个T类型含值std::optional初始化
      • 使用构造函数初始化:以nullopt_t类型值或是T类型值
      • 默认构造函数
    • 是否含值:
      • 使用bool hasValue=temp.has_value()检查是否含值
    • 取值:
      • 使用(*temp)T即默认为T的指针
      • 使用temp.value()获取T
      • 使用temp.value_or()获取值(存在值)或者其他(不存在值)
    • 返回:
      • 一个T对象(非指针)
      • nullopt
      • {}
      • ...

    一个实例:

    //一个可析构类型
    class Test{
        int num1;
        int num2;
        Test(int n1,int n2){
            num1=n1;
            num2=n2;
        }
        bool isOK(){
            return num1+num2>=0?true:false;
        }
    }
    
    //一个可能执行失败的函数【有点草率,看看语法就好
    std::optional<Test>foo(int num){
        Test t(num,num);
        if(t.isOK()){
            //返回正常对象
            return t;
        }
        //返回空值
        return nullopt;
    }
    
    int main(){
        int myAge=20;
        //一种赋值方式
        std::optional<Test>opt=foo(myAge);
        //一种判断是否含值的方式
        if(opt.has_value()){
            //foo函数成功执行
            //一种取值方式
            cout<<(opt.value()).num1<<endl;
        }
    }
    

    Reference

    cppreference-std::optional 更多特性/支持的操作请访问
    C++17 新特性之 std::optional(上)更好地理解为何使用std::optional请访问

    转载于:https://www.cnblogs.com/riko707/p/11440664.html

    展开全文
  • DL之LSTM:tf.contrib.rnn.BasicLSTMCell(rnn_unit)函数的解读 目录 tf.contrib.rnn.BasicLSTMCell(rnn_unit)函数的解读 函数功能解读 函数代码实现 tf.contrib.rnn.BasicLSTMCell(rnn_unit)函数的解读...

    DL之LSTM:tf.contrib.rnn.BasicLSTMCell(rnn_unit)函数的解读

     

     

    目录

    tf.contrib.rnn.BasicLSTMCell(rnn_unit)函数的解读

    函数功能解读

    函数代码实现


     

     

    tf.contrib.rnn.BasicLSTMCell(rnn_unit)函数的解读

    函数功能解读

      """Basic LSTM recurrent network cell.

      The implementation is based on: http://arxiv.org/abs/1409.2329.

      We add forget_bias (default: 1) to the biases of the forget gate in order to reduce the scale of forgetting in the beginning of the training.

      It does not allow cell clipping, a projection layer, and does not use peep-hole connections: it is the basic baseline.  For advanced models, please use the full @{tf.nn.rnn_cell.LSTMCell}
      that follows.

      """

      def __init__(self,
                   num_units,
                   forget_bias=1.0,
                   state_is_tuple=True,
                   activation=None,
                   reuse=None,
                   name=None,
                   dtype=None):
        """Initialize the basic LSTM cell.

    基本LSTM递归网络单元。

    实现基于:http://arxiv.org/abs/1409.2329。

    我们在遗忘门的偏见中加入了遗忘偏见(默认值:1),以减少训练开始时的遗忘程度。

    它不允许细胞剪切(一个投影层),也不使用窥孔连接:它是基本的基线。对于高级模型,请使用完整的@{tf.n .rnn_cell. lstmcell}遵循。

     

        Args:
          num_units: int, The number of units in the LSTM cell.
          forget_bias: float, The bias added to forget gates (see above).
            Must set to `0.0` manually when restoring from CudnnLSTM-trained checkpoints.
          state_is_tuple: If True, accepted and returned states are 2-tuples of the `c_state` and `m_state`.  If False, they are concatenated along the column axis.  The latter behavior will soon be deprecated.
          activation: Activation function of the inner states.  Default: `tanh`.
          reuse: (optional) Python boolean describing whether to reuse variables in an existing scope.  If not `True`, and the existing scope already has the given variables, an error is raised.
          name: String, the name of the layer. Layers with the same name will share weights, but to avoid mistakes we require reuse=True in such cases.
          dtype: Default dtype of the layer (default of `None` means use the type of the first input). Required when `build` is called before `call`.

          When restoring from CudnnLSTM-trained checkpoints, must use `CudnnCompatibleLSTMCell` instead.
        """

    参数:
    num_units: int类型, LSTM单元中的单元数。
    forget_bias: float类型,偏见添加到忘记门(见上面)。
    从cudnnlstm训练的检查点恢复时,必须手动设置为“0.0”。
    state_is_tuple: 如果为真,则接受状态和返回状态是' c_state '和' m_state '的二元组。如果为假,则沿着列轴连接它们。后一种行为很快就会被摒弃。
    activation: 内部状态的激活功能。默认值tanh激活函数
    reuse: (可选)Python布尔值,描述是否在现有范围内重用变量。如果不是“True”,并且现有范围已经有给定的变量,则会引发错误。
    name:字符串,层的名称。具有相同名称的层将共享权重,但是为了避免错误,我们需要在这种情况下重用=True。
    dtype:该层的默认dtype(默认为‘None’意味着使用第一个输入的类型)。当' build '在' call '之前被调用时是必需的。

    从经过cudnnlstm训练的检查点恢复时,必须使用“CudnnCompatibleLSTMCell”。
    ”“”

     

    函数代码实现

    
    @tf_export("nn.rnn_cell.BasicLSTMCell")
    class BasicLSTMCell(LayerRNNCell):
      """Basic LSTM recurrent network cell.
    
      The implementation is based on: http://arxiv.org/abs/1409.2329.
    
      We add forget_bias (default: 1) to the biases of the forget gate in order to
      reduce the scale of forgetting in the beginning of the training.
    
      It does not allow cell clipping, a projection layer, and does not
      use peep-hole connections: it is the basic baseline.
    
      For advanced models, please use the full @{tf.nn.rnn_cell.LSTMCell}
      that follows.
      """
    
      def __init__(self,
                   num_units,
                   forget_bias=1.0,
                   state_is_tuple=True,
                   activation=None,
                   reuse=None,
                   name=None,
                   dtype=None):
        """Initialize the basic LSTM cell.
    
        Args:
          num_units: int, The number of units in the LSTM cell.
          forget_bias: float, The bias added to forget gates (see above).
            Must set to `0.0` manually when restoring from CudnnLSTM-trained
            checkpoints.
          state_is_tuple: If True, accepted and returned states are 2-tuples of
            the `c_state` and `m_state`.  If False, they are concatenated
            along the column axis.  The latter behavior will soon be deprecated.
          activation: Activation function of the inner states.  Default: `tanh`.
          reuse: (optional) Python boolean describing whether to reuse variables
            in an existing scope.  If not `True`, and the existing scope already has
            the given variables, an error is raised.
          name: String, the name of the layer. Layers with the same name will
            share weights, but to avoid mistakes we require reuse=True in such
            cases.
          dtype: Default dtype of the layer (default of `None` means use the type
            of the first input). Required when `build` is called before `call`.
    
          When restoring from CudnnLSTM-trained checkpoints, must use
          `CudnnCompatibleLSTMCell` instead.
        """
        super(BasicLSTMCell, self).__init__(_reuse=reuse, name=name, dtype=dtype)
        if not state_is_tuple:
          logging.warn("%s: Using a concatenated state is slower and will soon be "
                       "deprecated.  Use state_is_tuple=True.", self)
    
        # Inputs must be 2-dimensional.
        self.input_spec = base_layer.InputSpec(ndim=2)
    
        self._num_units = num_units
        self._forget_bias = forget_bias
        self._state_is_tuple = state_is_tuple
        self._activation = activation or math_ops.tanh
    
      @property
      def state_size(self):
        return (LSTMStateTuple(self._num_units, self._num_units)
                if self._state_is_tuple else 2 * self._num_units)
    
      @property
      def output_size(self):
        return self._num_units
    
      def build(self, inputs_shape):
        if inputs_shape[1].value is None:
          raise ValueError("Expected inputs.shape[-1] to be known, saw shape: %s"
                           % inputs_shape)
    
        input_depth = inputs_shape[1].value
        h_depth = self._num_units
        self._kernel = self.add_variable(
            _WEIGHTS_VARIABLE_NAME,
            shape=[input_depth + h_depth, 4 * self._num_units])
        self._bias = self.add_variable(
            _BIAS_VARIABLE_NAME,
            shape=[4 * self._num_units],
            initializer=init_ops.zeros_initializer(dtype=self.dtype))
    
        self.built = True
    
      def call(self, inputs, state):
        """Long short-term memory cell (LSTM).
    
        Args:
          inputs: `2-D` tensor with shape `[batch_size, input_size]`.
          state: An `LSTMStateTuple` of state tensors, each shaped
            `[batch_size, num_units]`, if `state_is_tuple` has been set to
            `True`.  Otherwise, a `Tensor` shaped
            `[batch_size, 2 * num_units]`.
    
        Returns:
          A pair containing the new hidden state, and the new state (either a
            `LSTMStateTuple` or a concatenated state, depending on
            `state_is_tuple`).
        """
        sigmoid = math_ops.sigmoid
        one = constant_op.constant(1, dtype=dtypes.int32)
        # Parameters of gates are concatenated into one multiply for efficiency.
        if self._state_is_tuple:
          c, h = state
        else:
          c, h = array_ops.split(value=state, num_or_size_splits=2, axis=one)
    
        gate_inputs = math_ops.matmul(
            array_ops.concat([inputs, h], 1), self._kernel)
        gate_inputs = nn_ops.bias_add(gate_inputs, self._bias)
    
        # i = input_gate, j = new_input, f = forget_gate, o = output_gate
        i, j, f, o = array_ops.split(
            value=gate_inputs, num_or_size_splits=4, axis=one)
    
        forget_bias_tensor = constant_op.constant(self._forget_bias, dtype=f.dtype)
        # Note that using `add` and `multiply` instead of `+` and `*` gives a
        # performance improvement. So using those at the cost of readability.
        add = math_ops.add
        multiply = math_ops.multiply
        new_c = add(multiply(c, sigmoid(add(f, forget_bias_tensor))),
                    multiply(sigmoid(i), self._activation(j)))
        new_h = multiply(self._activation(new_c), sigmoid(o))
    
        if self._state_is_tuple:
          new_state = LSTMStateTuple(new_c, new_h)
        else:
          new_state = array_ops.concat([new_c, new_h], 1)
        return new_h, new_state
    

     

    展开全文
  • <div><h3>Steps to ...<ol><li>I prepared a Showcase <a href="https://github.com/mscheibler/micronaut-httpclient-optional">project with a unit-test to demonstrate the issue</a>.</li><li>Run the <code>...
  • Java 8 新特性 | Optional解决空指针异常 日常开发中最常见的异常大概就是NullPointerException,因为我们写业务代码的时候经常不会去考虑这个对象为空,这个属性为空的情况。当测试告诉我们程序报错了,我们一看...

    日常开发中最常见的异常大概就是NullPointerException,因为我们写业务代码的时候经常不会去考虑这个对象为空,这个属性为空的情况。当测试告诉我们程序报错了,我们一看日志报错信息为空指针异常,然后就会恍然大悟,哦这里忘记加空值判断了,于是就会写if (face!=null)这样的代码去规避这样的问题。但是当出现对象包含对象的情况,这样的if判断会变得很冗余而且可维护性也差。Optional类就是为了解决这一系列问题的。

    Optional常用的一些方法

    1. // 返回一个Optionl包装的一个空实例 static <T> Optional<T> empty()

    2. // 根据特定条件返回一个 Optional实例 Optional<T> filter(Predicate<? super T> predicate)

    3. // 返回Optional实际表示的对象 T get()

    4. // 获取Optional保存的对象的各个属性值 <U> Optional<U> map(Function<? super T,? extends U> mapper)

    5. // 返回一个不为null的Optional对象 static <T> Optional<T> ofNullable(T value)

    6. // 配合5使用当获取到的实例是null时返回默认对象 T orElse(T other)

    7. // 配合5使用如果获取的是null时,获取一个特定对象 T orElseGet(Supplier<? extends T> other)

    8. // 配合5 使用如果为null时,抛出指定异常 <X extends Throwable> orElseThrow(Supplier<? extends X> exceptionSupplier)

    实战

    业务场景1

    一个小区中有很多楼栋,楼栋下面有很多的单元,单元下面有很多的楼层,楼层下面有很多的房间,而日常生活中我们在设计表格的时候,小区楼栋单元楼层房间都是维护在不同表格里面的,但是实际业务需求是为了准确知道某个房间的具体位置,一般定义房间名称时会是以xxxx小区-xx栋-xx单元-xx楼-xx号房间,这就需要去小区实体取小区名字,楼栋实体取楼栋名字等系列操作,完成以上需求有两张方案如下

    1. 传统方案

      // 小区名字
      String communityName 
      if(community !=null){
          communityName=community.getCommunityName();
      }
      // 楼栋名字
      String buildName 
      if(build !=null){
          buildName=build.getBulidName();
      }
      ..... 最后拼接字符串返回
      
    2. Java 8 方案

      // 小区名字
      String communityName =Optional.ofNullable(community).map(community -> community.getCommunityName()).orElse("*");
      // 楼栋名字
      String bName=Optional.ofNullable(build).map(build>build.getBuildingName()).orElse("*");
      // 单元名字
      String unitName = Optional.ofNullable(unit).map(unit -> unit.getUnitName()).orElse("*");
      // 楼层名字
      String floorName = Optional.ofNullable(basicBuildingUnitFloorByFloorId).map(floor -> floor.getFloorName()).orElse("*");
      // 房间名字
      String roomName = Optional.ofNullable(basicRoomByRoomId).map(room -> room.getRoomName()).orElse("*");
      // 返回拼接后的名字
      return sb.append(communityName).append("-").append(buildName).append("-").append(unitName).append("-").append(floorName).append("-").append(roomName).toString();
         }                         
      

    业务场景2

    常常会先获取到某个对象,然后获取这个对象的某个属性的值,map()可以很方便的完成这一需求而且十分优雅。

    1. // 获取组织结构对象
      EstateOrganization or =iEstateOrganiz.findOrganizationByName(e.getOrgId());
      // 将组织结构的Id值 赋予给用户
      user.setOrgId(Optional.ofNullable(or).map(organ->organ.getOrgId()).orElse("未知组织机构"));
      

    总结

    1. 传统方案代码冗余且不易维护。
    2. Java 8 优化后代码简洁明了,而且看起来十分的清爽优雅。
    展开全文
  • 前段时间因为做了音频的双功模式处理,使用系统的回音抑制以及降噪功能,使用了AudioQueue以及AudioUnit来处理,但是相比之下,还是比较喜欢AudioUnit的处理方式,简单易懂。 下面,我就为大家讲解一下具体的使用...
  • 团结单元测试助手 入门 这些说明将为您提供测试Solidity Dapp的有用帮助者。 先决条件 您需要安装软件什么东西以及如何安装它们: 。... [-S|--save|-D|--save-dev|-O|--save-optional|--no-save] a
  • 在Scala类型系统中,Null、Nothing、Nil、None、Unit这些类型看起来似乎都表达“空”的语义,但实际上很有一些区别,容易混淆。本文来简单分辨一下。 作为预热,可以先看看来自官方文档的class hierarc...
  • vue unit及e2e问题记录

    千次阅读 2017-11-09 14:57:53
    为了快速上手vue项目,一般我们会使用脚手架vue-cli帮助我们创建项目模板。 vue init webpack my-project // 创建 my-project项目 ... npm run unit // 启动单元测试 npm run e2e // 启动端到端测试 npm run bui
  • maven scope-provided 与 optional 区别

    千次阅读 2018-07-19 14:36:05
    今天遇到一个问题,整了我一上午,一个Spark项目,总是报错 package tests import org.apache.spark.sql.SparkSession /** * Created by lcc on 2018/7/19... def main(args: Array[String]): Unit = { val ...
  • Performance Monitor is an optional feature in ARMv8-A architecture. Performance Monitor in ARMv8-A includes a 64-bit cycle counter, a number of 32-bit event counters and control component.From ...
  • Spring Boot的单元测试(Unit Test)

    千次阅读 2017-07-19 14:56:55
    Optional<Client> client = clientRepository.findByName("Wang"); assertEquals("Wang", client.get().getName()); } } 测试JSON的序列化和反序列化,需要用@JsonTest RunWith(SpringRunner.class) @...
  • Unit Test naming convention

    2021-01-01 13:10:36
    - Naming of the unit tests should be [MethodActedUpon]When...Should....</code> where the part in []</code> is optional. <p>The above is just a first suggestion.</p><p>该提问来源于开源项目:...
  • JPA Persistence Unit

    千次阅读 2011-01-31 16:08:00
    JPA Persistence Unit A JPA Persistence Unit is a logical grouping of user defined persistable classes (entity classes, embeddable classes and mapped ...optional when using ObjectDB
  • title: ‘厘清Keras中的shape,unit,input_shape’ date: 2021-03-05 16:06:22 categories: TensorFlow tags: Keras TensorFlow 厘清Keras中的shape,unit,input_shape 新人(没错正是在下)在个性化Github上的...
  •  status = AudioUnitRender([iosAudio audioUnit], ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, &bufferList);  [iosAudio processAudio:&bufferList];  NSLog(@"%u", (unsigned int)buffer...
  • // ::country is named param ...: which make it optional // because we make ::country=? optional named param, we may pass in or may not pass in // we need use '()' --> (): string =&g...
  • TestApe - Unit testing for embedded software TestApe - Unit testing for embedded softwareAbout this siteWelcome - This site is TestAp...
  • Make I0MonitorIndex Optional

    2020-12-09 04:43:30
    <div><p>Fixes #15075. ...- Unit tests and System tests should pass - Tim Charlton should be given the opportunity to test this out</p><p>该提问来源于开源项目:mantidproject/mantid</p></div>
  • # 1 | required/optional | repeated | required_struct/optional_struct |   # | ------------------| ---------:| ---------------------------------:|   # 2 | 属性类型 | | 结构元素个数 ...
  • What is ConvertAll?...Why write another unit converter? There are plenty of them out there. Well, I couldn't find one that worked quite the way I wanted. With ConvertAll, you can combine the units a
  • def getMatchOption(name :String,contents:Map[String,String]): Unit ={ //采用的是Map Key 查 vale 的 情形 contents.get(name) match { case Some(values) => println("exists") case None => println("not ...
  • Kotlin Java 互通指南

    2018-08-07 07:26:22
    本文翻译自 Android Kotlin Guides 的 Interop Guide ,翻译项目地址为: ... ,欢迎关注及校正。 ...这是一组关于使用 Java 和 Kotlin 语言编写公共 API 的规则,... optionalString = nullableString.asOptional()...
  • Graphics processing unit

    千次阅读 2012-08-14 13:28:10
    as "the world's first 'GPU', or Graphics Processing Unit, a single-chip processor with integrated transform, lighting, triangle setup/clipping, and rendering engines that is capable of processing a ...
  • SIZE is an integer and optional unit (example: 10M is 10*1024*1024). Units are K, M, G, T, P, E, Z, Y (powers of 1024) or KB, MB, ... (powers of 1000). 使用色彩来区分文件类型的功能已被禁用,默认设置...
  • 流利说 Level 5 全文

    万次阅读 多人点赞 2019-05-22 10:53:33
    Unit 1 1/4 Listening Lesson 1 Jessica’s Class Reunion1-2 Vocabulary Lesson 3 Actions and Change Lesson 4 Types of Information Dialogue Lesson 5 A Customer Complaint 2/4 Listening L...
  • -m="": Memory limit (format: <number><optional unit>, where unit = b, k, m or g) -c=0 : CPU shares (relative weight) 通过docker run -m可以调整容器所使用的内存资源。如果主机支持swap内存,那么可以使用-m...
  • Using RemoteIO audio unit

    千次阅读 2011-08-24 14:31:35
    Using RemoteIO audio unit By MICHAEL TYSON | Published: NOVEMBER 4, 2008 I’ve had nasty old time trying to get some audio stuff

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,116
精华内容 8,446
关键字:

optionalunit