Resets / Initializes the hash for the specified dimension.
778627
def reset(self, dim):
        
        if self.dim != dim:
            self.dim = dim
            self.normals = self.rand.randn(self.projection_count, dim)
128481
def reset
			self.clear
			me = self
			@default_values.each {|n,v| me[n] = v.is_a?(Class) ? nil : v}
		end
362188
void init() throws Throwable {
		if (this.digestAlgorithmName != null) {
			this.hashService.setHashAlgorithmName(this.digestAlgorithmName);
		}
		if (this.hashIterations > 0) {
			this.hashService.setHashIterations(this.hashIterations);
		}
	}
527633
function (hasher, key) {
            // Init hasher
            hasher = this._hasher = new hasher.init();

            // Convert string to WordArray, else assume WordArray already
            if (typeof key == 'string') {
                key = Utf8.parse(key);
            }

            // Shortcuts
            var hasherBlockSize = hasher.blockSize;
            var hasherBlockSizeBytes = hasherBlockSize * 4;

            // Allow arbitrary length keys
            if (key.sigBytes > hasherBlockSizeBytes) {
                key = hasher.finalize(key);
            }

            // Clamp excess bits
            key.clamp();

            // Clone key for inner and outer pads
            var oKey = this._oKey = key.clone();
            var iKey = this._iKey = key.clone();

            // Shortcuts
            var oKeyWords = oKey.words;
            var iKeyWords = iKey.words;

            // XOR keys with pad constants
            for (var i = 0; i < hasherBlockSize; i++) {
                oKeyWords[i] ^= 0x5c5c5c5c;
                iKeyWords[i] ^= 0x36363636;
            }
            oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;

            // Set initial values
            this.reset();
        }
658965
function init() {
    var stateFromHash = getStateFromHash();
    var stateChanged = false;

    if (typeof defaults === 'object' && defaults) {
      Object.keys(defaults).forEach(function(key) {
        if (key in stateFromHash) return;

        stateFromHash[key] = defaults[key]
        stateChanged = true;
      });
    }

    if (stateChanged) set(stateFromHash);
  }
864565
public void reset() {
        for (long i = 0; i < idCounter; i++) {
            localStorage.removeItem(key(i));
        }
        idCounter = 0;
        localStorage.removeItem(documentsKey());
        localStorage.removeItem(indexKey());

        resetInternal();
        Log.info("Reset index to " + indexKey());
    }
1090673
protected void reset() {
    attributeStatics = new StringBuilder();
    functionGroupStatics = new StringBuilder();
    properties = new StringBuilder();
    constructor = new StringBuilder();
    gettersSetters = new StringBuilder();
    equals = new StringBuilder();
    hashCode = new StringBuilder();
    toString = new StringBuilder();
    footer = new StringBuilder();
  }
963768
def init_with_hash(hash)
      @tuple = Hash.new
      hash.each do |k, v|
        raise InvalidHashTupleKey unless String === k
        @tuple[k] = v
      end
    end
1330573
public void reset()
    {
        this.bufferSize = 0;
        this.bufferPos = 0;
        this.bufferSizeAfterLimit = 0;
        this.currentLimit = Integer.MAX_VALUE;
        this.lastTag = 0;
        this.packedLimit = 0;
        this.sizeLimit = DEFAULT_SIZE_LIMIT;
        resetSizeCounter();
    }
254707
public void reset() {
    n_ = 0;
    combinedBufferItemCapacity_ = 2 * Math.min(DoublesSketch.MIN_K, k_); //the min is important
    combinedBuffer_ = new Object[combinedBufferItemCapacity_];
    baseBufferCount_ = 0;
    bitPattern_ = 0;
    minValue_ = null;
    maxValue_ = null;
  }
357002
private void increaseAndReset() {
		if (this.hashSize < 30) {
			this.hashSize += 1;
			this.hashfunctions.clear();
			for (List<Entry<T>> table : this.tables) {
				this.hashfunctions.add(new DietzfelbingerHash(this.hashSize,
						this.random));
				((ArrayList<Entry<T>>) table)
						.ensureCapacity(1 << this.hashSize);
			}
		} else {
			this.hashfunctions.add(new DietzfelbingerHash(this.hashSize,
					this.random));
			this.tables.add(new ArrayList<Entry<T>>(1 << this.hashSize));
			this.numTables++;
		}
		reset();
	}
864658
public void reset() {
        this.table = this.hashTable.getTable();
        this.length = this.table.length;
        this.entry = null;
        this.row = 0;
    }
1069209
def initialize_for_speed(hash)
      hash.each_pair do |k,v|
        key = key_as_sym(k)
        case v
          when Array
            value = v.map { |element| translate_value(element) }
            container.store(key, value)
          when Hash
            container.store(key, NestedResult.new(v))
          else
            container.store(key, v)
        end
      end
    end
258882
public void reset() {
        this.cacheHandler = null;
        this.pjp = null;
        this.cacheKey = null;
        this.cache = null;
        this.autoLoadTO = null;
        this.arguments = null;
        this.cacheWrapper = null;
    }
1074053
public final void reset() {
    isNonMassSpectrum = false;
    curScan = null;
    defaultArrayLength = null;
    spectrumIndex = null;
    spectrumId = null;
    precursorSpectrumIndex = null;
    activationMethodAbbreviation = null;
    precursors = new ArrayList<>(1);
    precursorIsoWndTarget = null;
    precursorIsoWndLoOffset = null;
    precursorIsoWndHiOffset = null;
    precursorIntensity = null;

    offsetLo = null;
    offsetHi = null;
    length = null;

    precision = null;
    compressions = null;
    binDataType = null;
    mzData = null;
    intensityData = null;
    imData = null;
  }
934903
private void reset()
    {
        int count = 0;
        for (int i = 0; i < tableLength; i++)
        {
            long t = tableAt(i);
            count += Long.bitCount(t & ONE_MASK);
            tableAt(i, (t >>> 1) & RESET_MASK);
        }
        size = (size >>> 1) - (count >>> 2);
    }
379477
public void reset() {
    this.formatMode = null;
    this.roundMode = NumberRoundMode.ROUND;
    this.grouping = null;
    this.minimumIntegerDigits = null;
    this.maximumFractionDigits = null;
    this.minimumFractionDigits = null;
    this.maximumSignificantDigits = null;
    this.minimumSignificantDigits = null;
  }