PdVector ("JavaView Reference Manual")

java.lang.Object
- jv.vecmath.P_Vector
- - jv.vecmath.PdVector

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable
```
public class PdVector
extends P_Vector
implements java.lang.Cloneable
```
Linear algebra class for an array of doubles with variable length. Many non-linear operations implemented too.

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

double[] m_data
Data array containing the components of the vector.

Fields
Modifier and Type	Field and Description
`double[]`	`m_data` Data array containing the components of the vector.

Constructor Summary

Constructors
Constructor and Description
`PdVector()` Construct vector with zero size.
`PdVector(double x)` Constructs a vector of length 1 and given initial data.
`PdVector(double[] x)` Constructs a vector having same length and given initial data as given array.
`PdVector(double x, double y)` Constructs a vector of length 2 and given initial data.
`PdVector(double x, double y, double z)` Constructs a vector of length 3 and given initial data.
`PdVector(double x, double y, double z, double w)` Constructs a vector of length 4 and given initial data.
`PdVector(int aSize)` Constructor creating a vector with given dimension.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`add(double val)` Add argument to each component of vector.
`void`	`add(double scale, PdVector v)` Add `scale*v` to `this`.
`void`	`add(PdVector m)` Sum with argument vector `this += m`.
`void`	`add(PdVector m1, PdVector m2)` Sum of argument vectors `this = m1+m2`.
`int`	`addEntry(double val)` Add another entry at the end of the vector and increment size of vector.
`static PdVector`	`addNew(PdVector m1, PdVector m2)` Create a new vector as sum of argument vectors `new = m1+m2`.
`static PdVector[][]`	`alloc(int sizeI, int sizeJ, int vectorSize)` Allocate a new array of vectors, where all vectors have the same dimension.
`static void`	`angle(double[] angle, PdVector[] p)` Compute interior angles at all vertices of a convex polygon.
`static void`	`angle(double[] angle, PdVector p, PdVector q, PdVector r)` Compute interior angles at all three vertices of a triangle.
`static double`	`angle(PdVector v, PdVector w)` Compute angle between two vectors in (0.,180.).
`static double`	`angle(PdVector p, PdVector q, PdVector r)` Compute angle of triangle (p, q, r) at vertex p.
`static double`	`angleWithOrientation(double[] angle, PdVector[] p, int len)` Compute exterior angles in radians at vertices of a (possibly non-convex) polygon.
`static double`	`angleWithOrientation(PdVector v, PdVector w, PdVector orient)` Compute signed angle in radians between two vectors depending on the orientation.
`static double`	`area(PdVector[] p)` Compute area of planar n-gon spanned by vertices p[] in some R^m.
`static double`	`area(PdVector p, PdVector q, PdVector r)` Compute area of triangle spanned by vertices {p,q,r} in some R^m.
`double`	`average()` Compute the average of all entries.
`void`	`blend(double a, PdVector v, double b, PdVector w)` Interpolate between two vectors with given weights.
`void`	`blend(double a, PdVector u, double b, PdVector v, double c, PdVector w)` Interpolate between three vectors with given weights.
`void`	`blend(double a, PdVector u, double b, PdVector v, double c, PdVector w, double d, PdVector x)` Interpolate between four vectors with given weights.
`void`	`blendBase(PdVector u, double b, PdVector v)` Interpolate between two vectors with given weights.
`void`	`blendBase(PdVector u, double b, PdVector v, double c, PdVector w)` Interpolate between three vectors with given weights.
`static PdVector`	`blendNew(double a, PdVector v, double b, PdVector w)` Create a new vector `this = av + bw`.
`static PdVector`	`blendNew(double a, PdVector u, double b, PdVector v, double c, PdVector w)` Create a new vector `this = ua + vb + w*c`.
`static PdVector`	`blendNew(double a, PdVector u, double b, PdVector v, double c, PdVector w, double d, PdVector x)` Create a new vector `this = ua + vb + w*c + x'd`.
`int`	`changeValue(double oldValue, double newValue)` Change all occurrence of value oldValue to newValue COMPARE: changeValue(int, double, double) return number of changed positions
`int`	`changeValue(int usedSize, double oldValue, double newValue)` Change occurrence of value oldValue to newValue on first 'usedSize' positions difference to method changeValue(double, double): sometime we use vectors where only the first entries are used.
`java.lang.Object`	`clone()` Clone object and all instance variables.
`void`	`concat(PdVector pdv)` Concatenates another PdVector to the end of this vector.
`void`	`copy(double[] anArray, int aSize)` Copy a double array into a vector, and do not adjust size of dest vector.
`void`	`copy(double[] anArray, int srcPos, int aSize)` Copy part of a double array into a vector, and do not adjust size of dest vector.
`boolean`	`copy(int destInd, PdVector dataSrc, int srcInd, int size)` Copy part of the source vector into this vector, and adjust size of this vector only if it is too small.
`void`	`copy(PdVector v)` Copy a vector into a vector, and do not adjust size of dest vector.
`static boolean`	`copy(PdVector[] dataDest, int destInd, PdVector[] dataSrc, int srcInd, int size)` Copies some vectors of a given array of vectors into an existing destination array.
`void`	`copyArray(PdVector v)` Copy data array of source vector into this vector, and do not adjust size of dest vector.
`static PdVector[]`	`copyNew(double[][] data)` Create an new array with copies of all doubles of a given 2-dimensional array of numbers.
`static PdVector`	`copyNew(PdVector v)` Create a new vector as clone of argument vector.
`static PdVector[]`	`copyNew(PdVector[] data)` Create an new array with copies of all vectors of a given array of vectors.
`static PdVector[]`	`copyNew(PdVector[] data, int size)` Create an new array with copies of the first 'size' vectors of a given array of vectors.
`boolean`	`cross(PdVector v, PdVector w)` Compute cross product of given argument vectors.
`static PdVector`	`crossNew(PdVector v, PdVector w)` Create new vector with cross product of given argument vectors.
`static double`	`det(PdVector[] v)` Compute determinant of a frame of `n` vectors in `R^n`.
`static double`	`det(PdVector v, PdVector w, PdVector t)` Compute determinant of a frame of three vectors in `R^3`.
`double`	`dist(PdVector v)` Euclidean distance `dist = \|this-v\|`.
`static double`	`dist(PdVector v, PdVector w)` Distance of two points.
`double`	`dot(PdVector v)` Compute scalar product with argument vector.
`static double`	`dot(PdVector v, PdVector w)` Scalar product of two given vectors.
`static double`	`dot(PdVector p, PdVector q, PdVector r)` Scalar product of two vectors v:=q-p and w:=r-p determined by given vertices.
`static double`	`dotDir(PdVector v, PdVector q, PdVector p)` Scalar product of two vectors v and w:=q-p determined by given vertices.
`boolean`	`equals(double[] list)` Compare vector with list of doubles and return `false if different array lengths or a different entry.`
`boolean`	`equals(java.lang.Object obj)` Determines whether another vector or array of doubles is equal to this vector.
`boolean`	`equals(PdVector v)` Determines whether another vector is equal to this vector.
`boolean`	`equals(PdVector v, double eps)` Determines whether another vector is equal to this vector.
`static PdVector`	`flatten(PdVector[] data)` Flatten out array of vectors.
`static PdVector`	`flatten(PdVector[] data, PdVector flat)` Flatten out an array of vectors.
`double[]`	`getEntries()` Return a copy of the content of vector as array of doubles.
`static double[][]`	`getEntries(PdVector[] vArr)` Return content of array of vectors as matrix of doubles.
`double`	`getEntry(int ind)` Get the component of a vector.
`double`	`getFirstEntry()` Get the first component of a vector.
`double`	`getLastEntry()` Get the last component of a vector.
`static double`	`getOrientation(PdVector[] v)` Deprecated. since JavaView 2.92.000, use same method det().
`static int`	`getSameSize(PdVector[] vecArray, int numUsed)` Check of all vectors in array of vector have same length.
`int`	`getSize()` Get dimension of vector, i.e. length of its data array.
`int`	`indexOfAbsMax()` Find component in vector with maximal absolute value.
`int`	`indexOfAbsMin()` Find component in vector with minimal absolute value.
`int`	`indexOfMax()` Find component in vector with maximal value.
`int`	`indexOfMin()` Find component in vector with minimal value.
`int`	`indexOfValueInOrdering(double value)` Computes the index i of the first entry of vector with `v[i]<=value` in logarithmic time.
`void`	`invert()` Invert order of all entries, i.e. the first entry becomes the last entry.
`void`	`invert(int usedSize)` Invert order of the first 'usedSize' entries, i.e. the first entry becomes the 'usedSize-1' entry.
`void`	`invStereoProj(double x, double y)` Map point (x,y) in R2 onto unit sphere S2 in R3 using inverse of stereographic projection.
`void`	`leftMultAffin(PdMatrix m, PdVector v, boolean bPoint)` Multiply a point resp. vector with matrix `this = m*(v,1)` resp.
`PdVector`	`leftMultMatrix(PdMatrix m)` Multiply vector with matrix `this = m*this`.
`PdVector`	`leftMultMatrix(PdMatrix m, PdVector v)` Multiply vector with matrix `this = m*v`.
`double`	`length()` Get euclidean length of vector.
`static double`	`length(int num, double[] data)` Get euclidean length of vector.
`double`	`max()` Find maximal value of component in vector.
`boolean`	`max(PdVector vec)` Find the maximum of this and a comparison vector in each component and adjust the minimum in each component of this vector.
`static boolean`	`max(PdVector max, PdVector[] vecArr, int arrayLength)` Find the maximum of an array of vectors in each component.
`double`	`maxAbs()` Find maximal absolute value of component in vector.
`double`	`min()` Find minimal value of component in vector.
`boolean`	`min(PdVector vec)` Find the minimum of this and a comparison vector in each component and adjust the minimum in each component of this vector.
`static boolean`	`min(PdVector min, PdVector[] vecArr, int arrayLength)` Find the minimum of an array of vectors in each component.
`void`	`multScalar(double scalar)` Multiply vector with scalar `this = scalar*this`.
`void`	`multScalar(PdVector v, double scalar)` Multiply argument vector with scalar `this = scalar*v`.
`boolean`	`normalize()` Normalize vector to unit length.
`boolean`	`normalize(PdVector v)` Set vector to normalized argument vector.
`boolean`	`normalOfPlane(PdVector p, PdVector q, PdVector r)` Compute unit normal vector to a plane given by three points.
`void`	`normalToVector(PdVector v)` Compute an arbitrary vector orthonormal to a given unit vector v, assume \|v\|==1.
`static PdVector`	`normalToVectorNew(PdVector v)` Create a new arbitrary vector orthogonal to a given unit vector.
`void`	`orthogonalize(PdVector e)` Remove part of 'this' in direction of e, assume \|e\|=1, `v = v - <v,e>e`.
`PdVector`	`orthogonalPart(PdVector vCompl, PdVector e)` Remove part of 'this' in direction of e, assume \|e\|=1, `vCompl = v - <v,e>e`.
`PdVector`	`orthogonalPartWrtONB(PdVector e1, PdVector e2)` Return orthogonal part of 'this' w.r.t. e_i, assume \|e_i\|=1, < e_i,e_j >=0 v_compl = v - < v,e_1 > e_1 - < v,e_2 > e_2
`void`	`orthonormalize(PdVector e)` Remove part of 'this' in direction of e, assume \|e\|=1, `v = v - <v,e>e`, and normalize v.
`PdVector`	`projectOntoONB(PdVector e1, PdVector e2)` Project onto ONB e_i, assume \|e_i\|=1, <e_i, e_j> =0 v_proj = < v,e_1 > e_1 + < v,e_2 > e_2
`static PdVector[]`	`realloc(PdVector[] data, int arraySize)` Allocate an array of vectors.
`static PdVector[]`	`realloc(PdVector[] data, int arraySize, int vectorSize)` Allocate an array of vectors, where all vectors have the same dimension.
`void`	`removeEntry(int ind)` Remove an entry from the vector.
`void`	`removeSuccessiveDuplicates()` Removes all successive duplicate entries.
`void`	`rightMultMatrix(PdMatrix m)` Multiply vector with matrix `this = this*m`.
`void`	`rightMultMatrix(PdVector v, PdMatrix m)` Multiply vector with matrix `this = v*m`.
`static boolean`	`scale(PdVector[] bnd, PdVector[] vecArr, int arrayLength)` Affine scaling of an array of vectors to lie in a given bounding volume.
`void`	`set(double x)` Assign value to vector, and increase size of vector if necessary.
`void`	`set(double[] x)` Assign values of double array to vector, and adjust length of vector if different from length of array.
`void`	`set(double[] x, int len)` Assign first values of double array to vector, and adjust length of vector if different from argument len.
`void`	`set(double[] x, int from, int len)` Assign 'len' values of double array starting at 'from' to vector, and adjust length of vector if different from argument len.
`void`	`set(double x, double y)` Assign value to vector, and increase size of vector if necessary.
`void`	`set(double x, double y, double z)` Assign value to vector, and increase size of vector if necessary.
`void`	`set(double x, double y, double z, double w)` Assign value to vector, and increase size of vector if necessary.
`void`	`set(int[] x)` Assign values of vector from integer array, and adjust length of vector if different from length of array.
`void`	`set(int[] x, int len)` Assign first values of integer array to vector, and adjust length of vector if different from argument len.
`void`	`set(int[] x, int from, int len)` Assign 'len' values of integer array starting at 'from' to vector, and adjust length of vector if different from argument len.
`void`	`set(PdVector x, int from, int len)` Assign 'len' values of array starting at 'from' to vector, and adjust length of vector if different from argument len.
`void`	`setConstant(double aValue)` Set all entries to a constant value.
`static void`	`setConstant(PdVector[] vecArr, double aValue)` Set all components of all vectors of an array to a constant.
`static void`	`setConstant(PdVector[] vecArr, double[] data)` Set all vectors of an array equal to a given vector.
`static void`	`setConstant(PdVector[] vecArr, PdVector aVector)` Set all vectors of an array equal to a given vector.
`static void`	`setConstant(PdVector v, double aValue)` Set all entries to a constant value.
`void`	`setEntry(int ind, double value)` Assign value to component of vector, and possibly enlarge vector if too small.
`void`	`setEntry(int ind, int value)` Assign value to component of vector, and possibly enlarge vector if too small.
`void`	`setFirstEntry(double value)` Set the first component of a vector.
`void`	`setLastEntry(double value)` Set the last component of a vector.
`boolean`	`setLength(double aLength)` Set Euclidean length of vector.
`int`	`setSize(int aSize)` Set dimension of vector, i.e. length of its data array.
`void`	`shift(int num)` Shift components in cyclic order within the array.
`void`	`sort()` Sort entries of this vector in place by increasing size.
`PdVector`	`sort(PdVector vecOut)` Sort entries of this vector into argument vector by increasing size.
`double`	`sqrDist(PdVector v)` Square of euclidean distance `sqrDist = \|this-v\|^2`.
`static double`	`sqrDist(PdVector v, PdVector w)` Square of the distance of two points.
`double`	`sqrLength()` Get square of euclidean length of vector.
`void`	`sub(PdVector m)` Difference with argument vector `this = this-m`.
`void`	`sub(PdVector m1, PdVector m2)` Difference of argument vectors `this = m1-m2`.
`static PdVector`	`subNew(PdVector m1, PdVector m2)` Create a new vector as difference of argument vectors `new = m1-m2`.
`double`	`sum()` Compute the sum of all entries.
`java.lang.String`	`toShortString()` Create a single-line string representation of the vector components and attributes.
`java.lang.String`	`toString()` Create a multi-line string representation of the vector with detailed information about all instance variables.
`double`	`variance()` Compute the variance of the entries of a PdVector.

