## Vector3d Class

3D vector with `x`,`y`,`z` as properties

• object

### Methods

Name Description
constructor(x: number = 0, y: number = 0, z: number = 0):
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(vectorB: Vector3d): Return the (Strongly typed) angle from this vector to the plane perpendicular to planeNormal.
angleTo(vectorB: Vector3d): Return the (Strongly typed) angle from this vector to vectorB.
angleToXY(vectorB: Vector3d): Return the (Strongly typed) angle from this vector to vectorB,using only the xy parts.
clone(result?: Vector3d): Copy xyz from this instance to a new (or optionally reused) Vector3d
crossProduct(vectorB: Vector3d, result?: Vector3d): Return the cross product of this vector and vectorB.
crossProductMagnitude(vectorB: XYAndZ): number Compute the magnitude of a cross product (without allocating a temporary vector object)
crossProductMagnitudeSquared(vectorB: XYAndZ): number Compute the squared magnitude of a cross product (without allocating a temporary vector object)
crossProductStartEnd(pointA: Point3d, pointB: Point3d, result?: 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): return cross product of `this` with the vector `(x, y, z)`
dotProduct(vectorB: XYAndZ): 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)
That is, pointA is weighted to weight of pointB.

dotProductStartEnd(pointA: XYAndZ, pointB: XYAndZ): number Returns the dot product of this vector with the with vector from pointA to pointB
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, x: number, y: number, z: number, w: number): number Dot product with vector from pointA to pointB, with pointB given as (weighted) x,y,z,w
pointB is a homogeneous point that has to be unweighted
if the weight is near zero metric, the return is zero.

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 the fractional projection of spaceVector onto this
interpolate(fraction: number, vectorB: Vector3d, result?: Vector3d): Return a vector computed at fractional position between this vector and vectorB
isParallelTo(other: Vector3d, oppositeIsParallel: boolean = false, returnValueIfAnInputIsZeroLength: boolean = false): boolean Test if this vector is parallel to other.
isPerpendicularTo(other: Vector3d, returnValueIfAnInputIsZeroLength: boolean = false): boolean Test if this vector is perpendicular to other.
minus(vector: XYAndZ, result?: Vector3d): Return the vector difference `this - vector`
negate(result?: Vector3d): Return a new vector with components negated from the calling instance.
normalize(result?: Vector3d): Vector3d | undefined 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): Normalize this vector, using given xyz as default if length is zero.
normalizeWithLength(result?: Vector3d): object Return a pair object containing (a) property `v` which is a unit vector in the direction
of the input and (b) property mag which is the magnitude (length) of the input (instance) prior to normalization.

planarAngleTo(vector: Vector3d, planeNormal: Vector3d): Return the (as strongly typed Angle) Angle from this vector to vectorB.
planarRadiansTo(vector: Vector3d, planeNormal: Vector3d): number Return the (radians as a simple number, not strongly typed Angle) radians from this vector to vectorB.
plus(vector: XYAndZ, result?: Vector3d): Return the vector sum `this - vector`
plus2Scaled(vectorA: XYAndZ, scalarA: number, vectorB: XYAndZ, scalarB: number, result?: Vector3d): Return the (strongly typed Vector3d) `this Vector3d + vectorA * scalarA + vectorB * scalarB`
plus3Scaled(vectorA: XYAndZ, scalarA: number, vectorB: XYAndZ, scalarB: number, vectorC: XYAndZ, scalarC: number, result?: Vector3d): Return the (strongly typed Vector3d) `thisVector3d + vectorA * scalarA + vectorB * scalarB + vectorC * scalarC`
plusScaled(vector: XYAndZ, scaleFactor: number, result?: Vector3d): Return vector + vector * scalar
rotate90Around(axis: Vector3d, result?: Vector3d): Vector3d | undefined Rotate this vector 90 degrees around an axis vector.
rotate90CCWXY(result?: Vector3d): Return a vector same length as this but rotate 90 degrees CCW
rotate90Towards(target: Vector3d, result?: Vector3d): Vector3d | undefined Return a (new or optionally preallocated) vector that is rotated 90 degrees in the plane of this vector and the target vector.
rotateXY(angle: Angle, result?: Vector3d): Rotate the xy parts of this vector around the z axis.
safeDivideOrNull(denominator: number, result?: Vector3d): Vector3d | undefined Divide by denominator, but return undefined if denominator is zero.
scale(scale: number, result?: Vector3d): Return vector * scalar
scaleToLength(length: number, result?: Vector3d): Vector3d | undefined Return a (optionally new or reused) vector in the direction of `this` but with specified length.
setStartEnd(point0: XYAndZ, point1: XYAndZ): void Set (replace) xzz components so they are a vector from point0 to point1
signedAngleTo(vector1: Vector3d, vectorW: Vector3d): Return the (strongly typed Angle) angle from this vector to vectorB, measured in the plane containing both, with vectorW indicating which side to view to control sign of the angle.
signedRadiansTo(vector1: Vector3d, vectorW: Vector3d): number Return the (simple number of radians, not Strongly typed Angle) angle from this vector to vectorB, measured in the plane containing both, with vectorW indicating which side to view to control sign of the angle.
sizedCrossProduct(vectorB: Vector3d, productLength: number, result?: Vector3d): Vector3d | undefined Compute cross product with `vectorB`.
smallerUnorientedAngleTo(vectorB: Vector3d): Return the smallest (strongly typed) angle from the (bidirectional) line containing `this` to the (bidirectional) line containing `vectorB`
smallerUnorientedRadiansTo(vectorB: Vector3d): number Return the smallest angle (in radians) from the (bidirectional) line containing `this` to the (bidirectional) line containing `vectorB`
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): Vector3d | undefined Compute the cross product of this vector with `vectorB`.
unitCrossProductWithDefault(vectorB: Vector3d, x: number, y: number, z: number, result?: Vector3d): Compute the cross product of this vector with `vectorB`.
unitPerpendicularXY(result?: Vector3d): Return a vector which is in the xy plane, perpendicular ot the xy part of this vector, and of unit length.
create(x: number = 0, y: number = 0, z: number = 0, result?: Vector3d): Static return a Vector3d (new or reused from optional result)
createAdd2Scaled(vectorA: XYAndZ, scaleA: number, vectorB: XYAndZ, scaleB: number, result?: 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): Static Return the (strongly typed Vector3d) `thisVector3d + vectorA * scalarA + vectorB * scalarB` with all components presented as numbers
createAdd3Scaled(vectorA: XYAndZ, scaleA: number, vectorB: XYAndZ, scaleB: number, vectorC: XYAndZ, scaleC: number, result?: Vector3d): Static Return the (strongly typed Vector3d) `thisVector3d + vectorA * scaleA + vectorB * scaleB + vectorC * scaleC`
createCrossProduct(ux: number, uy: number, uz: number, vx: number, vy: number, vz: number, result?: Vector3d): Static Create a vector which is cross product of two vectors supplied as separate arguments
createCrossProductToPoints(origin: XYAndZ, pointA: XYAndZ, pointB: XYAndZ, result?: Vector3d): Static Return the cross product of the vectors from origin to pointA and pointB.
createFrom(data: XYAndZ | XAndY | Float64Array, result?: Vector3d): Static Copy contents from another Point3d, Point2d, Vector2d, or Vector3d
createPolar(r: number, theta: Angle, z?: number): Static Return a vector defined by polar coordinates distance and angle from x axis
createRotateVectorAroundVector(vector: Vector3d, axis: Vector3d, angle?: Angle): Vector3d | undefined Static Return a vector which is the input vector rotated around the axis vector.
createSpherical(r: number, theta: Angle, phi: Angle): Static Return a vector defined in spherical coordinates.
createStartEnd(start: XYAndZ, end: XYAndZ, result?: 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): Static Return a vector (optionally in preallocated result, otherwise newly created) from [x0,y0,z0] to [x1,y1,z1]
createZero(result?: Vector3d): Static Return a vector with 000 xyz parts.
fromJSON(json?: XYZProps): Static Convert json to Vector3d.
unitX(scale: number = 1): Static Return a unit X vector optionally multiplied by a scale
unitY(scale: number = 1): Static Return a unit Y vector
unitZ(scale: number = 1): Static Return a unit Z vector

