Sets the elevation for a single given grid cell.
@param {Number} x
@param {Number} z
@param {Number} h new elevation value
@return itself
554248
function(x,z,h){
				var index = this._getIndex(x,z);
				this.elevation[index] = h;
				this.vertices[index].y = h;
				return this;
			}
512214
function set(x, y, z) {
         if (x !== +x || y !== +y || z !== +z) {
           throw new Error("invalid x, y, z parameters (not a number)");
         }
         /**
          * x value of the vector
          * @public
          * @type Number
          * @name x
          * @memberOf me.Vector3d
          */
         //this.x = x;

         /**
          * y value of the vector
          * @public
          * @type Number
          * @name y
          * @memberOf me.Vector3d
          */
         //this.y = y;

         /**
          * z value of the vector
          * @public
          * @type Number
          * @name z
          * @memberOf me.Vector3d
          */
         //this.z = z;


         return this._set(x, y, z);
       }
1035690
function(x,z){
				var xx = x / this._scale.x + this.width * 0.5,
					zz = z / this._scale.y + this._depth * 0.5,
					y = 0,
					flxx = ~~x,
					flzz = ~~zz;

				if(xx >= 0 & xx < this.width && zz >= 0 && zz < this._depth){

					var x2 = ~~Math.min(xx + 1, this.width - 1),
						z2 = ~~Math.min(zz + 1, this._depth - 1);

					var	a = this.getHeightAtCell(flxx, flzz),
						b = this.getHeightAtCell(x2, flzz),
						c = this.getHeightAtCell(flxx, z2),
						d = this.getHeightAtCell(x2, z2);

					y = Interpolation2D.bilinear(xx,zz, flxx, flzz, x2, z2, a, b, c, d);
				}
				return y;
			}
656734
public static Vector4 createVector(double x, double y, double z, double h) {
		Vector4 v=new Vector4Impl();
		v.setX(x);
		v.setY(y);
		v.setZ(z);
		v.setH(h);
		return v;
	}
1365794
public void setPosition(float x, float y, float z) {
        if (isActive()) {
            mIODevice.setPosition(x, y, z);
        }
    }
791457
function(v, h, Hshp, shpclass) {
    var t;
    if (v instanceof Cell) {
      return {
        back: v,
        front: v,
      };
    } else {

      Hshp = v.clipSHPtoParents(Hshp);

      // If no sub-hyperplane exists, then H doesn't intersect
      // the region of the current node v, so the result
      // is an outside cell. This will be condensed into a 
      // single outside cell in a subsequent step
      if (!Hshp) {
        return {
          back: new Cell(false),
          front: new Cell(false),
        };
      }

      var Vshp = v.shp;
      var HsplitByT = Hshp.splitBy(Vshp.s);
      var TsplitByH = Vshp.splitBy(h);

      if (HsplitByT.coincident && TsplitByH.coincident) {

        if (Vshp.s.isSameOrientation(h)) {
          return {
            back: v.back, 
            front: v.front
          };
        } else {
          return {
            back: v.front, 
            front: v.back,
          };
        }

      } else if (TsplitByH.front && TsplitByH.back && HsplitByT.front && HsplitByT.back) {

        t = splitBSP(v.back, h, Hshp, shpclass);
        var left_minus = t.back;
        var left_plus = t.front;

        t = splitBSP(v.front, h, Hshp, shpclass);
        var right_minus = t.back;
        var right_plus = t.front;

        t = Vshp.splitBy(h);
        var shp_left_tree = t.back;
        var shp_right_tree = t.front;

        var leftNode = new Node(v.plane, left_minus, right_minus);
        var rightNode = new Node(v.plane, left_plus, right_plus);
        leftNode.shp = shp_left_tree;
        rightNode.shp = shp_right_tree;

        return {
          back  : leftNode,
          front : rightNode,
        };

      } else {

        var TinHPlus = TsplitByH.front && !TsplitByH.back;
        var HinTPlus = HsplitByT.front && !HsplitByT.back;
        // Vshp in H+ and H behind Vshp
        // Case 4
        if (TinHPlus && !HinTPlus) {
          t = splitBSP(v.back, h, Hshp, shpclass);
          v.back = t.front;
          return {
            back: t.back,
            front: v,
          };
        // // Vshp in H+ and H in front of Vshp
        // // Case 5
        } else if (TinHPlus && HinTPlus) {
          t = splitBSP(v.front, h, Hshp, shpclass);
          v.front = t.front;
          return {
            back: t.back,
            front: v,
          };
        // // Vshp in H- and H behind Vshp
        // // Case 6
        } else if (!TinHPlus && !HinTPlus) {
          t = splitBSP(v.back, h, Hshp, shpclass);
          v.back = t.back;
          return {
            back: v,
            front: t.front,
          };
        // // Vshp in H- and H in front of Vshp
        // // Case 7
        } else if (HinTPlus && !TinHPlus) {
          t = splitBSP(v.front, h, Hshp, shpclass);
          v.front = t.back;
          return {
            back: v,
            front: t.front,
          };

        } else {
          throw new Error('unexpected combination');
        }

      }

    }
  }