Methods inherited from class jv.vecmath.P_Vector
clearTag, clone, clone, copy, getBits, getDetail, getName, getURL, hasTag, invert, setDetail, setName, setTag, setURL

Methods inherited from class java.lang.Object
getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - m_data
```
public double[] m_data
```
    Data array containing the components of the vector. Array has public access for efficiency reasons in numerical computations, although method access should be preferred. Do not modify length of array directly.
- Constructor Detail
  - PdVector
```
public PdVector()
```
    Construct vector with zero size.
  - PdVector
```
public PdVector(int aSize)
```
    Constructor creating a vector with given dimension.
  - PdVector
```
public PdVector(double x)
```
    Constructs a vector of length 1 and given initial data.
  - PdVector
```
public PdVector(double x,
        double y)
```
    Constructs a vector of length 2 and given initial data.
  - PdVector
```
public PdVector(double x,
        double y,
        double z)
```
    Constructs a vector of length 3 and given initial data.
  - PdVector
```
public PdVector(double x,
        double y,
        double z,
        double w)
```
    Constructs a vector of length 4 and given initial data.
  - PdVector
```
public PdVector(double[] x)
```
    Constructs a vector having same length and given initial data as given array.
- Method Detail
  - clone
```
public java.lang.Object clone()
```
    Clone object and all instance variables. Similar like copyNew(PdVector) but this clone() method is consistent with possible subclasses while copyNew() explicitly creates a new PdVector.
    
    Overrides:
    
    clone in class java.lang.Object
    
    See Also:
    copyNew(PdVector)
  - getEntries
