reset the LinearAnalysis.pst attribute

        Parameters
        ----------
        arg : (str or matrix)
            the value to assign to the pst attribute
542078
def reset_pst(self,arg):
        
        self.logger.statement("resetting pst")
        self.__pst = None
        self.pst_arg = arg
262833
def p_param_args(self, p):
        ''
        p[0] = p[1] + (p[3],)
        p.set_lineno(0, p.lineno(1))
745065
def pstdev(data, mu=None):
    
    var = pvariance(data, mu)
    try:
        return var.sqrt()
    except AttributeError:
        return math.sqrt(var)
1324339
def set(self, **args) :
		""
		for k, v in args.items() :
			setattr(self, k, v)
86841
def p_instance_port_arg_none(self, p):
        ''
        p[0] = PortArg(p[2], None, lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
253338
def batch_normalize_with_arguments(x, arguments):
  
  x = prettytensor.wrap(x)
  # Backwards compatibility.
  if isinstance(arguments, bool):
    if arguments:
      return x.batch_normalize()
    else:
      return x

  # pylint: disable=protected-access
  kwargs = arguments._asdict()
  defaults = prettytensor._defaults
  # pylint: enable=protected-access
  for arg in ('learned_moments_update_rate', 'variance_epsilon',
              'scale_after_normalization'):
    if kwargs.get(arg, None) is None:
      if arg in defaults:
        kwargs[arg] = defaults[arg]
      else:
        del kwargs[arg]
  return x.batch_normalize(**kwargs)
1139133
def reset(self):
        """"""

        sun = ephem.Sun()
        this_time = Time(self.date.get(), scale='utc')
        sun.compute(this_time.iso)
        self.sun = Coord((sun.ra, sun.dec))

        self.doplot()
        self.plot_pointings()
541356
def update_mt_arg(self, metatabfile):
        """"""
        o = MetapackCliMemo(self.args)
        o.set_mt_arg(metatabfile)
        return o
778627
def reset(self, dim):
        
        if self.dim != dim:
            self.dim = dim
            self.normals = self.rand.randn(self.projection_count, dim)
1264975
def regweight_from_parbound(pst):
    

    pst.parameter_data.index = pst.parameter_data.parnme
    pst.prior_information.index = pst.prior_information.pilbl
    for idx, parnme in enumerate(pst.prior_information.pilbl):
        if parnme in pst.parameter_data.index:
            row = pst.parameter_data.loc[parnme, :]
            lbnd,ubnd = row["parlbnd"], row["parubnd"]
            if row["partrans"].lower() == "log":
                weight = 1.0 / (np.log10(ubnd) - np.log10(lbnd))
            else:
                weight = 1.0 / (ubnd - lbnd)
            pst.prior_information.loc[parnme, "weight"] = weight
        else:
            print("prior information name does not correspond" +\
                  " to a parameter: " + str(parnme))
348573
def remove_arg(self, arg):
        """"""

        self.args = [arg_.strip() for arg_ in self.args if arg_.strip()]

        for arg_ in list(self.args):
            if arg_.lower() == arg.lower():
                self.args.remove(arg_)
1358848
def reset(self, **kwargs):
        
        for key in kwargs:
            setattr(self, key, kwargs[key])
        self.command = self.COMMAND_RESET
696617
def set_args(self, **kwargs):
        
        try:
            kwargs_items = kwargs.iteritems()
        except AttributeError:
            kwargs_items = kwargs.items()
        for key, val in kwargs_items:
            self.args[key] = val
945542
def reset_parameters(self, init_weight):
        
        stdv = 1. / math.sqrt(self.num_units)
        self.linear_att.data.uniform_(-init_weight, init_weight)

        if self.normalize:
            self.normalize_scalar.data.fill_(stdv)
            self.normalize_bias.data.zero_()
1118069
def reset(self, dim):
        
        if self.dim != dim:
            self.dim = dim
            self.normals = self.rand.randn(self.projection_count, dim)
            self.tree_root = RandomBinaryProjectionTreeNode()
211627
def p_param_arg_exp(self, p):
        ''
        p[0] = ParamArg(p[2], p[4], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
830105
def reassign_arguments(self):
        """"""
        condition = (
            "variable-list" in self.arguments and
            "list-of-flags" not in self.arguments
        )
        if condition:
            self.arguments["list-of-flags"] = (
                self.arguments.pop("variable-list"))
            self.rargs_cnt = 1