If ``period`` is ``None``, remove all known values of the variable.

            If ``period`` is not ``None``, only remove all values for any period included in period (e.g. if period is "2017", values for "2017-01", "2017-07", etc. would be removed)
500402
def delete_arrays(self, period = None):
        

        self._memory_storage.delete(period)
        if self._disk_storage:
            self._disk_storage.delete(period)
881394
def clean_var(text):
    """"""
    text = re_invalid_var.sub('', text)
    text = re_invalid_start.sub('', text)
    return text
878487
function removeUserVals() {
        _.each(user, function reset(val, key) {
            if (!_.isFunction(val) && key !== 'initComplete') {
                user[key] = null;
            }
        });
    }
48942
def max(self, value):
        
        if value == self._defaults['max'] and 'max' in self._values:
            del self._values['max']
        else:
            self._values['max'] = value
244116
def remove_points_from_interval(self, start, end):
        
        for s, e, v in self.iterperiods(start, end):
            try:
                del self._d[s]
            except KeyError:
                pass
1318801
private void clearUnusedPrecision() {
        switch (_precision) {
            case YEAR:
                _month = 1;
            case MONTH:
                _day = 1;
            case DAY:
                _hour = 0;
                _minute = 0;
            case MINUTE:
                _second = 0;
                _fraction = null;
            case SECOND:
        }
    }
491777
def _pre_var(self, value):
        

        def sub_(m):
            return self._pre_variables.get(m.group()[2:-1].strip(), '')

        return r_pre_var.sub(sub_, value)
1270100
def remove_value(v)
      index = @values.index(v)
      if index
        return !@values.delete_at(index).nil?
      else
        return false
      end
    end
502656
def data(self, value):
        
        if value == self._defaults['data'] and 'data' in self._values:
            del self._values['data']
        else:
            self._values['data'] = value
1268214
def aroon_up(data, period):
    
    catch_errors.check_for_period_error(data, period)
    period = int(period)

    a_up = [((period -
            list(reversed(data[idx+1-period:idx+1])).index(np.max(data[idx+1-period:idx+1]))) /
            float(period)) * 100 for idx in range(period-1, len(data))]
    a_up = fill_for_noncomputable_vals(data, a_up)
    return a_up
1191998
def remove_all_instances(var)
      # Iterate though all the site configs, removing every instance of :var
      # Return an array containing the value of :var at each config,
      # from lowest priority to highest.
      # If [] is returned, it implies that there was no instancs of :var to be removed.
      ret = []
      configs.each do |c|
        if c.has_var?(var)
          ret << c.remove_var(var)
        end
      end
      ret
    end
254003
def clean(self, value):
        """"""
        if not isinstance(value, self.t):
            value = self.t(value)

        if not self.allow_negative and value < 0:
            raise ValueError('value was negative')

        if not self.allow_positive and value > 0:
            raise ValueError('values was positive')

        return value
24445
def var_unset(session, name):
        
        name = name.strip()
        try:
            session.unset(name)
        except KeyError:
            session.write_line("Unknown variable: {0}", name)
            return False
        else:
            session.write_line("Variable {0} unset.", name)

        return None
1096967
protected function _clear_var()
    {
        $this->field    = array();
        $this->limit    = '';
        $this->skip     = '';
        $this->where    = array();
        $this->orderby  = array();
        $this->data         = array();
    }
36488
protected function filterEmpty()
    {
        $vars = $this->toArray();
        foreach ($vars as $name => $value) {
            if (!strlen($value)) {
                unset($this->{$name});
            }
        }
    }
1128282
function delVars(origEnv, deleteVars) {
  var i;
  if (!Array.isArray(deleteVars))
    return;
  for (i = 0; i < deleteVars.length; i++) {
    if (!has(origEnv, deleteVars[i])) {
      origEnv[deleteVars[i]] = [
        !!has(process.env, deleteVars[i]),
        process.env[deleteVars[i]]
      ];
    }
    delete process.env[deleteVars[i]];
  }
  return;
}
474843
def _check_values(self, values):
        """"""
        assert isinstance(values, Iterable) and not isinstance(
            values, (str, dict, bytes, bytearray)), \
            'values should be a list or tuple. Got {}'.format(type(values))
        if self.header.analysis_period.is_annual:
            a_period_len = 8760 * self.header.analysis_period.timestep
            if self.header.analysis_period.is_leap_year is True:
                a_period_len = a_period_len + 24 * self.header.analysis_period.timestep
        else:
            a_period_len = len(self.header.analysis_period.moys)
        assert len(values) == a_period_len, \
            'Length of values does not match that expected by the '\
            'header analysis_period. {} != {}'.format(len(values), a_period_len)