### Inherited methods

Name Inherited from Description
addScaledInPlace(other: XYAndZ, scale: number): void XYZ add (in place) the scaled x,y,z of other
addXYZInPlace(dx: number = 0, dy: number = 0, dz: number = 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(): XYZ Clone strongly typed as Point3d
distance(other: XYAndZ): number XYZ Return the distance from this point to other
distanceSquared(other: XYAndZ): number XYZ Return squared distance from this point to other
distanceSquaredXY(other: XAndY): number XYZ Return squared XY distance from this point to other
distanceXY(other: XAndY): number XYZ Return the XY distance from this point to other
freeze(): void 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: XYAndZ, tol?: number): boolean XYZ Returns true if this and other have equal x,y,z parts within Geometry.smallMetricDistance.
isAlmostEqualMetric(other: XYAndZ): boolean XYZ equality test with Geometry.smallMetricDistance tolerance
isAlmostEqualXY(other: XAndY, 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: XYAndZ): 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: XYAndZ): 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: XYAndZ, scale: number, result?: 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.
setFrom(other: Float64Array | XAndY | XYAndZ | undefined): void XYZ Set the x,y,z parts from one of these input types

XYZ -- copy the x,y,z parts
Float64Array -- Copy from indices 0,1,2 to x,y,z
* XY -- copy the x, y parts and set z=0
setFromJSON(json?: XYZProps): void XYZ Set the x,y,z properties from one of several json forms:

array of numbers: [x,y,z]
object with x,y, and (optional) z as numeric properties {x: xValue, y: yValue, z: zValue}
setFromPoint3d(other?: XYAndZ): 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
This is the same effect as `setFrom(other)` with no pretesting of variant input type
setZero(): void XYZ Set the x,y,z parts to zero.
subtractInPlace(other: XYAndZ): void XYZ add x,y,z from other in place.
toFloat64Array(): Float64Array XYZ Pack the x,y,z values in a Float64Array.
toJSON(): XYZ Return a JSON object as array `[x,y,z]`
toJSONXYZ(): XYZ Return a JSON object as key value pairs `{x: value, y: value, z: value}`
unitVectorTo(target: XYAndZ, result?: Vector3d): Vector3d | undefined XYZ Return a unit vector from this vector to other.
vectorTo(other: XYAndZ, result?: Vector3d): XYZ Return a (full length) vector from this point to other
accessX(arg: any, defaultValue?: number): number | undefined Static XYZ Look for (in order) an x coordinate present as:
arg.x
arg
accessY(arg: any, defaultValue?: number): number | undefined Static XYZ Look for (in order) an x coordinate present as:
arg.y
arg
accessZ(arg: any, defaultValue?: number): number | undefined Static XYZ Look for (in order) an x coordinate present as:
arg.z
arg
hasZ(arg: any): boolean 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:
XAndY
XYAndZ
[number,number]
[number,number,number]
isXAndY(arg: any): boolean Static XYZ Type guard for XAndY.
isXYAndZ(arg: any): boolean Static XYZ Type guard for XYAndZ.

### Inherited properties

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

### Defined in

Last Updated: 08 January, 2020