```
public static double[][] getEntries(PdVector[] vArr)
```
    Return content of array of vectors as matrix of doubles.
    
    Parameters:
    vArr - Array of vectors
    
    Returns:
    2-dimensional matrix of doubles
  - alloc
```
public static PdVector[][] alloc(int sizeI,
                 int sizeJ,
                 int vectorSize)
```
    Allocate a new array of vectors, where all vectors have the same dimension.
    
    Parameters:
    sizeI - number of rows in new array
    sizeJ - number of columns in row[i] in new array
    vectorSize - dimension of vectors in new array
    See Also:
    realloc(PdVector [], int, int)
  - realloc
```
public static PdVector[] realloc(PdVector[] data,
                 int arraySize,
                 int vectorSize)
```
    Allocate an array of vectors, where all vectors have the same dimension. If argument data!=null then as most as possible of the content of existing vectors is copied into (possibly reused) vectors of the reallocated array.
    If requested array size is 0 then method returns an array of length 0.
    
    Parameters:
    data - possibly empty array of vectors
    arraySize - number of vectors in new array
    vectorSize - dimension of vectors in new array
    See Also:
    realloc(PdVector [], int)
  - realloc
```
public static PdVector[] realloc(PdVector[] data,
                 int arraySize)
```
    Allocate an array of vectors. If argument data!=null then as most as possible of the existing vectors are reused in the reallocated array. New vectors are allocated with dimension zero.
    If requested array size is 0 then method returns an array of length 0.
    
    Parameters:
    data - possibly empty array of vectors
    arraySize - number of vectors in new array
    See Also:
    realloc(PdVector [], int, int)
  - copyNew
```
public static PdVector[] copyNew(double[][] data)
```
    Create an new array with copies of all doubles of a given 2-dimensional array of numbers. Each row of argument vector is stored in a vector. Rows may have different length. A row with length zero leads to a warning message, and allocates a vector with length zero.
    
    Parameters:
    data - 2-dimensional array of numbers
    
    Returns:
    new array with same number of vectors as rows of argument array
    See Also:
    copyNew(PdVector [], int), copy(PdVector [], int, PdVector [], int, int)
  - copyNew
```
public static PdVector[] copyNew(PdVector[] data)
```
    Create an new array with copies of all vectors of a given array of vectors. The new array contains new vectors containing the same data as the original vectors.
    
    Parameters:
    data - array of vectors
    
    Returns:
    new array with same number of vectors as argument array
    See Also:
    copyNew(PdVector [], int), copy(PdVector [], int, PdVector [], int, int)
  - copyNew
