API Reference > core-geometry > CartesianGeometry > Vector3d

Vector3d Class

3D vector with x,y,z as properties

Extends

Methods

Name Description
constructor(x: number = 0, y: number = 0, z: number = 0): Vector3d    
addCrossProductToTargetsInPlace(ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): void Accumulate a vector which is cross product vectors from origin (ax,ay,az) to targets (bx,by,bz) and (cx,cy,cz)  
angleFromPerpendicular(planeNormal: Vector3d): Angle Return the (strongly-typed) angle from this vector to the plane perpendicular to planeNormal.  
angleTo(vectorB: Vector3d): Angle Return the (strongly-typed) angle from this vector to vectorB.  
angleToXY(vectorB: Vector3d): Angle Return the (strongly-typed) angle from this vector to vectorB, using only the xy parts.  
clone(result?: Vector3d): Vector3d Copy xyz from this instance to a new (or optionally reused) Vector3d  
crossProduct(vectorB: Vector3d, result?: Vector3d): Vector3d Return the cross product of this vector and vectorB.  
crossProductMagnitude(vectorB: Readonly<WritableXYAndZ>): number Compute the magnitude of a cross product (without allocating a temporary vector object)  
crossProductMagnitudeSquared(vectorB: Readonly<WritableXYAndZ>): number Compute the squared magnitude of a cross product (without allocating a temporary vector object)  
crossProductStartEnd(pointA: Point3d, pointB: Point3d, result?: Vector3d): Vector3d Cross product with vector from pointA to pointB  
crossProductStartEndXY(pointA: Point3d, pointB: Point3d): number Cross product (xy parts only) with vector from pointA to pointB  
crossProductXY(vectorB: Vector3d): number Return the cross product of the instance and vectorB, using only the x and y parts.  
crossProductXYZ(x: number, y: number, z: number, result?: Vector3d): Vector3d return cross product of this with the vector (x, y, z)  
dotProduct(vectorB: Readonly<WritableXYAndZ>): number Return the dot product of this vector with vectorB.  
dotProductStart3dEnd4d(pointA: Point3d, pointB: Point4d): number Returns the dot product with vector (pointB - pointA * pointB.w)  
dotProductStartEnd(pointA: Readonly<WritableXYAndZ>, pointB: Readonly<WritableXYAndZ>): number Returns the dot product of this vector with the with vector from pointA to pointB  
dotProductStartEndXY(pointA: Point3d, pointB: Point3d): number Dot product with vector from pointA to pointB, using only xy parts  
dotProductStartEndXYZ(pointA: Point3d, x: number, y: number, z: number): number Dot product with vector from pointA to pointB, with pointB given as x,y,z  
dotProductStartEndXYZW(pointA: Point3d, wx: number, wy: number, wz: number, w: number): number Dot product with vector from pointA to pointB, with pointB given as (weighted) wx,wy,wz,w  
dotProductXY(vectorB: Vector3d): number Return the dot product of the instance and vectorB, using only the x and y parts.  
dotProductXYZ(x: number, y: number, z: number = 0): number Dot product with vector (x,y,z)  
fractionOfProjectionToVector(target: Vector3d, defaultFraction: number = 0): number Return fractional projection of this vector on the target vector.  
interpolate(fraction: number, vectorB: Readonly<WritableXYAndZ>, result?: Vector3d): Vector3d Return a vector computed at fractional position between this vector and vectorB  
isParallelTo(other: Vector3d, oppositeIsParallel: boolean = false, returnValueIfAnInputIsZeroLength: boolean = false, options?: PerpParallelOptions): boolean Test if this vector is parallel to other.  
isPerpendicularTo(other: Vector3d, returnValueIfAnInputIsZeroLength: boolean = false, options?: PerpParallelOptions): boolean Test if this vector is perpendicular to other.  
minus(vector: Readonly<WritableXYAndZ>, result?: Vector3d): Vector3d Return the vector difference this - vector  
negate(result?: Vector3d): Vector3d Return a new vector with components negated from the calling instance.  
normalize(result?: Vector3d): undefined | Vector3d Return a unit vector parallel with this.  
normalizeInPlace(): boolean If this vector has nonzero length, divide by the length to change to a unit vector.  
normalizeWithDefault(x: number, y: number, z: number, result?: Vector3d): Vector3d Normalize this vector, using given xyz as default if length is zero.  
normalizeWithLength(result?: Vector3d): { mag: number, v: undefined | Vector3d } Return a pair object containing (a) property v which is a unit vector in the direction of the input  
planarAngleTo(vectorB: Vector3d, planeNormal: Vector3d): Angle Return the (strongly-type) angle from this vector to vectorB,  
planarRadiansTo(vectorB: Vector3d, planeNormal: Vector3d): number Return the angle in radians (not as strongly-typed Angle) from this vector to vectorB,  
plus(vector: Readonly<WritableXYAndZ>, result?: Vector3d): Vector3d Return the vector sum this - vector  
plus2Scaled(vectorA: Readonly<WritableXYAndZ>, scalarA: number, vectorB: Readonly<WritableXYAndZ>, scalarB: number, result?: Vector3d): Vector3d Return the (strongly typed Vector3d) this Vector3d + vectorA * scalarA + vectorB * scalarB  
plus3Scaled(vectorA: Readonly<WritableXYAndZ>, scalarA: number, vectorB: Readonly<WritableXYAndZ>, scalarB: number, vectorC: Readonly<WritableXYAndZ>, scalarC: number, result?: Vector3d): Vector3d Return the (strongly typed Vector3d) thisVector3d + vectorA * scalarA + vectorB * scalarB + vectorC * scalarC  
plusScaled(vector: Readonly<WritableXYAndZ>, scaleFactor: number, result?: Vector3d): Vector3d Return vector + vector * scalar  
radiansTo(vectorB: Vector3d): number Return the angle in radians (not as strongly typed Angle) from this vector to vectorB.  
rotate90Around(axis: Vector3d, result?: Vector3d): undefined | Vector3d Rotate this vector 90 degrees around an axis vector.  
rotate90CCWXY(result?: Vector3d): Vector3d Return a vector same length as this but rotate 90 degrees CCW  
rotate90CWXY(result?: Vector3d): Vector3d Return a vector same length as this but rotated 90 degrees clockwise  
rotate90Towards(target: Vector3d, result?: Vector3d): undefined | Vector3d Return a (new or optionally preallocated) vector that is rotated 90 degrees in  
rotateXY(angle: Angle, result?: Vector3d): Vector3d Rotate the xy parts of this vector around the z axis.  
safeDivideOrNull(denominator: number, result?: Vector3d): undefined | Vector3d Divide by denominator, but return undefined if denominator is zero.  
scale(scale: number, result?: Vector3d): Vector3d Return vector * scalar  
scaleToLength(length: number, result?: Vector3d): undefined | Vector3d Return a (optionally new or reused) vector in the direction of this but with specified length.  
setStartEnd(point0: Readonly<WritableXYAndZ>, point1: Readonly<WritableXYAndZ>): void Set (replace) xyz components so they are a vector from point0 to point1  
signedAngleTo(vectorB: Vector3d, vectorW: Vector3d): Angle Return the (strongly-typed) angle from this vector to vectorB, measured  
signedRadiansTo(vectorB: Vector3d, vectorW: Vector3d): number Return the angle in radians (not as strongly-typed Angle) from this vector to vectorB, measured  
sizedCrossProduct(vectorB: Vector3d, productLength: number, result?: Vector3d): undefined | Vector3d Compute cross product with vectorB  
smallerUnorientedAngleTo(vectorB: Vector3d): Angle Return the smallest (strongly typed) angle from the (bidirectional) line containing this  
smallerUnorientedRadiansTo(vectorB: Vector3d): number Return the smallest angle (in radians) from the (bidirectional) line containing this  
tripleProduct(vectorB: Vector3d, vectorC: Vector3d): number Return the triple product of the instance, vectorB, and vectorC  
tryNormalizeInPlace(smallestMagnitude: number = Geometry.smallMetricDistance): boolean Try to normalize (divide by magnitude), storing the result in place.  
unitCrossProduct(vectorB: Vector3d, result?: Vector3d): undefined | Vector3d Compute the cross product of this vector with vectorB.  
unitCrossProductWithDefault(vectorB: Vector3d, x: number, y: number, z: number, result?: Vector3d): Vector3d Compute the cross product of this vector with vectorB.  
unitPerpendicularXY(result?: Vector3d): Vector3d Return a vector which is in the xy plane, perpendicular to the xy part of this vector, and of unit length.  
create(x: number = 0, y: number = 0, z: number = 0, result?: Vector3d): Vector3d Static return a Vector3d (new or reused from optional result)  
createAdd2Scaled(vectorA: Readonly<WritableXYAndZ>, scaleA: number, vectorB: Readonly<WritableXYAndZ>, scaleB: number, result?: Vector3d): Vector3d Static Return the (strongly typed Vector3d) thisVector3d + vectorA * scalarA + vectorB * scalarB  
createAdd2ScaledXYZ(ax: number, ay: number, az: number, scaleA: number, bx: number, by: number, bz: number, scaleB: number, result?: Vector3d): Vector3d Static Return the (strongly typed Vector3d) thisVector3d + vectorA * scalarA + vectorB * scalarB  
createAdd3Scaled(vectorA: Readonly<WritableXYAndZ>, scaleA: number, vectorB: Readonly<WritableXYAndZ>, scaleB: number, vectorC: Readonly<WritableXYAndZ>, scaleC: number, result?: Vector3d): Vector3d Static Return the (strongly typed Vector3d) thisVector3d + vectorA * scaleA + vectorB * scaleB + vectorC * scaleC  
createArrayFromPackedXYZ(data: Float64Array): Vector3d[] Static Return an array of vectors constructed from groups of 3 entries in a Float64Array.  
createCrossProduct(ux: number, uy: number, uz: number, vx: number, vy: number, vz: number, result?: Vector3d): Vector3d Static Create a vector which is cross product of two vectors supplied as separate arguments  
createCrossProductToPoints(origin: Readonly<WritableXYAndZ>, pointA: Readonly<WritableXYAndZ>, pointB: Readonly<WritableXYAndZ>, result?: Vector3d): Vector3d Static Return the cross product of the vectors from origin to pointA and pointB.  
createFrom(data: number[] | Float64Array | Readonly<WritableXAndY> | Readonly<WritableXYAndZ>, result?: Vector3d): Vector3d Static Copy contents from another Point3d, Point2d, Vector2d, or Vector3d  
createNormalized(x: number = 0, y: number = 0, z: number = 0, result?: Vector3d): undefined | Vector3d Static Create a normalized vector from the inputs.  
createPolar(r: number, theta: Angle, z?: number): Vector3d Static Return a vector defined by polar coordinates distance and angle from x axis  
createRotateVectorAroundVector(vector: Vector3d, axis: Vector3d, angle?: Angle): undefined | Vector3d Static Return a vector which is the input vector rotated around the axis vector.  
createSpherical(r: number, theta: Angle, phi: Angle): Vector3d Static Return a vector defined in spherical coordinates.  
createStartEnd(start: Readonly<WritableXAndY> | Readonly<WritableXYAndZ>, end: Readonly<WritableXAndY> | Readonly<WritableXYAndZ>, result?: Vector3d): Vector3d Static Return a vector defined by start and end points (end - start).  
createStartEndXYZXYZ(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, result?: Vector3d): Vector3d Static Return a vector (optionally in preallocated result, otherwise newly created) from [x0,y0,z0] to [x1,y1,z1]  
createZero(result?: Vector3d): Vector3d Static Return a vector with 000 xyz parts.  
dotProductAsXYAndZ(dataA: Readonly<WritableXYAndZ>, dataB: Readonly<WritableXYAndZ>): number Static Return the dot product of the xyz components of two inputs that are XYAndZ but otherwise not explicitly Vector3d  
fromJSON(json?: XYZProps): Vector3d Static Convert json to Vector3d.  
unitX(scale: number = 1): Vector3d Static Return a unit X vector optionally multiplied by a scale  
unitY(scale: number = 1): Vector3d Static Return a unit Y vector optionally multiplied by a scale  
unitZ(scale: number = 1): Vector3d Static Return a unit Z vector optionally multiplied by a scale  

