chemaxon.descriptors.Metrics
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
java.lang.Object
public class Metrics
The Metrics class implements dissimilarity metrics for
MolecularDescriptors. For the sake of general availability
of this dissimilarity calculations by any MolecularDescriptor
derivatives, methods take float and int arrays as input parameters, thus
they do not need to access to the internal representation of descriptors.
This, however, may introduce some overhead in dissimilarity calculations,
since MolecularDescriptor objects may need to transform their
internal representation into an int or a float array. If this overhead
is significant, then the required dissimilarity function has to be
implemented as part of the descriptor class.
| Constructor Summary | |
|---|---|
Metrics()
|
|
| Method Summary | |
|---|---|
static float |
asymmetricEuclidean(float[] v1,
float[] v2,
double asymmetryFactor)
Calculates the asymmetric Euclidean distance. |
static float |
asymmetricEuclidean(int[] v1,
int[] v2,
double asymmetryFactor)
Calculates the asymmetric Euclidean distance. |
static float |
asymmetricNormalizedEuclidean(float[] v1,
float[] v2,
double asymmetryFactor)
Calculates the asymmetric normalized Euclidean distance. |
static float |
asymmetricNormalizedEuclidean(int[] v1,
int[] v2,
double asymmetryFactor)
Calculates the asymmetric normalized Euclidean distance. |
static float |
asymmetricTanimoto(float[] v1,
float[] v2,
float asymmetryFactor)
Calculates the asymmetric Tanimoto dissimilarity for floating point values. |
static float |
asymmetricTanimoto(int[] v1,
int[] v2,
float asymmetryFactor)
Calculates the asymmetric Tanimoto dissimilarity for floating point values. |
static float |
binaryAsymmetricEuclidean(int[] v1,
int[] v2,
float asymmetryFactor)
Calculates the asymmetric Euclidean distance of binary descriptors. |
static float |
binaryAsymmetricNormalizedEuclidean(int[] v1,
int[] v2,
float asymmetryFactor)
Calculates the asymmetric normalized Euclidean distance of binary descriptors. |
static float |
binaryAsymmetricNormalizedEuclidean(int[] v1,
int oneCount1,
int[] v2,
int oneCount2,
float asymmetryFactor)
Calculates the asymmetric normalized Euclidean distance of binary descriptors. |
static float |
binaryAsymmetricTanimoto(int[] v1,
int[] v2,
float asymmetryFactor)
Calculates asymmetric Tanimoto dissimilarity for binary descriptors. |
static float |
binaryAsymmetricTanimoto(int[] v1,
int oneCount1,
int[] v2,
int oneCount2,
float asymmetryFactor)
Calculates asymmetricTanimoto dissimilarity for binary descriptors. |
static float |
binaryEuclidean(int[] v1,
int[] v2)
Calculates the Euclidean distance of two binary descriptors. |
static float |
binaryNormalizedEuclidean(int[] v1,
int[] v2)
Calculates the normalized Euclidean distance of two binary descriptors. |
static float |
binaryNormalizedEuclidean(int[] v1,
int oneCount1,
int[] v2,
int oneCount2)
Calculates the normalized Euclidean distance of two binary descriptors. |
static float |
binaryTanimoto(int[] v1,
int[] v2)
Calculates Tanimoto dissimilarity for binary descriptors. |
static float |
binaryTanimoto(int[] v1,
int oneCount1,
int[] v2,
int oneCount2)
Calculates Tanimoto dissimilarity for binary descriptors. |
static float |
binaryWeightedAsymmetricEuclidean(int[] v1,
int[] v2,
float[] weights,
float asymmetryFactor)
Calculates the weighted asymmetric Euclidean distance of binary descriptors. |
static float |
binaryWeightedAsymmetricNormalizedEuclidean(int[] v1,
int[] v2,
float[] weights,
float asymmetryFactor)
Calculates the weighted asymmetric normalized Euclidean distance of binary descriptors. |
static float |
binaryWeightedAsymmetricNormalizedEuclidean(int[] v1,
int oneCount1,
int[] v2,
int oneCount2,
float[] weights,
float asymmetryFactor)
Calculates the weighted asymmetric normalized Euclidean distance of binary descriptors. |
static float |
binaryWeightedEuclidean(int[] v1,
int[] v2,
float[] weights)
Calculates the weighted Euclidean distance of binary descriptors. |
static float |
binaryWeightedNormalizedEuclidean(int[] v1,
int[] v2,
float[] weights)
Calculates the weighted normalized Euclidean distance of binary descriptors. |
static float |
binaryWeightedNormalizedEuclidean(int[] v1,
int oneCount1,
int[] v2,
int oneCount2,
int[] weights)
Calculates the weighted normalized Euclidean distance of binary descriptors. |
static int |
calcBitCount(int i)
Counts the number of bits set (1) in the integer parameter. |
static int |
calcBitCount(int[] v)
Counts the number of bits set (1) in a bit vector. |
static float |
euclidean(float[] v1,
float[] v2)
Calculates the Euclidean distance. |
static float |
euclidean(int[] v1,
int[] v2)
Calculates the Euclidean distance. |
static float |
normalizedEuclidean(float[] v1,
float[] v2)
Calculates the normalized Euclidean distance. |
static float |
normalizedEuclidean(int[] v1,
int[] v2)
Calculates the normalized Euclidean distance. |
static float |
scaledAsymmetricTanimoto(float[] v1,
float[] v2,
float[] hypothesis,
float scaleFactor,
float asymmetryFactor)
Calculates the scaled asymmetric Tanimoto dissimilarity for floating point values. |
static float |
scaledAsymmetricTanimoto(int[] v1,
int[] v2,
float[] hypothesis,
float scaleFactor,
float asymmetryFactor)
Calculates the scaled asymmetric Tanimoto dissimilarity for floating point values. |
static float |
scaledTanimoto(float[] v1,
float[] v2,
float[] hypothesis,
float scaleFactor)
Calculates the scaled Tanimoto dissimilarity for floating point values. |
static float |
scaledTanimoto(int[] v1,
int[] v2,
float[] hypothesis,
float scaleFactor)
Calculates the scaled Tanimoto dissimilarity for floating point values. |
static float |
tanimoto(float[] v1,
float[] v2)
Calculates Tanimoto dissimilarity for floating point values. |
static float |
tanimoto(int[] v1,
int[] v2)
Calculates Tanimoto dissimilarity for floating point values. |
static float |
weightedAsymmetricEuclidean(float[] v1,
float[] v2,
float[] weights,
float asymmetryFactor)
Calculates the weighted asymmetric Euclidean distance. |
static float |
weightedAsymmetricEuclidean(int[] v1,
int[] v2,
float[] weights,
float asymmetryFactor)
Calculates the weighted asymmetric Euclidean distance. |
static float |
weightedAsymmetricNormalizedEuclidean(float[] v1,
float[] v2,
float[] weights,
float asymmetryFactor)
Calculates the weighted asymmetric normalized Euclidean distance. |
static float |
weightedAsymmetricNormalizedEuclidean(int[] v1,
int[] v2,
float[] weights,
float asymmetryFactor)
Calculates the weighted asymmetric normalized Euclidean distance. |
static float |
weightedEuclidean(float[] v1,
float[] v2,
float[] weights)
Calculates the weighted Euclidean distance. |
static float |
weightedEuclidean(int[] v1,
int[] v2,
float[] weights)
Calculates the weighted Euclidean distance. |
static float |
weightedNormalizedEuclidean(float[] v1,
float[] v2,
float[] weights)
Calculates the weighted normalized Euclidean distance. |
static float |
weightedNormalizedEuclidean(int[] v1,
int[] v2,
float[] weights)
Calculates the weighted normalized Euclidean distance. |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public Metrics()
| Method Detail |
|---|
public static final float euclidean(float[] v1,
float[] v2)
v1 - first vectorv2 - second vector
public static final float normalizedEuclidean(float[] v1,
float[] v2)
v1 - first vectorv2 - second vector
public static final float asymmetricEuclidean(float[] v1,
float[] v2,
double asymmetryFactor)
v1 - first vectorv2 - second vectorasymmetryFactor - asymmetry ratio
public static final float asymmetricNormalizedEuclidean(float[] v1,
float[] v2,
double asymmetryFactor)
v1 - first vectorv2 - second vectorasymmetryFactor - asymmetry ratio
public static final float weightedEuclidean(float[] v1,
float[] v2,
float[] weights)
v1 - first vectorv2 - second vectorweights - weight factors for every coordinate
public static final float weightedNormalizedEuclidean(float[] v1,
float[] v2,
float[] weights)
v1 - first vectorv2 - second vectorweights - weight factors for every coordinate
public static final float weightedAsymmetricEuclidean(float[] v1,
float[] v2,
float[] weights,
float asymmetryFactor)
v1 - first vectorv2 - second vectorweights - weight factors for every coordinateasymmetryFactor - asymmetry ratio
public static final float weightedAsymmetricNormalizedEuclidean(float[] v1,
float[] v2,
float[] weights,
float asymmetryFactor)
v1 - first vectorv2 - second vectorweights - weight factors for every coordinateasymmetryFactor - asymmetry ratio
public static final float tanimoto(float[] v1,
float[] v2)
v1 - first vectorv2 - second vector
public static final float asymmetricTanimoto(float[] v1,
float[] v2,
float asymmetryFactor)
v1 - first vectorv2 - second vectorasymmetryFactor - asymmetry ratio
public static final float scaledTanimoto(float[] v1,
float[] v2,
float[] hypothesis,
float scaleFactor)
v1 - first vectorv2 - second vectorhypothesis - scaling (consensus) hypothesisscaleFactor - scale factor
public static final float scaledAsymmetricTanimoto(float[] v1,
float[] v2,
float[] hypothesis,
float scaleFactor,
float asymmetryFactor)
v1 - first vectorv2 - second vectorhypothesis - scaling (consensus) hypothesisscaleFactor - scale factorasymmetryFactor - asymmetry ratio
public static final float euclidean(int[] v1,
int[] v2)
v1 - first vectorv2 - second vector
public static final float normalizedEuclidean(int[] v1,
int[] v2)
v1 - first vectorv2 - second vector
public static final float asymmetricEuclidean(int[] v1,
int[] v2,
double asymmetryFactor)
v1 - first vectorv2 - second vectorasymmetryFactor - asymmetry ratio
public static final float asymmetricNormalizedEuclidean(int[] v1,
int[] v2,
double asymmetryFactor)
v1 - first vectorv2 - second vectorasymmetryFactor - asymmetry ratio
public static final float weightedEuclidean(int[] v1,
int[] v2,
float[] weights)
v1 - first vectorv2 - second vectorweights - weight factors for every coordinate
public static final float weightedNormalizedEuclidean(int[] v1,
int[] v2,
float[] weights)
v1 - first vectorv2 - second vectorweights - weight factors for every coordinate
public static final float weightedAsymmetricEuclidean(int[] v1,
int[] v2,
float[] weights,
float asymmetryFactor)
v1 - first vectorv2 - second vectorweights - weight factors for every coordinateasymmetryFactor - asymmetry ratio
public static final float weightedAsymmetricNormalizedEuclidean(int[] v1,
int[] v2,
float[] weights,
float asymmetryFactor)
v1 - first vectorv2 - second vectorweights - weight factors for every coordinateasymmetryFactor - asymmetry ratio
public static final float tanimoto(int[] v1,
int[] v2)
v1 - first vectorv2 - second vector
public static final float asymmetricTanimoto(int[] v1,
int[] v2,
float asymmetryFactor)
v1 - first vectorv2 - second vectorasymmetryFactor - asymmetry ratio
public static final float scaledTanimoto(int[] v1,
int[] v2,
float[] hypothesis,
float scaleFactor)
v1 - first vectorv2 - second vectorhypothesis - scaling (consensus) hypothesisscaleFactor - scale factor
public static final float scaledAsymmetricTanimoto(int[] v1,
int[] v2,
float[] hypothesis,
float scaleFactor,
float asymmetryFactor)
v1 - first vectorv2 - second vectorhypothesis - scaling (consensus) hypothesisscaleFactor - scale factorasymmetryFactor - asymmetry ratio
public static int calcBitCount(int i)
i - an integer value
public static int calcBitCount(int[] v)
v - bit vector, represented by an integer vector, each element
stores 32 bits
public static float binaryEuclidean(int[] v1,
int[] v2)
v1 - first vectorv2 - second vector
public static float binaryNormalizedEuclidean(int[] v1,
int[] v2)
v1 - first vectorv2 - second vector
public static float binaryNormalizedEuclidean(int[] v1,
int oneCount1,
int[] v2,
int oneCount2)
binaryNormalizedEuclidean( final int[] v1,
final int[] v2 ) when the number of bits set (1) is known in both
input vectors, as this method does not recalculate these values which
results in faster operation.
v1 - first vectoroneCount1 - number of 1 bits in v1v2 - second vectoroneCount2 - number of 1 bits in v1
public static float binaryWeightedEuclidean(int[] v1,
int[] v2,
float[] weights)
v1 - first vectorv2 - second vectorweights - weight factors for every coordinate
public static float binaryWeightedNormalizedEuclidean(int[] v1,
int[] v2,
float[] weights)
v1 - first vectorv2 - second vectorweights - weight factors for every coordinate
public static float binaryWeightedNormalizedEuclidean(int[] v1,
int oneCount1,
int[] v2,
int oneCount2,
int[] weights)
v1 - first vectoroneCount1 - number of 1 bits in v1v2 - second vectoroneCount2 - number of 1 bits in v2weights - weight factors for every coordinate
public static float binaryAsymmetricEuclidean(int[] v1,
int[] v2,
float asymmetryFactor)
v1 - first vectorv2 - second vectorasymmetryFactor - asymmetry ratio
public static float binaryAsymmetricNormalizedEuclidean(int[] v1,
int[] v2,
float asymmetryFactor)
v1 - first vectorv2 - second vectorasymmetryFactor - asymmetry ratio
public static float binaryAsymmetricNormalizedEuclidean(int[] v1,
int oneCount1,
int[] v2,
int oneCount2,
float asymmetryFactor)
binaryAsymmetricNormalizedEuclidean( final int[] v1, final int[] v2 )
when the number of bits set (1) is known in both input vectors, as this
method does not recalculate these values which results in faster
operation.
v1 - first vectoroneCount1 - number of 1 bits in v1v2 - second vectoroneCount2 - number of 1 bits in v2asymmetryFactor - asymmetry ratio
public static float binaryWeightedAsymmetricEuclidean(int[] v1,
int[] v2,
float[] weights,
float asymmetryFactor)
v1 - first vectorv2 - second vectorweights - weight factors for every coordinateasymmetryFactor - asymmetry ratio
public static float binaryWeightedAsymmetricNormalizedEuclidean(int[] v1,
int[] v2,
float[] weights,
float asymmetryFactor)
v1 - first vectorv2 - second vectorweights - weight factors for every coordinateasymmetryFactor - asymmetry ratio
public static float binaryWeightedAsymmetricNormalizedEuclidean(int[] v1,
int oneCount1,
int[] v2,
int oneCount2,
float[] weights,
float asymmetryFactor)
binaryWeightedAsymmetricNormalizedEuclidean( final int[] v1, final int[]
v2, final float[] weights, float asymmetryFactor ) when the number of
bits set (1) is known in both input vectors, as this method does not
recalculate these values which results in faster operation.
v1 - first vectoroneCount1 - number of 1 bits in v1v2 - second vectoroneCount2 - number of 1 bits in v2weights - weight factors for every coordinateasymmetryFactor - asymmetry ratio
public static float binaryTanimoto(int[] v1,
int[] v2)
v1 - first vectorv2 - second vector
public static float binaryAsymmetricTanimoto(int[] v1,
int[] v2,
float asymmetryFactor)
v1 - first vectorv2 - second vectorasymmetryFactor - asymmetry ratio
public static float binaryTanimoto(int[] v1,
int oneCount1,
int[] v2,
int oneCount2)
binaryTanimoto( final int[] v1, final int[] v2 )
when the number of bits set (1) is known in both input vectors, as this
method does not recalculate these values which results in faster
operation.
v1 - first vectoroneCount1 - number of 1 bits in v1v2 - second vectoroneCount2 - number of 1 bits in v2
public static float binaryAsymmetricTanimoto(int[] v1,
int oneCount1,
int[] v2,
int oneCount2,
float asymmetryFactor)
binaryTanimoto( final int[] v1, final int[] v2, float asymmetryFactor )
when the number of bits set (1) is known in both input vectors, as this
method does not recalculate these values which results in faster
operation.
v1 - first vectoroneCount1 - number of 1 bits in v1v2 - second vectoroneCount2 - number of 1 bits in v2asymmetryFactor - asymmetry ratio
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||