```
public static PdVector[] copyNew(PdVector[] data,
                 int size)
```
    Create an new array with copies of the first 'size' vectors of a given array of vectors. The new array contains new vectors containing the same data as the original vectors.
    
    Parameters:
    data - array of vectors
    size - number of copied vectors of array
    
    Returns:
    new array with number of vectors equal to argument 'size'
    See Also:
    copyNew(PdVector []), copy(PdVector [], int, PdVector [], int, int)
  - copy
```
public static boolean copy(PdVector[] dataDest,
           int destInd,
           PdVector[] dataSrc,
           int srcInd,
           int size)
```
    Copies some vectors of a given array of vectors into an existing destination array. All vectors in source and destination array must exist already.
```
   for (int i=0; i
 Destination array must be large enough, i.e. dataDest.length >= destInd+size.
```
    Parameters:
    dataDest - destination array of vectors
    destInd - index of first destination vector in dataDest
    dataSrc - source array of vectors
    srcInd - index of first source vector in dataSrc used for copying
    size - number of copied vectors of array
    
    Returns:
    true if destination array is large enough
    See Also:
    copy(PdVector)
  - getSameSize
```
public static int getSameSize(PdVector[] vecArray,
              int numUsed)
```
    Check of all vectors in array of vector have same length.
    
    Returns:
    same length, or -1 if different or no entries.
  - scale
```
public static final boolean scale(PdVector[] bnd,
            PdVector[] vecArr,
            int arrayLength)
```
    Affine scaling of an array of vectors to lie in a given bounding volume. All vectors must have the same size.
    
    Parameters:
    bnd - bounding volume
    vecArr - array of vectors
    arrayLength - number of used vectors of array
    Since:
    
    JavaView 2.45
  - min
```
public static final boolean min(PdVector min,
          PdVector[] vecArr,
          int arrayLength)
```
    Find the minimum of an array of vectors in each component. Vectors of array may have different length. Any comparison is between the resulting vector and a vector of the array is done for the common number of components.
    
    Parameters:
    min - computed minimum
    vecArr - array of vectors
    arrayLength - number of used vectors of array
    See Also:
    min(PdVector), max(PdVector, PdVector [], int)
  - max
```
public static final boolean max(PdVector max,
          PdVector[] vecArr,
          int arrayLength)
```
    Find the maximum of an array of vectors in each component. Vectors of array may have different length. Any comparison is between the resulting vector and a vector of the array is done for the common number of components.
    
    Parameters:
    max - computed maximum
    vecArr - array of vectors
    arrayLength - number of used vectors of array
    See Also:
    min(PdVector, PdVector [], int), max(PdVector)
  - min
```
public boolean min(PdVector vec)
```
    Find the minimum of this and a comparison vector in each component and adjust the minimum in each component of this vector. Vectors of different length are adjusted at all common components.
    
    Parameters:
    vec - comparison vector
    See Also:
    min(PdVector, PdVector [], int), max(PdVector)
  - max
```
public boolean max(PdVector vec)
```
    Find the maximum of this and a comparison vector in each component and adjust the minimum in each component of this vector. Vectors of different length are adjusted at all common components.
    
    Parameters:
    vec - comparison vector
    See Also:
    max(PdVector, PdVector [], int), min(PdVector)
  - setConstant
```
public static void setConstant(PdVector[] vecArr,
               double aValue)
```
    Set all components of all vectors of an array to a constant.
  - setConstant
```
public static void setConstant(PdVector[] vecArr,
               double[] data)
```
    Set all vectors of an array equal to a given vector. All vectors of argument array must have same length.
  - setConstant
```
public static void setConstant(PdVector[] vecArr,
               PdVector aVector)
```
    Set all vectors of an array equal to a given vector. All vectors of argument array must have same length.
  - setConstant
```
public static void setConstant(PdVector v,
               double aValue)
```
    Set all entries to a constant value.
  - setConstant
```
public void setConstant(double aValue)
```
    Set all entries to a constant value.
  - getOrientation
```
public static double getOrientation(PdVector[] v)
```
    Deprecated. since JavaView 2.92.000, use same method det().
    
    Compute orientation of a frame of n vectors in R^n.
    
    Returns:
    double determinant of vectors
  - det
```
public static double det(PdVector[] v)
```
    Compute determinant of a frame of n vectors in R^n. This method allocates a temporary matrix and returns PdMatrix.det(). See det(PdVector, PdVector, PdVector) for a direct method.
    
    Returns:
    double determinant of vectors
  - det
```
public static double det(PdVector v,
         PdVector w,
         PdVector t)
```
    Compute determinant of a frame of three vectors in R^3. No intermediate memory allocations. See det(PdVector []) for another method.
    
    Parameters:
    v - Vector in R3.
    w - Vector in R3.
    t - Vector in R3.
    
    Returns:
    double determinant of vectors
    Since:
    
    JavaView 2.92.000
  - area
```
public static double area(PdVector p,
          PdVector q,
          PdVector r)
```
    Compute area of triangle spanned by vertices {p,q,r} in some R^m. TODO: method could be made faster by using simplex formula: area = 1/2 * sqrt(det(df*df)).
  - area
```
public static double area(PdVector[] p)
```
    Compute area of planar n-gon spanned by vertices p[] in some R^m. Total area is computed as sum of area of triangles {p[0],p[j-1],p[j]}. TODO: method could be made faster by using simplex formula: area = 1/fak(m) * sqrt(det(df*df)).
  - angle
```
public static double angle(PdVector p,
           PdVector q,
           PdVector r)
```
    Compute angle of triangle (p, q, r) at vertex p. The Result will be in the range (0.,180.).
  - angle
```
public static void angle(double[] angle,
         PdVector p,
         PdVector q,
         PdVector r)
```
    Compute interior angles at all three vertices of a triangle. Angle values will be in the range (0, pi).
  - angle
```
public static void angle(double[] angle,
         PdVector[] p)
```
    Compute interior angles at all vertices of a convex polygon. Angle values will be in the range (0, pi).
  - angleWithOrientation
```
public static double angleWithOrientation(double[] angle,
                          PdVector[] p,
                          int len)
```
    Compute exterior angles in radians at vertices of a (possibly non-convex) polygon. If p0, p1, p2 are three successive vertices with edges v = p1-p0 and w = p2-p1 then the exterior vertex angle is angle = sign*acos(). The sign is positive at convex vertices and negative at concave vertices, and angles are in [-PI, PI].
    For a closed polygon the total sum of all angles is positive. For planar closed polygon it is windingNumber*2PI.
    
    Parameters:
    angle - array will contain the computed angles.
    p - array with given polygon vertices.
    len - used number of entries of both arrays.
    
    Returns:
    sum of all vertex angles in radians.
  - angle