582248
function FlatTile(x, y, z, geometry) {
  this.x = x;
  this.y = y;
  this.z = z;
  this._geometry = geometry;
  this._level = geometry.levelList[z];
}
186324
public GVRTransform setPosition(float x, float y, float z) {
        NativeTransform.setPosition(getNative(), x, y, z);
        return this;
    }
980083
public void setNode(int number, Vector3D v) {
        if (number <= 0) {
            number = 0;
        } else if (3 <= number) {
            number = 3;
        }
        this.points[number * 3] = (float)v.getX();
        this.points[number * 3 + 1] = (float)v.getY();
        this.points[number * 3 + 2] = (float)v.getZ();
        set();
    }
884109
function Arc(start, end, height) {
    this.start = start;
    this.end = end;
    this.height = height;
}
537405
public void setTargetNormal( double nx, double ny, double nz )
    {
        double h,f,c,vx,vy,hvx;

        vx = ny;
        vy = -nx;
        c = nz;
        
        h = (1-c)/(1-c*c);
        hvx = h*vx;
        f = (c < 0) ? -c : c;                
        
        if( f < 1.0 - 1.0E-4 ) 
        {
            m00=c + hvx*vx;
            m01=hvx*vy;
            m02=-vy;
            m10=hvx*vy;
            m11=c + h*vy*vy;
            m12=vx;
            m20=vy;
            m21=-vx;
            m22=c;
        }
        else
        {
            // if "from" and "to" vectors are nearly parallel
            m00=1;
            m01=0;
            m02=0;
            m10=0;
            m11=1;
            m12=0;
            m20=0;
            m21=0;
            if( c > 0 )
            {
                m22=1;                
            }
            else
            {
                m22=-1;
            }
        }
        
    }
116421
public Quaternion fromAnglesXZ (float x, float z) {
        float hx = x * 0.5f, hz = z * 0.5f;
        float sx = FloatMath.sin(hx), cx = FloatMath.cos(hx);
        float sz = FloatMath.sin(hz), cz = FloatMath.cos(hz);
        return set(cz*sx, sz*sx, sz*cx, cz*cx);
    }
1245179
function setAllHeights(elements, height) {
  for (let i = elements.length - 1; i >= 0; i--) {
    elements[i].style.height = height;
  }
}
384000
public Vector3f set(Vector2ic v, float z) {
        return set(v.x(), v.y(), z);
    }
147817
public Vector3d set(Vector2ic v, double z) {
        return set(v.x(), v.y(), z);
    }
633789
public void set(double x1, double y1, double z1, double w1) {
		double mag = (1.0/Math.sqrt( x1*x1 + y1*y1 + z1*z1 + w1*w1 ));
		this.x = x1*mag;
		this.y = y1*mag;
		this.z = z1*mag;
		this.w = w1*mag;
	}
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.")