GClasses
|
Contains some useful functions for operating on vectors. More...
#include <GVec.h>
Static Public Member Functions | |
static void | test () |
Performs unit tests for this class. Throws an exception if there is a failure. | |
static bool | doesContainUnknowns (const double *pVector, size_t nSize) |
This returns true if the vector contains any unknown values. Most of the methods in this class will give bad results if a vector contains unknown values, but for efficiency reasons, they don't check. So it's your job to check your vectors first. | |
static void | copy (double *pDest, const double *pSource, size_t nDims) |
This just wraps memcpy. | |
static double | dotProduct (const double *pA, const double *pB, size_t nSize) |
Computes the dot product of two vectors. Results are undefined if pA or pB contain unknown values. | |
static double | dotProduct (const double *pOrigin, const double *pTarget, const double *pVector, size_t nSize) |
Computes the dot product of (pTarget - pOrigin) with pVector. | |
static double | dotProduct (const double *pOriginA, const double *pTargetA, const double *pOriginB, const double *pTargetB, size_t nSize) |
Computes the dot product of (pTargetA - pOriginA) with (pTargetB - pOriginB). | |
static double | dotProductIgnoringUnknowns (const double *pOrigin, const double *pTarget, const double *pVector, size_t nSize) |
Computes the dot product of (pTarget - pOrigin) with pVector. Unknown values in pTarget will simply be ignored. (pOrigin and pVector must not contain any unknown values.) | |
static double | squaredMagnitude (const double *pVector, size_t nSize) |
Computes the squared magnitude of the vector. | |
static double | lNormMagnitude (double norm, const double *pVector, size_t nSize) |
Computes the magnitude in L-Norm distance (norm=1 is manhattan distance, norm=2 is Euclidean distance, norm=infinity is Chebychev, etc.) | |
static void | normalize (double *pVector, size_t nSize) |
Normalizes this vector to a magnitude of 1. Throws an exception if the magnitude is zero. | |
static void | safeNormalize (double *pVector, size_t nSize, GRand *pRand) |
Normalizes this vector to a magnitude of 1. If the magnitude is zero, it returns a random vector. | |
static void | sumToOne (double *pVector, size_t size) |
Scale the vector so that the elements sum to 1. | |
static void | lNormNormalize (double norm, double *pVector, size_t nSize) |
Normalizes with L-Norm distance (norm=1 is manhattan distance, norm=2 is Euclidean distance, norm=infinity is Chebychev, etc.) | |
static double | squaredDistance (const double *pA, const double *pB, size_t nDims) |
Computes the squared distance between two vectors. | |
static double | estimateSquaredDistanceWithUnknowns (const double *pA, const double *pB, size_t nDims) |
Estimates the squared distance between two points that may have some missing values. It assumes the distance in missing dimensions is approximately the same as the average distance in other dimensions. If there are no known dimensions that overlap between the two points, it returns 1e50. | |
static double | lNormDistance (double norm, const double *pA, const double *pB, size_t dims) |
Computes L-Norm distance (norm=1 is manhattan distance, norm=2 is Euclidean distance, norm=infinity is Chebychev, etc.) | |
static double | correlation (const double *pA, const double *pB, size_t nDims) |
Computes the cosine of the angle between two vectors (the origin is the vertex) | |
static double | correlation (const double *pOriginA, const double *pTargetA, const double *pB, size_t nDims) |
Computes the cosine of the angle between two vectors (the origin is the vertex) | |
static double | correlation (const double *pOriginA, const double *pTargetA, const double *pOriginB, const double *pTargetB, size_t nDims) |
Computes the cosine of the angle between two vectors (the origin is the vertex) | |
static size_t | indexOfMin (const double *pVector, size_t dims, GRand *pRand) |
Returns the index of the min value in pVector. If multiple elements have have an equivalent max value, it randomly (uniformly) picks from all the ties. | |
static size_t | indexOfMax (const double *pVector, size_t dims, GRand *pRand) |
Returns the index of the max value in pVector. If multiple elements have have an equivalent max value, it randomly (uniformly) picks from all the ties. | |
static size_t | indexOfMaxMagnitude (const double *pVector, size_t dims, GRand *pRand) |
Returns the index of the value with the largest magnitude in pVector. If multiple elements have have an equivalent magnitude, it randomly (uniformly) picks from all the ties. | |
static void | add (double *pDest, const double *pSource, size_t nDims) |
Adds pSource to pDest. | |
static void | addScaled (double *pDest, double dMag, const double *pSource, size_t nDims) |
Adds dMag * pSource to pDest. | |
static void | addLog (double *pDest, const double *pSource, size_t nDims) |
Adds the log of each element in pSource to pDest. | |
static void | subtract (double *pDest, const double *pSource, size_t nDims) |
Subtracts pSource from pDest. | |
static void | multiply (double *pVector, double dScalar, size_t nDims) |
Multiplies pVector by dScalar. | |
static void | pow (double *pVector, double dScalar, size_t nDims) |
Raises each element of pVector to the exponent dScalar. | |
static void | pairwiseMultiply (double *pDest, double *pOther, size_t dims) |
Multiplies each element in pDest by the corresponding element in pOther. | |
static void | pairwiseDivide (double *pDest, double *pOther, size_t dims) |
Divides each element in pDest by the corresponding element in pOther. | |
static void | setAll (double *pVector, double value, size_t dims) |
Sets all the elements to the specified value. | |
static void | interpolateIndexes (size_t nIndexes, double *pInIndexes, double *pOutIndexes, float fRatio, size_t nCorrIndexes, double *pCorrIndexes1, double *pCorrIndexes2) |
Interpolates (morphs) a set of indexes from one function to another. pInIndexes, pCorrIndexes1, and pCorrIndexes2 are all expected to be in sorted order. All indexes should be >= 0 and < nDims. fRatio is the interpolation ratio such that if fRatio is zero, all indexes left unchanged, and as fRatio approaches one, the indexes are interpolated linearly such that each index in pCorrIndexes1 is interpolated linearly to the corresponding index in pCorrIndexes2. If the two extremes are not in the list of corresponding indexes, the ends may drift. | |
static void | rotate (double *pVector, size_t nDims, double dAngle, const double *pA, const double *pB) |
Rotates pVector by dAngle radians in the plane defined by the orthogonal axes pA and pB. | |
static void | addInterpolatedFunction (double *pOut, size_t nOutVals, double *pIn, size_t nInVals) |
Adds the function pIn to pOut after interpolating pIn to be the same size as pOut. | |
static GDomNode * | serialize (GDom *pDoc, const double *pVec, size_t dims) |
Write the vector to a text format. | |
static void | deserialize (double *pVec, GDomListIterator &it) |
Load the vector from a text format. pVec must be large enough to contain all of the elements that remain in "it". | |
static void | print (std::ostream &stream, int precision, double *pVec, size_t dims) |
Prints the values in the vector separated by ", ". precision specifies the number of digits to print. | |
static void | project (double *pDest, const double *pPoint, const double *pOrigin, const double *pBasis, size_t basisCount, size_t dims) |
Projects pPoint onto the hyperplane defined by pOrigin onto the basisCount basis vectors specified by pBasis. (The basis vectors are assumed to be chained end-to-end in a big vector.) | |
static void | subtractComponent (double *pInOut, const double *pBasis, size_t dims) |
Subtracts the component of pInOut that projects onto pBasis. (Assumes that pBasis is normalized.) This might be used, for example, to implement the modified Gram-Schmidt process. | |
static void | subtractComponent (double *pInOut, const double *pOrigin, const double *pTarget, size_t dims) |
Subtracts the component of pInOut that projects onto (pTarget - pOrigin). This might be used, for example, to implement the modified Gram-Schmidt process. | |
static double | sumElements (const double *pVec, size_t dims) |
Returns the sum of all the elements. | |
static void | smallestToFront (double *pVec, size_t k, size_t size, double *pParallel1=NULL, size_t *pParallel2=NULL, double *pParallel3=NULL) |
Moves the smallest k values to the front of the vector, and the biggest (size - k) values to the end of the vector. (For efficiency, no other guarantees about ordering are made.) This has an average-case runtime that is linear with respect to size. pParallel1 and pParallel2 are optional arrays that should be arranged to keep their indices in sync with pVec. | |
static double | refinePoint (double *pPoint, double *pNeighbor, size_t dims, double distance, double learningRate, GRand *pRand) |
Moves "pPoint" so that it is closer to a distance of "distance" from "pNeighbor". "learningRate" specifies how much to move it (0=not at all, 1=all the way). Returns the squared distance between pPoint and pNeighbor. | |
static void | toImage (const double *pVec, GImage *pImage, int width, int height, int channels, double range) |
Converts a vector of rasterized pixel values to an image. channels must be 1 or 3 (for grayscale or rgb) range specifies the range of channel values. Typical values are 1.0 or 255.0. Pixels are visited in reading order (left-to-right, top-to-bottom). | |
static void | fromImage (GImage *pImage, double *pVec, int width, int height, int channels, double range) |
Converts an image to a vector of rasterized pixel values. channels must be 1 or 3 (for grayscale or rgb) range specifies the range of channel values. Typical values are 1.0 or 255.0. Pixels are visited in reading order (left-to-right, top-to-bottom). pVec must be big enough to hold width * height * channels values. | |
static void | capValues (double *pVec, double cap, size_t dims) |
Sets each value, v, to MIN(cap, v) | |
static void | floorValues (double *pVec, double floor, size_t dims) |
Sets each value, v, to MAX(floor, v) |
Contains some useful functions for operating on vectors.
static void GClasses::GVec::add | ( | double * | pDest, |
const double * | pSource, | ||
size_t | nDims | ||
) | [static] |
Adds pSource to pDest.
static void GClasses::GVec::addInterpolatedFunction | ( | double * | pOut, |
size_t | nOutVals, | ||
double * | pIn, | ||
size_t | nInVals | ||
) | [static] |
Adds the function pIn to pOut after interpolating pIn to be the same size as pOut.
static void GClasses::GVec::addLog | ( | double * | pDest, |
const double * | pSource, | ||
size_t | nDims | ||
) | [static] |
Adds the log of each element in pSource to pDest.
static void GClasses::GVec::addScaled | ( | double * | pDest, |
double | dMag, | ||
const double * | pSource, | ||
size_t | nDims | ||
) | [static] |
Adds dMag * pSource to pDest.
static void GClasses::GVec::capValues | ( | double * | pVec, |
double | cap, | ||
size_t | dims | ||
) | [static] |
Sets each value, v, to MIN(cap, v)
static void GClasses::GVec::copy | ( | double * | pDest, |
const double * | pSource, | ||
size_t | nDims | ||
) | [static] |
This just wraps memcpy.
static double GClasses::GVec::correlation | ( | const double * | pOriginA, |
const double * | pTargetA, | ||
const double * | pB, | ||
size_t | nDims | ||
) | [static] |
Computes the cosine of the angle between two vectors (the origin is the vertex)
static double GClasses::GVec::correlation | ( | const double * | pOriginA, |
const double * | pTargetA, | ||
const double * | pOriginB, | ||
const double * | pTargetB, | ||
size_t | nDims | ||
) | [static] |
Computes the cosine of the angle between two vectors (the origin is the vertex)
static double GClasses::GVec::correlation | ( | const double * | pA, |
const double * | pB, | ||
size_t | nDims | ||
) | [static] |
Computes the cosine of the angle between two vectors (the origin is the vertex)
static void GClasses::GVec::deserialize | ( | double * | pVec, |
GDomListIterator & | it | ||
) | [static] |
Load the vector from a text format. pVec must be large enough to contain all of the elements that remain in "it".
static bool GClasses::GVec::doesContainUnknowns | ( | const double * | pVector, |
size_t | nSize | ||
) | [static] |
This returns true if the vector contains any unknown values. Most of the methods in this class will give bad results if a vector contains unknown values, but for efficiency reasons, they don't check. So it's your job to check your vectors first.
static double GClasses::GVec::dotProduct | ( | const double * | pA, |
const double * | pB, | ||
size_t | nSize | ||
) | [static] |
Computes the dot product of two vectors. Results are undefined if pA or pB contain unknown values.
static double GClasses::GVec::dotProduct | ( | const double * | pOrigin, |
const double * | pTarget, | ||
const double * | pVector, | ||
size_t | nSize | ||
) | [static] |
Computes the dot product of (pTarget - pOrigin) with pVector.
static double GClasses::GVec::dotProduct | ( | const double * | pOriginA, |
const double * | pTargetA, | ||
const double * | pOriginB, | ||
const double * | pTargetB, | ||
size_t | nSize | ||
) | [static] |
Computes the dot product of (pTargetA - pOriginA) with (pTargetB - pOriginB).
static double GClasses::GVec::dotProductIgnoringUnknowns | ( | const double * | pOrigin, |
const double * | pTarget, | ||
const double * | pVector, | ||
size_t | nSize | ||
) | [static] |
Computes the dot product of (pTarget - pOrigin) with pVector. Unknown values in pTarget will simply be ignored. (pOrigin and pVector must not contain any unknown values.)
static double GClasses::GVec::estimateSquaredDistanceWithUnknowns | ( | const double * | pA, |
const double * | pB, | ||
size_t | nDims | ||
) | [static] |
Estimates the squared distance between two points that may have some missing values. It assumes the distance in missing dimensions is approximately the same as the average distance in other dimensions. If there are no known dimensions that overlap between the two points, it returns 1e50.
static void GClasses::GVec::floorValues | ( | double * | pVec, |
double | floor, | ||
size_t | dims | ||
) | [static] |
Sets each value, v, to MAX(floor, v)
static void GClasses::GVec::fromImage | ( | GImage * | pImage, |
double * | pVec, | ||
int | width, | ||
int | height, | ||
int | channels, | ||
double | range | ||
) | [static] |
Converts an image to a vector of rasterized pixel values. channels must be 1 or 3 (for grayscale or rgb) range specifies the range of channel values. Typical values are 1.0 or 255.0. Pixels are visited in reading order (left-to-right, top-to-bottom). pVec must be big enough to hold width * height * channels values.
static size_t GClasses::GVec::indexOfMax | ( | const double * | pVector, |
size_t | dims, | ||
GRand * | pRand | ||
) | [static] |
Returns the index of the max value in pVector. If multiple elements have have an equivalent max value, it randomly (uniformly) picks from all the ties.
static size_t GClasses::GVec::indexOfMaxMagnitude | ( | const double * | pVector, |
size_t | dims, | ||
GRand * | pRand | ||
) | [static] |
Returns the index of the value with the largest magnitude in pVector. If multiple elements have have an equivalent magnitude, it randomly (uniformly) picks from all the ties.
static size_t GClasses::GVec::indexOfMin | ( | const double * | pVector, |
size_t | dims, | ||
GRand * | pRand | ||
) | [static] |
Returns the index of the min value in pVector. If multiple elements have have an equivalent max value, it randomly (uniformly) picks from all the ties.
static void GClasses::GVec::interpolateIndexes | ( | size_t | nIndexes, |
double * | pInIndexes, | ||
double * | pOutIndexes, | ||
float | fRatio, | ||
size_t | nCorrIndexes, | ||
double * | pCorrIndexes1, | ||
double * | pCorrIndexes2 | ||
) | [static] |
Interpolates (morphs) a set of indexes from one function to another. pInIndexes, pCorrIndexes1, and pCorrIndexes2 are all expected to be in sorted order. All indexes should be >= 0 and < nDims. fRatio is the interpolation ratio such that if fRatio is zero, all indexes left unchanged, and as fRatio approaches one, the indexes are interpolated linearly such that each index in pCorrIndexes1 is interpolated linearly to the corresponding index in pCorrIndexes2. If the two extremes are not in the list of corresponding indexes, the ends may drift.
static double GClasses::GVec::lNormDistance | ( | double | norm, |
const double * | pA, | ||
const double * | pB, | ||
size_t | dims | ||
) | [static] |
Computes L-Norm distance (norm=1 is manhattan distance, norm=2 is Euclidean distance, norm=infinity is Chebychev, etc.)
static double GClasses::GVec::lNormMagnitude | ( | double | norm, |
const double * | pVector, | ||
size_t | nSize | ||
) | [static] |
Computes the magnitude in L-Norm distance (norm=1 is manhattan distance, norm=2 is Euclidean distance, norm=infinity is Chebychev, etc.)
static void GClasses::GVec::lNormNormalize | ( | double | norm, |
double * | pVector, | ||
size_t | nSize | ||
) | [static] |
Normalizes with L-Norm distance (norm=1 is manhattan distance, norm=2 is Euclidean distance, norm=infinity is Chebychev, etc.)
static void GClasses::GVec::multiply | ( | double * | pVector, |
double | dScalar, | ||
size_t | nDims | ||
) | [static] |
Multiplies pVector by dScalar.
static void GClasses::GVec::normalize | ( | double * | pVector, |
size_t | nSize | ||
) | [static] |
Normalizes this vector to a magnitude of 1. Throws an exception if the magnitude is zero.
static void GClasses::GVec::pairwiseDivide | ( | double * | pDest, |
double * | pOther, | ||
size_t | dims | ||
) | [static] |
Divides each element in pDest by the corresponding element in pOther.
static void GClasses::GVec::pairwiseMultiply | ( | double * | pDest, |
double * | pOther, | ||
size_t | dims | ||
) | [static] |
Multiplies each element in pDest by the corresponding element in pOther.
static void GClasses::GVec::pow | ( | double * | pVector, |
double | dScalar, | ||
size_t | nDims | ||
) | [static] |
Raises each element of pVector to the exponent dScalar.
static void GClasses::GVec::print | ( | std::ostream & | stream, |
int | precision, | ||
double * | pVec, | ||
size_t | dims | ||
) | [static] |
Prints the values in the vector separated by ", ". precision specifies the number of digits to print.
static void GClasses::GVec::project | ( | double * | pDest, |
const double * | pPoint, | ||
const double * | pOrigin, | ||
const double * | pBasis, | ||
size_t | basisCount, | ||
size_t | dims | ||
) | [static] |
Projects pPoint onto the hyperplane defined by pOrigin onto the basisCount basis vectors specified by pBasis. (The basis vectors are assumed to be chained end-to-end in a big vector.)
static double GClasses::GVec::refinePoint | ( | double * | pPoint, |
double * | pNeighbor, | ||
size_t | dims, | ||
double | distance, | ||
double | learningRate, | ||
GRand * | pRand | ||
) | [static] |
Moves "pPoint" so that it is closer to a distance of "distance" from "pNeighbor". "learningRate" specifies how much to move it (0=not at all, 1=all the way). Returns the squared distance between pPoint and pNeighbor.
static void GClasses::GVec::rotate | ( | double * | pVector, |
size_t | nDims, | ||
double | dAngle, | ||
const double * | pA, | ||
const double * | pB | ||
) | [static] |
Rotates pVector by dAngle radians in the plane defined by the orthogonal axes pA and pB.
static void GClasses::GVec::safeNormalize | ( | double * | pVector, |
size_t | nSize, | ||
GRand * | pRand | ||
) | [static] |
Normalizes this vector to a magnitude of 1. If the magnitude is zero, it returns a random vector.
static GDomNode* GClasses::GVec::serialize | ( | GDom * | pDoc, |
const double * | pVec, | ||
size_t | dims | ||
) | [static] |
Write the vector to a text format.
static void GClasses::GVec::setAll | ( | double * | pVector, |
double | value, | ||
size_t | dims | ||
) | [static] |
Sets all the elements to the specified value.
static void GClasses::GVec::smallestToFront | ( | double * | pVec, |
size_t | k, | ||
size_t | size, | ||
double * | pParallel1 = NULL , |
||
size_t * | pParallel2 = NULL , |
||
double * | pParallel3 = NULL |
||
) | [static] |
Moves the smallest k values to the front of the vector, and the biggest (size - k) values to the end of the vector. (For efficiency, no other guarantees about ordering are made.) This has an average-case runtime that is linear with respect to size. pParallel1 and pParallel2 are optional arrays that should be arranged to keep their indices in sync with pVec.
static double GClasses::GVec::squaredDistance | ( | const double * | pA, |
const double * | pB, | ||
size_t | nDims | ||
) | [static] |
Computes the squared distance between two vectors.
static double GClasses::GVec::squaredMagnitude | ( | const double * | pVector, |
size_t | nSize | ||
) | [static] |
Computes the squared magnitude of the vector.
static void GClasses::GVec::subtract | ( | double * | pDest, |
const double * | pSource, | ||
size_t | nDims | ||
) | [static] |
Subtracts pSource from pDest.
static void GClasses::GVec::subtractComponent | ( | double * | pInOut, |
const double * | pOrigin, | ||
const double * | pTarget, | ||
size_t | dims | ||
) | [static] |
Subtracts the component of pInOut that projects onto (pTarget - pOrigin). This might be used, for example, to implement the modified Gram-Schmidt process.
static void GClasses::GVec::subtractComponent | ( | double * | pInOut, |
const double * | pBasis, | ||
size_t | dims | ||
) | [static] |
Subtracts the component of pInOut that projects onto pBasis. (Assumes that pBasis is normalized.) This might be used, for example, to implement the modified Gram-Schmidt process.
static double GClasses::GVec::sumElements | ( | const double * | pVec, |
size_t | dims | ||
) | [static] |
Returns the sum of all the elements.
static void GClasses::GVec::sumToOne | ( | double * | pVector, |
size_t | size | ||
) | [static] |
Scale the vector so that the elements sum to 1.
static void GClasses::GVec::test | ( | ) | [static] |
Performs unit tests for this class. Throws an exception if there is a failure.
static void GClasses::GVec::toImage | ( | const double * | pVec, |
GImage * | pImage, | ||
int | width, | ||
int | height, | ||
int | channels, | ||
double | range | ||
) | [static] |
Converts a vector of rasterized pixel values to an image. channels must be 1 or 3 (for grayscale or rgb) range specifies the range of channel values. Typical values are 1.0 or 255.0. Pixels are visited in reading order (left-to-right, top-to-bottom).