```
public static double angle(PdVector v,
           PdVector w)
```
    Compute angle between two vectors in (0.,180.). All vectors must have same but arbitrary dimension.
    
    Returns:
    angle in (0.,180.), or 0. in case of error.
  - angleWithOrientation
```
public static double angleWithOrientation(PdVector v,
                          PdVector w,
                          PdVector orient)
```
    Compute signed angle in radians between two vectors depending on the orientation. Sign of angle is equal to orientation of frame (v,w,orient).
    
    Parameters:
    v - vector in R^2 or R^3
    w - vector in R^2 or R^3
    orient - vector in R^3
    
    Returns:
    angle in radians in (-pi,pi), or 0. in case of error.
  - dot
```
public static double dot(PdVector v,
         PdVector w)
```
    Scalar product of two given vectors.
    
    Parameters:
    v - vector
    w - vector
    
    Returns:
    scalar product
  - dot
```
public static double dot(PdVector p,
         PdVector q,
         PdVector r)
```
    Scalar product of two vectors v:=q-p and w:=r-p determined by given vertices.
    
    Parameters:
    p - base point
    q - end point of vector with base p
    r - end point of vector with base p
    
    Returns:
    scalar product
    Since:
    
    JavaView 2.46
  - dotDir
```
public static double dotDir(PdVector v,
            PdVector q,
            PdVector p)
```
    Scalar product of two vectors v and w:=q-p determined by given vertices.
    
    Parameters:
    v - first vector
    q - end point of second vector with base p
    p - base point of second vector with end q
    
    Returns:
    scalar product
    Since:
    
    JavaView 3.97.058
  - sqrDist
```
public static double sqrDist(PdVector v,
             PdVector w)
```
    Square of the distance of two points.
  - dist
```
public static double dist(PdVector v,
          PdVector w)
```
    Distance of two points.
  - flatten
```
public static PdVector flatten(PdVector[] data)
```
    Flatten out array of vectors. The returned vector contains the entries of all vectors of the input array.
    
    Parameters:
    data - array of vectors
    
    Returns:
    new vector containing the entries of all vectors of the input array
  - flatten
```
public static PdVector flatten(PdVector[] data,
               PdVector flat)
```
    Flatten out an array of vectors. The returned vector contains the entries of all vectors of the input array.
    
    Parameters:
    data - array of vectors
    flat - vector is returned, if argument is null a vector is created
    
    Returns:
    vector containing the entries of all vectors of the input array
  - getSize
```
public int getSize()
```
    Get dimension of vector, i.e. length of its data array.
  - setSize
```
public int setSize(int aSize)
```
    Set dimension of vector, i.e. length of its data array.
    
    Parameters:
    aSize - new number of components of vector
    
    Returns:
    new number of components of vector
  - getEntries
```
public double[] getEntries()
```
    Return a copy of the content of vector as array of doubles.
  - getEntry
```
public double getEntry(int ind)
```
    Get the component of a vector.
  - setEntry
```
public void setEntry(int ind,
            double value)
```
    Assign value to component of vector, and possibly enlarge vector if too small.
    
    Parameters:
    ind - index of component.
    value - new value of component.
  - setEntry
```
public void setEntry(int ind,
            int value)
```
    Assign value to component of vector, and possibly enlarge vector if too small.
    
    Parameters:
    ind - index of component.
    value - new value of component.
    See Also:
    setEntry(int, double)
  - getFirstEntry
```
public double getFirstEntry()
```
    Get the first component of a vector.
    
    Returns:
    value of the first component.
  - setFirstEntry
```
public void setFirstEntry(double value)
```
    Set the first component of a vector.
    
    Parameters:
    value - new value of first component
  - getLastEntry
```
public double getLastEntry()
```
    Get the last component of a vector.
    
    Returns:
    value of the last component.
  - setLastEntry
```
public void setLastEntry(double value)
```
    Set the last component of a vector.
    
    Parameters:
    value - new value of last component
  - addEntry
```
public int addEntry(double val)
```
    Add another entry at the end of the vector and increment size of vector.
    
    Parameters:
    val - value to be added
    
    Returns:
    index of new last entry.
  - removeEntry
```
public void removeEntry(int ind)
```
    Remove an entry from the vector. All successive entries will be copied.
    
    Parameters:
    ind - Index of the entry to remove.
  - concat
```
public void concat(PdVector pdv)
```
    Concatenates another PdVector to the end of this vector.
    
    Parameters:
    pdv - Vector to append to this one.
  - set
```
public void set(PdVector x,
       int from,
       int len)
```
    Assign 'len' values of array starting at 'from' to vector, and adjust length of vector if different from argument len.
  - set
```
public void set(double[] x,
       int from,
       int len)
```
    Assign 'len' values of double array starting at 'from' to vector, and adjust length of vector if different from argument len.
  - set
```
public void set(double[] x,
       int len)
```
    Assign first values of double array to vector, and adjust length of vector if different from argument len.
  - set
```
public void set(double[] x)
```
    Assign values of double array to vector, and adjust length of vector if different from length of array.
  - set
```
public void set(int[] x,
       int from,
       int len)
```
    Assign 'len' values of integer array starting at 'from' to vector, and adjust length of vector if different from argument len.
    
    See Also:
    set(double [], int, int)
  - set
```
public void set(int[] x,
       int len)
```
    Assign first values of integer array to vector, and adjust length of vector if different from argument len.
    
    See Also:
    set(double [], int)
  - set
```
public void set(int[] x)
```
    Assign values of vector from integer array, and adjust length of vector if different from length of array.
    
    See Also:
    set(double [])
  - set
```
public void set(double x)
```
    Assign value to vector, and increase size of vector if necessary.
  - set
```
public void set(double x,
       double y)
```
    Assign value to vector, and increase size of vector if necessary.
  - set
```
public void set(double x,
       double y,
       double z)
```
    Assign value to vector, and increase size of vector if necessary.
  - set
```
public void set(double x,
       double y,
       double z,
       double w)
```
    Assign value to vector, and increase size of vector if necessary.
  - changeValue
```
public int changeValue(int usedSize,
              double oldValue,
              double newValue)
```
    Change occurrence of value oldValue to newValue on first 'usedSize' positions difference to method changeValue(double, double): sometime we use vectors where only the first entries are used. The other entries are not used and initialized to zero. If by chance 'oldValue' is zero then these initialization would be spoiled, which is very error prone. return number of changed positions
  - changeValue
```
public int changeValue(double oldValue,
              double newValue)
```
    Change all occurrence of value oldValue to newValue COMPARE: changeValue(int, double, double) return number of changed positions
  - shift
```
public void shift(int num)
```
    Shift components in cyclic order within the array.
    
    Parameters:
    num - Number of positions each component is shifted.
    See Also:
    invert()
  - invert