Inherited methods

Name Inherited from Description
addInPlace(other: Readonly<WritableXYAndZ>): void XYZ add x,y,z from other in place.
addScaledInPlace(other: Readonly<WritableXYAndZ>, scale: number): void XYZ add (in place) the scaled x,y,z of other
addXYZInPlace(dx: number = 0.0, dy: number = 0.0, dz: number = 0.0): void XYZ add to x, y, z parts
at(index: number): number XYZ Return the x,y, z component corresponding to 0,1,2.
cloneAsPoint3d(): Point3d XYZ Clone strongly typed as Point3d
distance(other: Readonly<WritableXYAndZ>): number XYZ Return the distance from this point to other
distanceSquared(other: Readonly<WritableXYAndZ>): number XYZ Return squared distance from this point to other
distanceSquaredXY(other: Readonly<WritableXAndY>): number XYZ Return squared XY distance from this point to other
distanceXY(other: Readonly<WritableXAndY>): number XYZ Return the XY distance from this point to other
freeze(): Readonly<Vector3d> XYZ Freeze this XYZ
indexOfMaxAbs(): number XYZ Return the index (0,1,2) of the x,y,z component with largest absolute value
isAlmostEqual(other: Readonly<Readonly<WritableXYAndZ>>, tol?: number): boolean XYZ Returns true if this and other have equal x,y,z parts within Geometry.smallMetricDistance.
isAlmostEqualMetric(other: Readonly<WritableXYAndZ>): boolean XYZ equality test with Geometry.smallMetricDistance tolerance
isAlmostEqualXY(other: Readonly<WritableXAndY>, tol?: number): boolean XYZ Return true if this and other have equal x,y parts within Geometry.smallMetricDistance.
isAlmostEqualXYZ(x: number, y: number, z: number, tol?: number): boolean XYZ Return true if this and other have equal x,y,z parts within Geometry.smallMetricDistance.
isExactEqual(other: Readonly<WritableXYAndZ>): boolean XYZ exact equality test.
magnitude(): number XYZ Return the sqrt of the sum of squared x,y,z parts
magnitudeSquared(): number XYZ Return the sum of squared x,y,z parts
magnitudeSquaredXY(): number XYZ Return the sum of squared x,y parts
magnitudeXY(): number XYZ Return sqrt of the sum of squared x,y parts
maxAbs(): number XYZ Return the largest absolute value of any component
maxDiff(other: Readonly<WritableXYAndZ>): number XYZ Return the largest absolute distance between corresponding components
scaleInPlace(scale: number): void XYZ Multiply the x, y, z parts by scale.
scaledVectorTo(other: Readonly<WritableXYAndZ>, scale: number, result?: Vector3d): Vector3d XYZ Return a multiple of a the (full length) vector from this point to other
set(x: number = 0, y: number = 0, z: number = 0): void XYZ Set the x,y,z parts.
setAt(index: number, value: number): void XYZ Set value at index 0 or 1 or 2.
setFrom(other: undefined | Float64Array | Readonly<WritableXAndY> | Readonly<WritableXYAndZ>): void XYZ Set the x,y,z parts from one of these input types
setFromJSON(json?: XYZProps): void XYZ Set the x,y,z properties from one of several json forms:
setFromPoint3d(other?: Readonly<WritableXYAndZ>): void XYZ Set the x,y,z parts from a Point3d.
setFromVector3d(other?: Vector3d): void XYZ Set the x,y,z parts from a Vector3d
setZero(): void XYZ Set the x,y,z parts to zero.
subtractInPlace(other: Readonly<WritableXYAndZ>): void XYZ add x,y,z from other in place.
toArray(): number[] XYZ Return as an array [x,y,z]
toFloat64Array(): Float64Array XYZ Pack the x,y,z values in a Float64Array.
toJSON(): XYZProps XYZ Return a JSON object as array [x,y,z]
toJSONXYZ(): XYZProps XYZ Return a JSON object as key value pairs {x: value, y: value, z: value}
unitVectorTo(target: Readonly<WritableXYAndZ>, result?: Vector3d): undefined | Vector3d XYZ Return a unit vector from this vector to other.
vectorTo(other: Readonly<WritableXYAndZ>, result?: Vector3d): Vector3d XYZ Return a (full length) vector from this point to other
accessX(arg: any, defaultValue?: number): undefined | number Static XYZ Look for (in order) an x coordinate present as:
accessY(arg: any, defaultValue?: number): undefined | number Static XYZ Look for (in order) an x coordinate present as:
accessZ(arg: any, defaultValue?: number): undefined | number Static XYZ Look for (in order) an x coordinate present as:
hasZ(arg: any): arg is Readonly<WriteableHasZ> Static XYZ Type guard to determine whether an object has a member called "z"
isAnyImmediatePointType(arg: any): boolean Static XYZ Test if arg is any of:
isXAndY(arg: any): arg is Readonly<WritableXAndY> Static XYZ Type guard for XAndY.
isXYAndZ(arg: any): arg is Readonly<WritableXYAndZ> Static XYZ Type guard for XYAndZ.
x(xyz: undefined | XYZProps, defaultValue: number = 0): number Static XYZ access x part of XYZProps (which may be .x or [0])
y(xyz: undefined | XYZProps, defaultValue: number = 0): number Static XYZ access x part of XYZProps (which may be .x or [0])
z(xyz: undefined | XYZProps, defaultValue: number = 0): number Static XYZ access x part of XYZProps (which may be .x or [0])

Inherited properties

Name Type Inherited from Description
isAlmostZero Accessor ReadOnly boolean XYZ Return true if the x,y,z components are all nearly zero to tolerance Geometry.smallMetricDistance
isZero Accessor ReadOnly boolean XYZ Return true if the x,y,z components are all exactly zero
x number XYZ x coordinate
y number XYZ y coordinate
z number XYZ z coordinate

Defined in

Last Updated: 20 June, 2023