Set the value of a point on a heightmap.

    .. deprecated:: 2.0
        `hm` is a NumPy array, so values should be assigned to it directly.
321905
def heightmap_set_value(hm: np.ndarray, x: int, y: int, value: float) -> None:
    
    if hm.flags["C_CONTIGUOUS"]:
        warnings.warn(
            "Assign to this heightmap with hm[i,j] = value\n"
            "consider using order='F'",
            DeprecationWarning,
            stacklevel=2,
        )
        hm[y, x] = value
    elif hm.flags["F_CONTIGUOUS"]:
        warnings.warn(
            "Assign to this heightmap with hm[x,y] = value",
            DeprecationWarning,
            stacklevel=2,
        )
        hm[x, y] = value
    else:
        raise ValueError("This array is not contiguous.")
1311691
def set(self, value):
        

        if isinstance(value, str_cls):
            if self._map is None:
                raise ValueError(unwrap(
                    '''
                    %s value is a unicode string, but no _map provided
                    ''',
                    type_name(self)
                ))

            if value not in self._reverse_map:
                raise ValueError(unwrap(
                    '''
                    %s value, %s, is not present in the _map
                    ''',
                    type_name(self),
                    value
                ))

            value = self._reverse_map[value]

        elif not isinstance(value, int_types):
            raise TypeError(unwrap(
                '''
                %s value must be an integer or unicode string when a name_map
                is provided, not %s
                ''',
                type_name(self),
                type_name(value)
            ))

        self._native = self._map[value] if self._map and value in self._map else value

        self.contents = int_to_bytes(value, signed=True)
        self._header = None
        if self._trailer != b'':
            self._trailer = b''
630622
def set_datapoint(self, ind, datapoint):
        
        if ind >= self.num_datapoints:
            raise ValueError('Index %d out of bounds! Tensor has %d datapoints' %(ind, self.num_datapoints))
        self.data[ind, ...] = np.array(datapoint).astype(self.dtype)
126430
def set(self, num):
        
        self._value = str(int(num))
        self._variable.set(self._value)
423436
def set_values(self, values):
        """"""
        self.values = values
        self.height = len(self.values) * 14
        self._max = max(rec[1] for rec in values) if values else dt.timedelta(0)
1357939
def set_value(self, arr, key, value):
        
        self._engine.set_value(com.values_from_object(arr),
                               com.values_from_object(key), value)
797337
def set(self, value, samples=0):
        '''
        
        '''
        if self.params.length > self.pos and samples > 0:
            l = min(samples, self.params.length-self.pos)
            self.data[self.pos:self.pos+l] = np.full(l, value, dtype=np.float)
            self.pos += l
        self.latest = value
        return self
97912
function setGeomAttrList(params) {
    for(var param in params) {
      if(params.hasOwnProperty(param)) {
        if(typeof params[param] === 'string') {
          geomAttrs.push(params[param]);
        } else if (typeof params[param] === 'object') { // Array of coordinates for Point
          geomAttrs.push(params[param][0]);
          geomAttrs.push(params[param][1]);
        }
      }
    }

    if(geomAttrs.length === 0) { throw new Error('No geometry attributes specified'); }
  }
1015186
def _set_value(self, target, value, bitarray):
        '''  '''
        # derive raw value
        rng = target.find('range')
        rng_min = float(rng.find('min').text)
        rng_max = float(rng.find('max').text)
        scl = target.find('scale')
        scl_min = float(scl.find('min').text)
        scl_max = float(scl.find('max').text)
        raw_value = (value - scl_min) * (rng_max - rng_min) / (scl_max - scl_min) + rng_min
        # store value in bitfield
        return self._set_raw(target, int(raw_value), bitarray)
1186030
def set_I(self, I=None):
        
        C0 = I is None
        C1 = type(I) in [int,float,np.int64,np.float64]
        C2 = type(I) in [list,tuple,np.ndarray]
        msg = "Arg I must be None, a float or an 1D np.ndarray !"
        assert C0 or C1 or C2, msg
        if C1:
            I = np.array([I],dtype=float)
        elif C2:
            I = np.asarray(I,dtype=float).ravel()
        self._dmag['I'] = I
        if C0:
            self._dmag['nI'] = 0
        else:
            self._dmag['nI'] = I.size
520708
def point(value):
    
    lst = value.split()
    dim = len(lst)
    if dim == 2:
        return longitude(lst[0]), latitude(lst[1]), 0.
    elif dim == 3:
        return longitude(lst[0]), latitude(lst[1]), depth(lst[2])
    else:
        raise ValueError('Invalid point format: %s' % value)
5469
def set_org(self, value, lineno):
        
        if value < 0 or value > MAX_MEM:
            error(lineno, "Memory ORG out of range [0 .. 65535]. Current value: %i" % value)

        self.index = self.ORG = value
1107850
def __set_unit(self, value):
        '''
        
        '''
        if value in UNITS:
            value = value.upper()

        self.__unit = value
712146
def add(self, point, value):
        
        # check range
        for p, r in zip(point, self.range):
            if p < r[0] or p > r[1]:
                return
        # check nan
        if isnan(value):
            return

        refs = self.opts['references']
        # for all neighbour points (1, if antialiasting=False):
        for position, intensity in self.sortMethod.getPositionsIntensities(
                point):
            position = tuple(position)
            if self.mean is not None:
                old_value = self.values[position]
                if not np.isnan(old_value):
                    anz_values = self.density[position]
                    mean = old_value + intensity * (
                        ((value - old_value) / (anz_values + intensity)))
                    self.mean[position] = mean

                    if self.variance is not None:
                        self.variance[
                            position] += (abs(value - mean) / (
                                anz_values + intensity))

            if self.mergeMethod(self.values, position, intensity, value):
                for a in refs:
                    a.mergeMethod(a, position, intensity, value)
            if self.density is not None:
                self.density[position] += intensity
46313
def set(self, value):
        

        if not isinstance(value, byte_cls):
            raise TypeError(unwrap(
                '''
                %s value must be a byte string, not %s
                ''',
                type_name(self),
                type_name(value)
            ))

        self._bytes = value
        self.contents = value
        self._header = None
        if self._indefinite:
            self._indefinite = False
            self.method = 0
        if self._trailer != b'':
            self._trailer = b''
739278
function setPoints(points) {
         var x = Infinity,
             y = Infinity,
             right = -Infinity,
             bottom = -Infinity;
         points.forEach(function (point) {
           x = Math.min(x, point.x);
           y = Math.min(y, point.y);
           right = Math.max(right, point.x);
           bottom = Math.max(bottom, point.y);
         });
         this.setShape(x, y, right - x, bottom - y);
         return this;
       }
1012322
void set(final double m, final Object pt) {
		if (m == 0.0) {
			if (count != 0) {
				clusters.space.setToOrigin(m1);
				clusters.space.setToOrigin(m2);
			}
		} else {
			clusters.space.setToScaled(m1, m, pt);
			clusters.space.setToScaledSqr(m2, m, pt);
		}
		count = 1;
		m0 = m;
		var = 0.0;
	}