```
public void invert(int usedSize)
```
    Invert order of the first 'usedSize' entries, i.e. the first entry becomes the 'usedSize-1' entry.
    
    See Also:
    invert()
  - invert
```
public void invert()
```
    Invert order of all entries, i.e. the first entry becomes the last entry.
    
    See Also:
    invert(int)
  - add
```
public void add(double val)
```
    Add argument to each component of vector.
  - add
```
public void add(PdVector m)
```
    Sum with argument vector this += m. Both must be of same size.
  - add
```
public void add(double scale,
       PdVector v)
```
    Add scale*v to this. If result vector 'this' is empty then its size is set to length of vector 'v'. Otherwise, 'this' and v must be of same size.
    
    Parameters:
    v - vector to add to 'this'
    scale - weight of vector v
    See Also:
    add(PdVector), add(PdVector, PdVector), blendBase(PdVector, double, PdVector), blend(double, PdVector, double, PdVector)
  - add
```
public void add(PdVector m1,
       PdVector m2)
```
    Sum of argument vectors this = m1+m2. m1, m2 and this must be of same size.
  - sub
```
public void sub(PdVector m)
```
    Difference with argument vector this = this-m. Vectors m and this must be of same size.
  - sub
```
public void sub(PdVector m1,
       PdVector m2)
```
    Difference of argument vectors this = m1-m2. Vectors must be of same size.
  - addNew
```
public static PdVector addNew(PdVector m1,
              PdVector m2)
```
    Create a new vector as sum of argument vectors new = m1+m2.
  - subNew
```
public static PdVector subNew(PdVector m1,
              PdVector m2)
```
    Create a new vector as difference of argument vectors new = m1-m2. If sizes differ then a warning is thrown and a vector of minimal common size returned.
  - copyNew
```
public static PdVector copyNew(PdVector v)
```
    Create a new vector as clone of argument vector.
    
    Parameters:
    v - source vector to clone
  - copy
```
public boolean copy(int destInd,
           PdVector dataSrc,
           int srcInd,
           int size)
```
    Copy part of the source vector into this vector, and adjust size of this vector only if it is too small.
    
    See Also:
    copy(PdVector)
  - copy
```
public void copy(PdVector v)
```
    Copy a vector into a vector, and do not adjust size of dest vector. If destination vector is empty then allocated space of size of source vector. If source and destination vectors have different size then use the minimum of both sizes. If destination vector is bigger than source then reset the additional entries in destination vector with 0.
    
    Parameters:
    v - source vector to copy
    See Also:
    copy(int,PdVector,int,int)
  - copyArray
```
public void copyArray(PdVector v)
```
    Copy data array of source vector into this vector, and do not adjust size of dest vector. In contrast to copy(PdVector) this method does not invoke the copy method of the superclass. If destination vector is empty then allocated space of size of source vector. If source and destination vectors have different size then use the minimum of both sizes for copying. If destination vector is bigger than source then reset the additional entries in destination vector with 0.
    
    Parameters:
    v - source vector to copy
    See Also:
    copy(PdVector)
  - copy
```
public void copy(double[] anArray,
        int aSize)
```
    Copy a double array into a vector, and do not adjust size of dest vector. If destination vector is empty then allocated space of size of source array. If source and destination vectors have different size then use the minimum of both sizes. If destination vector is bigger than source then reset the additional entries in destination vector with 0.
    
    See Also:
    copy(int,PdVector,int,int), copy(double [], int, int)
  - copy
```
public void copy(double[] anArray,
        int srcPos,
        int aSize)
```
    Copy part of a double array into a vector, and do not adjust size of dest vector. If destination vector is empty then allocated space of size of source array. If parameter size and length of destination vectors are different then use the minimum of both sizes. If destination vector is bigger than argument size then reset the additional entries in destination vector with 0.
    
    Parameters:
    anArray - array of doubles
    srcPos - first position in array used for copying
    aSize - number of entries to copy.
    See Also:
    copy(double [], int)
  - multScalar
```
public void multScalar(double scalar)
```
    Multiply vector with scalar this = scalar*this.
  - multScalar
```
public void multScalar(PdVector v,
              double scalar)
```
    Multiply argument vector with scalar this = scalar*v. Vectors v and this must be of same size.
  - leftMultMatrix
```
public PdVector leftMultMatrix(PdMatrix m)
```
    Multiply vector with matrix this = m*this. Matrix must be square and of same size than vector. Method does not change size of 'this'!
    
    Returns:
    this vector
  - leftMultAffin
```
public void leftMultAffin(PdMatrix m,
                 PdVector v,
                 boolean bPoint)
```
    Multiply a point resp. vector with matrix this = m*(v,1) resp. this = m*(v,0). Matrix need not be square but must have equal or more lines than the size of this vector, and exactly one more columns than the size of the argument vector.
    
    Parameters:
    m - Transformation matrix, square.
    v - source vector whose dimension is 1 smaller than m.
    bPoint - if true then v is a point else a vector
  - leftMultMatrix
```
public PdVector leftMultMatrix(PdMatrix m,
                      PdVector v)
```
    Multiply vector with matrix this = m*v. Matrix need not be square. Argument vector must have same size as number of columns of matrix. Method modifies size of this vector to number of rows of matrix.
    
    Returns:
    this
  - rightMultMatrix
```
public void rightMultMatrix(PdMatrix m)
```
    Multiply vector with matrix this = this*m. Matrix must be square and have the same size as than this vector. Method does not change size of this vector!
  - rightMultMatrix
```
public void rightMultMatrix(PdVector v,
                   PdMatrix m)
```
    Multiply vector with matrix this = v*m. Matrix need not be square. Argument vector must have same size as number of rows of matrix. Method modifies size of vector to number of columns of matrix.
  - dot
```
public double dot(PdVector v)
```
    Compute scalar product with argument vector. Vectors must be of same size.
  - sqrLength
```
public double sqrLength()
```
    Get square of euclidean length of vector.
  - length
```
public double length()
```
    Get euclidean length of vector.
  - length
```
public static double length(int num,
            double[] data)
```
    Get euclidean length of vector.
    
    Parameters:
    num - number of components to be used from data array
    data - array whose euclidean length is returned
  - normalize
```
public boolean normalize()
```
    Normalize vector to unit length. In case of error, for example, if length of vector is too small then return false and set the maximal coordinate to 1.
  - normalize
```
public boolean normalize(PdVector v)
```
    Set vector to normalized argument vector.
  - setLength
```
public boolean setLength(double aLength)
```
    Set Euclidean length of vector. If current vector has zero length then the highest components is assigned the requested length.
  - blendNew
