Reset the internal state of the triangulator
9925
public void reset() {
		while (holes != null) {
			holes = freePointBag(holes);
		}

		contour.clear();
		holes = null;
	}
539621
def reset(self):
        """"""
        self.alpha_ = np.zeros(self._size, dtype=int)
        self.beta_ = np.zeros(self._size, dtype=int)
        self.theta_ = np.empty(self._size, dtype=float)
        if self.store_variance:
            self.var_theta_ = np.empty(self._size, dtype=float)
        if self.store_wp:
            self.theta_wp_ = np.empty(self._size, dtype=float)

        self._calc_theta()
        if self.store_variance:
            self._calc_var_theta()
938170
public void reset() {
		square = null;
		touch = null;
		center.set(-1,-1);
		largestSide = 0;
		smallestSide = Double.MAX_VALUE;
		graph = RESET_GRAPH;
		for (int i = 0; i < edges.length; i++) {
			if ( edges[i] != null )
				throw new RuntimeException("BUG!");
			sideLengths[i] = 0;
		}
	}
877234
public static void clearUnwalkableTriangles(Context ctx, float walkableSlopeAngle, float[] verts, int nv,
            int[] tris, int nt, int[] areas) {
        float walkableThr = (float) Math.cos(walkableSlopeAngle / 180.0f * Math.PI);

        float norm[] = new float[3];

        for (int i = 0; i < nt; ++i) {
            int tri = i * 3;
            calcTriNormal(verts, tris[tri], tris[tri + 1], tris[tri + 2], norm);
            // Check if the face is walkable.
            if (norm[1] <= walkableThr)
                areas[i] = RC_NULL_AREA;
        }
    }
850973
def reset(self):
		
		self.gametree = self.game
		self.nodenum = 0
		self.index = 0
		self.stack = []
		self.node = self.gametree[self.index]
		self._setChildren()
		self._setFlags()
313450
void reset() {
        cd = initCd;
        serializer = initSerializer;
        in.position(initPosition);
        finalPosition = initFinalPosition;
        offset = initOffset;
    }
1305101
def reset(cls, *args, **kwargs):
        """"""
        cls.local.tchannel = None
        cls.args = None
        cls.kwargs = None
        cls.prepared = False
1108394
def reset(self):
        
        super(DruckSampler, self).reset()
        self.strata.reset()
        self._TP_st = np.zeros([self.strata.n_strata_, self._n_class])
        self._PP_st = np.zeros([self.strata.n_strata_, self._n_class])
        self._P_st = np.zeros([self.strata.n_strata_, self._n_class])
        self._TP_rates = np.zeros([self.strata.n_strata_, self._n_class])
        self._PP_rates = np.zeros([self.strata.n_strata_, self._n_class])
        self._P_rates = np.zeros([self.strata.n_strata_, self._n_class])

        for k in self.strata.indices_:
            for i in range(2):
                self._iterate(fixed_stratum = k, calc_rates = False)
13867
@Override
    public final void reset()
    {
        m_currentCodepoint_ = 0;
        m_nextCodepoint_    = 0;
        m_nextIndex_        = 0;
        m_nextBlock_ = m_trie_.m_index_[0] << Trie.INDEX_STAGE_2_SHIFT_;
        if (m_nextBlock_ == m_trie_.m_dataOffset_) {
            m_nextValue_ = m_initialValue_;
        }
        else {
            m_nextValue_ = extract(m_trie_.getValue(m_nextBlock_));
        }
        m_nextBlockIndex_ = 0;
        m_nextTrailIndexOffset_ = TRAIL_SURROGATE_INDEX_BLOCK_LENGTH_;
    }
666516
public void reset() {
		gsStack.removeAllElements();
		gsStack.add(new GraphicsState());
		textMatrix = null;
		textLineMatrix = null;
		resources = new DictionaryStack();
	}
658448
def reset(self):
        '''
        
        '''
        self.initializeSim()
        self.aLvlNow = self.kInit*np.ones(self.AgentCount) # Start simulation near SS
        self.aNrmNow = self.aLvlNow/self.pLvlNow
1099003
function reset() {
         this.resetTransform();
         this.setBlendMode(this.settings.blendMode);
         this.setColor("#000000");
         this.currentTint.setColor(255, 255, 255, 1.0);
         this.cache.clear();
         this.currentScissor[0] = 0;
         this.currentScissor[1] = 0;
         this.currentScissor[2] = this.backBufferCanvas.width;
         this.currentScissor[3] = this.backBufferCanvas.height;
         this.updateBounds();
       }
41434
def _reset(self):
    
    self.basis = np.random.randn(self.filterDim, self.outputDim)
    self.basis /= np.sqrt(np.sum(self.basis ** 2, axis=0))
    self._iteration = 0
    self.losses = {}
286777
def reset(self) -> None:
        
        self.evaluating = set()
        self.assumptions = {}
        self.known_results = {}
        self.current_node = None
        self.evaluate_stack = []
        self.bnode_map = {}
1111189
def reset(self):
        """"""
        import tqdm
        self.iter = 0
        self.pbar = tqdm.tqdm(total=self.niter, **self.kwargs)
76608
public void reset() {
        base.reset();
        graphics.projection.reset();
        baseGrid.setBase(base);

        if (graphics.projection instanceof Projection3D) {
            ((Projection3D) graphics.projection).setDefaultView();
        }

        canvas.repaint();    
    }
286498
function reset() {
         this.sbIndex = 0;
         this.length = 0;
         var samplers = []; // WebGL context

         this.gl = this.renderer.gl;

         for (var i = 0; i < this.maxTextures; i++) {
           this.units[i] = false;
           samplers[i] = i;
         } // set the quad shader as the default program


         this.useShader(this.quadShader);
         this.quadShader.uniforms.uSampler = samplers;
       }