Update the vertex set #setnum with the data in *vertexData, sets have 0-based index
Conversions are not sopported so nvgraphTopologyType_t should match the graph structure
767829
public static int nvgraphSetVertexData(
        nvgraphHandle handle, 
        nvgraphGraphDescr descrG, 
        Pointer vertexData, 
        long setnum)
    {
        return checkResult(nvgraphSetVertexDataNative(handle, descrG, vertexData, setnum));
    }
598225
function update(nodes,mod) {
    if (!mod) mod = 0;
    nodes
      .attr("x",function(d){
        var w = d.d3plus.r ? d.d3plus.r*2 : d.d3plus.width;
        return (-w/2)-(mod/2);
      })
      .attr("y",function(d){
        var h = d.d3plus.r ? d.d3plus.r*2 : d.d3plus.height;
        return (-h/2)-(mod/2);
      })
      .attr("width",function(d){
        var w = d.d3plus.r ? d.d3plus.r*2 : d.d3plus.width;
        return w+mod;
      })
      .attr("height",function(d){
        var h = d.d3plus.r ? d.d3plus.r*2 : d.d3plus.height;
        return h+mod;
      })
      .attr("rx",function(d){
        var w = d.d3plus.r ? d.d3plus.r*2 : d.d3plus.width;
        var rounded = ["circle","donut"].indexOf(vars.shape.value) >= 0;
        return rounded ? (w+mod)/2 : 0;
      })
      .attr("ry",function(d){
        var h = d.d3plus.r ? d.d3plus.r*2 : d.d3plus.height;
        var rounded = ["circle","donut"].indexOf(vars.shape.value) >= 0;
        return rounded ? (h+mod)/2 : 0;
      })
      .attr("shape-rendering",function(d){
        if (["square"].indexOf(vars.shape.value) >= 0) {
          return vars.shape.rendering.value;
        }
        else {
          return "auto";
        }
      });
  }
402881
public static int nvgraphGetVertexData(
        nvgraphHandle handle, 
        nvgraphGraphDescr descrG, 
        Pointer vertexData, 
        long setnum)
    {
        return checkResult(nvgraphGetVertexDataNative(handle, descrG, vertexData, setnum));
    }
509281
def make_original_face(num_edges)
      num_edges_check(num_edges)
      # Make the vertices
      vert_ref = Array.new(num_edges) {Vertex.new}
      edge_ref = []

      # Connect each vertex to the one before it (including the first one :)
      (num_edges).times do |vert_id|
        edge_ref << make_connection(vert_ref[vert_id - 1], vert_ref[vert_id])
      end

      # Make the face and store it
      face = add_face(edge_ref)
      # Store the new vertices
      @vertices += vert_ref
      # Store the new edges
      @edges += edge_ref

      face
    end
3282
def update(self, τ: float = 1.0, update_indicators=True, dampen=False):
        

        for n in self.nodes(data=True):
            n[1]["next_state"] = n[1]["update_function"](n)

        for n in self.nodes(data=True):
            n[1]["rv"].dataset = n[1]["next_state"]

        for n in self.nodes(data=True):
            for i in range(self.res):
                self.s0[i][n[0]] = n[1]["rv"].dataset[i]
                if dampen:
                    self.s0[i][f"∂({n[0]})/∂t"] = self.s0_original[
                        f"∂({n[0]})/∂t"
                    ] * exp(-τ * self.t)
            if update_indicators:
                for indicator in n[1]["indicators"].values():
                    indicator.samples = np.random.normal(
                        indicator.mean * np.array(n[1]["rv"].dataset),
                        scale=0.01,
                    )

        self.t += self.Δt
1178683
def set_data(self, X, Y):
        
        assert X.shape[1]==self.Z.shape[1]
        self.X, self.Y = X, Y
708357
public static int nvgraphGetEdgeData(
        nvgraphHandle handle, 
        nvgraphGraphDescr descrG, 
        Pointer edgeData, 
        long setnum)
    {
        return checkResult(nvgraphGetEdgeDataNative(handle, descrG, edgeData, setnum));
    }
772510
def update_data(self, data_np, metadata=None, astype=None):
        
        self.set_data(data_np.copy(), metadata=metadata,
                      astype=astype)
789098
def update_bounds(self, bounds):
        '''

        '''
        starts =  bounds[:,0,:]
        ends = bounds[:,1,:]

        self.bounds = bounds
        self.lengths =  np.sqrt(((ends - starts)**2).sum(axis=1))
        
        vertices, normals, colors = self._process_reference()
        
        self.tr.update_vertices(vertices)
        self.tr.update_normals(normals)
312919
private void setVertex(Geometry geom, GeometryIndex index, Coordinate coordinate)
			throws GeometryIndexNotFoundException {
		if (index.hasChild() && geom.getGeometries() != null && geom.getGeometries().length > index.getValue()) {
			setVertex(geom.getGeometries()[index.getValue()], index.getChild(), coordinate);
		} else if (index.getType() == GeometryIndexType.TYPE_VERTEX && geom.getCoordinates() != null
				&& geom.getCoordinates().length > index.getValue()) {
			if (geom.getGeometryType().equals(Geometry.LINEAR_RING)) {
				// In case of a closed ring, the last vertex is not allowed to be moved:
				if ((geom.getCoordinates().length - 1) > index.getValue()) {
					geom.getCoordinates()[index.getValue()] = coordinate;
					if (index.getValue() == 0) {
						// In case of closed ring, keep last coordinate equal to the first:
						geom.getCoordinates()[geom.getCoordinates().length - 1] = new Coordinate(coordinate);
					}
				} else {
					throw new GeometryIndexNotFoundException("Can't move closing vertex of a LinearRing, "
							+ "move index=0 instead.");
				}
			} else {
				geom.getCoordinates()[index.getValue()] = coordinate;
			}
		} else {
			throw new GeometryIndexNotFoundException("Could not match index with given geometry");
		}
	}
1334447
def update_vertices(self, mask):
        
        if self.uv is not None:
            self.uv = self.uv[mask]
861323
def update_datatype(self, datatype, w=None, dw=None, pw=None,
                        return_body=None, timeout=None, include_context=None):
        
        raise NotImplementedError
411666
def update_vertices(self, vertices):
        

        vertices = np.array(vertices, dtype=np.float32)
        self._vbo_v.set_data(vertices)
59207
private void performUpdate(final Vec x, final double y, final double yHat)
    {
        for(IndexValue iv : x)
        {
            final int j = iv.getIndex();
            w.set(j, 
                    T(w.get(j)+2*learningRate*(y-yHat)*iv.getValue(), 
                    ((time-t[j])/K)*gravity*learningRate,
                    threshold));
            
            t[j] += ((time-t[j])/K)*K;
        }
    }
491433
def add_vertex(self, v):
        
        self.graph.add_vertex(v)
        self.vs.add(v)
1010067
public void copy(VertexData data) {
        clear();
        indices.addAll(data.indices);
        final TIntObjectIterator<VertexAttribute> iterator = data.attributes.iterator();
        while (iterator.hasNext()) {
            iterator.advance();
            attributes.put(iterator.key(), iterator.value().clone());
        }
        nameToIndex.putAll(data.nameToIndex);
    }
1335921
def updateMesh(self, polydata):
        
        self.poly = polydata
        self.mapper.SetInputData(polydata)
        self.mapper.Modified()
        return self