```
public static PdVector blendNew(double a,
                PdVector v,
                double b,
                PdVector w)
```
    Create a new vector this = a*v + b*w.
    
    Parameters:
    a - weight of first vector
    v - first vector
    b - weight of second vector
    w - second vector
    See Also:
    blend(double, PdVector, double, PdVector), blendBase(PdVector, double, PdVector)
  - blendNew
```
public static PdVector blendNew(double a,
                PdVector u,
                double b,
                PdVector v,
                double c,
                PdVector w)
```
    Create a new vector this = u*a + v*b + w*c.
    
    Parameters:
    a - weight of first vector
    u - first vector
    b - weight of second vector
    v - second vector
    c - weight of third vector
    w - third vector
    See Also:
    blend(double, PdVector, double, PdVector, double, PdVector)
  - blendNew
```
public static PdVector blendNew(double a,
                PdVector u,
                double b,
                PdVector v,
                double c,
                PdVector w,
                double d,
                PdVector x)
```
    Create a new vector this = u*a + v*b + w*c + x'd.
    
    Parameters:
    a - weight of first vector
    u - first vector
    b - weight of second vector
    v - second vector
    c - weight of third vector
    w - third vector
    d - weight of fourth vector
    x - fourth vector
    See Also:
    blend(double, PdVector, double, PdVector, double, PdVector, double, PdVector)
  - blend
```
public void blend(double a,
         PdVector v,
         double b,
         PdVector w)
```
    Interpolate between two vectors with given weights. Uses this = v*a + w*b. If result vector 'this' is empty then its size is set to length of vector v, otherwise interpolation is done up to length of result vector.
    
    Parameters:
    a - weight of first vector
    v - first vector
    b - weight of second vector
    w - second vector
    See Also:
    blendBase(PdVector, double, PdVector), blendNew(double, PdVector, double, PdVector)
  - blend
```
public void blend(double a,
         PdVector u,
         double b,
         PdVector v,
         double c,
         PdVector w)
```
    Interpolate between three vectors with given weights. Uses this = u*a + v*b + w*c. If result vector 'this' is empty then its size is set to length of vector v, otherwise interpolation is done up to length of result vector.
    
    Parameters:
    a - weight of first vector
    u - first vector
    b - weight of second vector
    v - second vector
    c - weight of third vector
    w - third vector
    See Also:
    blendNew(double, PdVector, double, PdVector, double, PdVector)
  - blend
```
public void blend(double a,
         PdVector u,
         double b,
         PdVector v,
         double c,
         PdVector w,
         double d,
         PdVector x)
```
    Interpolate between four vectors with given weights. Uses this = u*a + v*b + w*c + x*d. If result vector 'this' is empty then its size is set to length of vector v, otherwise interpolation is done up to length of result vector.
    
    Parameters:
    a - weight of first vector
    u - first vector
    b - weight of second vector
    v - second vector
    c - weight of third vector
    w - third vector
    d - weight of fourth vector
    x - fourth vector
    See Also:
    blendNew(double, PdVector, double, PdVector, double, PdVector, double, PdVector)
  - blendBase
```
public void blendBase(PdVector u,
             double b,
             PdVector v)
```
    Interpolate between two vectors with given weights. Uses this = u + b*v. If result vector 'this' is empty then its size is set to length of vector u, otherwise interpolation is done up to length of result vector.
    
    Parameters:
    u - first vector
    b - weight of second vector
    v - second vector
    See Also:
    blend(double, PdVector, double, PdVector), blendNew(double, PdVector, double, PdVector)
  - blendBase
```
public void blendBase(PdVector u,
             double b,
             PdVector v,
             double c,
             PdVector w)
```
    Interpolate between three vectors with given weights. Uses this = u + b*v + c*w. If result vector 'this' is empty then its size is set to length of vector u, otherwise interpolation is done up to length of result vector.
    
    Parameters:
    u - first vector (base)
    b - weight of second vector
    v - second vector
    c - weight of third vector
    w - third vector
    Since:
    
    JavaView 3.99.002
    
    See Also:
    blend(double, PdVector, double, PdVector, double, PdVector), blendNew(double, PdVector, double, PdVector, double, PdVector), blendBase(PdVector, double, PdVector)
  - dist
```
public double dist(PdVector v)
```
    Euclidean distance dist = |this-v|.
  - sqrDist
```
public double sqrDist(PdVector v)
```
    Square of euclidean distance sqrDist = |this-v|^2.
  - max
```
public double max()
```
    Find maximal value of component in vector.
    
    Returns:
    value of maximal component, or zero if empty vector.
    See Also:
    min(), indexOfMax(), indexOfAbsMax()
  - maxAbs
```
public double maxAbs()
```
    Find maximal absolute value of component in vector.
    
    Returns:
    absolute value of maximal absolute component, or zero if empty vector.
    See Also:
    min(), indexOfMax(), indexOfAbsMax()
  - min
```
public double min()
```
    Find minimal value of component in vector.
    
    Returns:
    value of minimal component, or zero if empty vector.
    See Also:
    max(), indexOfMin(), indexOfAbsMin()
  - indexOfAbsMax
```
public int indexOfAbsMax()
```
    Find component in vector with maximal absolute value. If the maximum is not unique, the smallest index among the maxima is returned.
    
    Returns:
    index of maximal absolute component, or -1 if empty vector.
    See Also:
    max(), indexOfMax()
  - indexOfAbsMin
```
public int indexOfAbsMin()
```
    Find component in vector with minimal absolute value.
    
    Returns:
    index of minimal absolute component, or -1 if empty vector.
    See Also:
    min(), indexOfMin()
  - indexOfMax
```
public int indexOfMax()
```
    Find component in vector with maximal value.
    
    Returns:
    index of maximal component, or -1 if empty vector.
    See Also:
    indexOfAbsMax()
  - indexOfMin
```
public int indexOfMin()
```
    Find component in vector with minimal value.
    
    Returns:
    index of minimal component, or -1 if empty vector.
    See Also:
    indexOfAbsMin()
  - indexOfValueInOrdering
```
public int indexOfValueInOrdering(double value)
```
    Computes the index i of the first entry of vector with v[i]<=value in logarithmic time. Vector must be sort by increasing values.
    
    Parameters:
    value - Find position of this value in order vector.
    
    Returns:
    Index of the first entry of vector with v[i]<=value or -1 if value is smaller than minimum value of vector.
  - sum
```
public double sum()
```
    Compute the sum of all entries.
  - average
```
public double average()
```
    Compute the average of all entries. Return 0 if this vector has no entries.
    
    Returns:
    Average of all entries if size is > 0, and 0 otherwise.
  - variance
```
public double variance()
```
    Compute the variance of the entries of a PdVector. Return 0 if this vector has no entries.
  - sort
```
public PdVector sort(PdVector vecOut)
```
    Sort entries of this vector into argument vector by increasing size. If the size of this vector is small (currently < 10) then bubble sort is used to avoid memory allocations. For larger sizes PuMath.heapsort(int,int[],int[]) is used.
    If missing or has different size then this, then size of vecOut is adjusted.
    
    See Also:
    sort()
  - sort
```
public void sort()
```
    Sort entries of this vector in place by increasing size. If the size of this vector is small (currently < 10) then bubble sort is used to avoid memory allocations. For larger sizes PuMath.heapsort(int,int[],int[]) is used.
    
    See Also:
    sort(PdVector)
  - cross
```
public boolean cross(PdVector v,
            PdVector w)
```
    Compute cross product of given argument vectors. Argument vectors may have different dimensions in {2,3}. Missing dimensions are considered to be zero.
    Dimension of 'this' must be 3.
    'this' may be one of the argument vectors.
    
    Parameters:
    v - vector of (possibly mixed) dimensions 2 or 3.
    w - vector of (possibly mixed) dimensions 2 or 3.
    
    Returns:
    false, if dimension of this or argument vectors wrong.
    See Also:
    crossNew(PdVector, PdVector)
  - crossNew
```
public static PdVector crossNew(PdVector v,
                PdVector w)
```
    Create new vector with cross product of given argument vectors. Argument vectors may have different dimensions in {2,3}. Missing dimensions are considered to be zero.
    
    Parameters:
    v - w,v: two vectors of (possibly mixed) dimensions 2 or 3.
    w - w,v: two vectors of (possibly mixed) dimensions 2 or 3.
    
    Returns:
    new vector of dimension 3.
    See Also:
    cross(PdVector, PdVector)
  - invStereoProj
```
public void invStereoProj(double x,
                 double y)
```
    Map point (x,y) in R2 onto unit sphere S2 in R3 using inverse of stereographic projection.
  - orthogonalize
```
public void orthogonalize(PdVector e)
```
    Remove part of 'this' in direction of e, assume |e|=1, v = v - <v,e>e. This vector will be orthogonal to vector e, or the zero vector.
    
    Parameters:
    e - unit vector.
  - orthonormalize
```
public void orthonormalize(PdVector e)
```
    Remove part of 'this' in direction of e, assume |e|=1, v = v - <v,e>e, and normalize v. This vector will be orthonormal to vector e, or the zero vector.
    
    Parameters:
    e - unit vector.
  - orthogonalPart
```
public PdVector orthogonalPart(PdVector vCompl,
                      PdVector e)
```
    Remove part of 'this' in direction of e, assume |e|=1, vCompl = v - <v,e>e. Returned vector will be orthogonal to vector e, or the zero vector.
    
    Parameters:
    vCompl - result vector, may be this vector. If null then it will be allocated.
    e - unit vector.
    
    Returns:
    complement vector will be orthogonal to e, or the zero vector.
  - orthogonalPartWrtONB
```
public PdVector orthogonalPartWrtONB(PdVector e1,
                            PdVector e2)
```
    Return orthogonal part of 'this' w.r.t. e_i, assume |e_i|=1, < e_i,e_j >=0 v_compl = v - < v,e_1 > e_1 - < v,e_2 > e_2
    
    Parameters:
    e1 - unit vector.
    e2 - unit vector.
    
    Returns:
    complement vector will be orthogonal to e1 and e2, or the zero vector.
  - projectOntoONB
```
public PdVector projectOntoONB(PdVector e1,
                      PdVector e2)
```
    Project onto ONB e_i, assume |e_i|=1, <e_i, e_j> =0 v_proj = < v,e_1 > e_1 + < v,e_2 > e_2
  - normalOfPlane
```
public boolean normalOfPlane(PdVector p,
                    PdVector q,
                    PdVector r)
```
    Compute unit normal vector to a plane given by three points.
    
    Returns:
    false if cross product failed or normalization.
  - normalToVector
```
public void normalToVector(PdVector v)
```
    Compute an arbitrary vector orthonormal to a given unit vector v, assume |v|==1. Adjust size of this vector to size of argument vector.
  - normalToVectorNew
```
public static PdVector normalToVectorNew(PdVector v)
```
    Create a new arbitrary vector orthogonal to a given unit vector.
  - equals
```
public boolean equals(double[] list)
```
    Compare vector with list of doubles and return false if different array lengths or a different entry. Determines whether a list of doubles is equal to data of this vector. The result is true if both arrays have same length and equal components. Result is also true if argument vector is null and this vector has no entries.
    Parameters: list - the list of doubles to compare with Returns: true if the objects are the same; false otherwise.
  equals public boolean equals(java.lang.Object obj) Determines whether another vector or array of doubles is equal to this vector. Overrides: equals in class java.lang.Object Since: JavaView 3.62.012 See Also: equals(double[]), equals(PdVector), Object.equals(java.lang.Object) equals public boolean equals(PdVector v) Determines whether another vector is equal to this vector. The result is true if both vectors have same length and equal components. Result is also true if argument vector is null and this vector has no entries. Parameters: v - the vector to compare with Returns: true if the objects are the same; false otherwise. equals public boolean equals(PdVector v, double eps) Determines whether another vector is equal to this vector. The result is true if both vectors have same length and the euclidean distance is smaller or equal than a given distance. Result is also true if argument vector is null and this vector has no entries. Parameters: v - the vector to compare with eps - distance for equality check Returns: true if the objects are the same; false otherwise. toString public java.lang.String toString() Create a multi-line string representation of the vector with detailed information about all instance variables. Overrides: toString in class P_Vector See Also: toShortString() toShortString public java.lang.String toShortString() Create a single-line string representation of the vector components and attributes. See Also: toString() removeSuccessiveDuplicates public void removeSuccessiveDuplicates() Removes all successive duplicate entries. Call sort() before, if you want to remove all duplicates.

Class PdVector

Field Summary

Constructor Summary

Method Summary

Methods inherited from class jv.vecmath.P_Vector

Methods inherited from class java.lang.Object

Field Detail

m_data

Constructor Detail

PdVector

PdVector

PdVector

PdVector

PdVector

PdVector

PdVector

Method Detail

clone

getEntries

alloc

realloc

realloc

copyNew

copyNew

copyNew

copy

getSameSize

scale

min

max

min

max

setConstant

setConstant

setConstant

setConstant

setConstant

getOrientation

det

det

area

area

angle

angle

angle

angleWithOrientation

angle

angleWithOrientation

dot

dot

dotDir

sqrDist

dist

flatten

flatten

getSize

setSize

getEntries

getEntry

setEntry

setEntry

getFirstEntry

setFirstEntry

getLastEntry

setLastEntry

addEntry

removeEntry

concat

set

set

set

set

set

set

set

set

set

set

set

changeValue