org.apache.solr.search.function.distance

## Class VectorDistanceFunction

- java.lang.Object
- - org.apache.lucene.queries.function.ValueSource
  - - org.apache.solr.search.function.distance.VectorDistanceFunction

- Direct Known Subclasses:
    SquaredEuclideanFunction

      public class VectorDistanceFunction
      extends ValueSource

  Calculate the p-norm for a Vector. See http://en.wikipedia.org/wiki/Lp_space

  Common cases:

  - 0 = Sparseness calculation
  - 1 = Manhattan distance
  - 2 = Euclidean distance
  - Integer.MAX_VALUE = infinite norm
  See Also:
    `for the special case`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected float` | `oneOverPower`
    `protected float` | `power`
    `protected MultiValueSource` | `source1`
    `protected MultiValueSource` | `source2`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `VectorDistanceFunction(float power, MultiValueSource source1, MultiValueSource source2)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `createWeight(Map context, IndexSearcher searcher)`
    `String` | `description()`
    `protected double` | `distance(int doc, FunctionValues dv1, FunctionValues dv2)` Calculate the distance
    `static double` | `distSquaredCartesian(double[] vec1, double[] vec2)` The square of the cartesian Distance.
    `boolean` | `equals(Object o)`
    `FunctionValues` | `getValues(Map context, LeafReaderContext readerContext)`
    `int` | `hashCode()`
    `protected String` | `name()`
    `static double` | `vectorDistance(double[] vec1, double[] vec2, double power)` Calculate the p-norm (i.e.
    `static double` | `vectorDistance(double[] vec1, double[] vec2, double power, double oneOverPower)` Calculate the p-norm (i.e.

    - ### Methods inherited from class org.apache.lucene.queries.function.ValueSource

      `getSortField, newContext, toString`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### source1

          protected MultiValueSource source1

    - #### source2

          protected MultiValueSource source2

    - #### power

          protected float power

    - #### oneOverPower

          protected float oneOverPower

  - ### Constructor Detail

    - #### VectorDistanceFunction

          public VectorDistanceFunction(float power,
                                        MultiValueSource source1,
                                        MultiValueSource source2)

  - ### Method Detail

    - #### name

          protected String name()

    - #### distance

          protected double distance(int doc,
                                    FunctionValues dv1,
                                    FunctionValues dv2)

      Calculate the distance
      Parameters:
        `doc` - The current doc
        `dv1` - The values from the first MultiValueSource
        `dv2` - The values from the second MultiValueSource
      Returns:
        The distance

    - #### vectorDistance

          public static double vectorDistance(double[] vec1,
                                              double[] vec2,
                                              double power)

      Calculate the p-norm (i.e. length) between two vectors.

      See Lp space

      Parameters:
        `vec1` - The first vector
        `vec2` - The second vector
        `power` - The power (2 for cartesian distance, 1 for manhattan, etc.)
      Returns:
        The length.
      See Also:
        `vectorDistance(double[], double[], double, double)`

    - #### vectorDistance

          public static double vectorDistance(double[] vec1,
                                              double[] vec2,
                                              double power,
                                              double oneOverPower)

      Calculate the p-norm (i.e. length) between two vectors.
      Parameters:
        `vec1` - The first vector
        `vec2` - The second vector
        `power` - The power (2 for cartesian distance, 1 for manhattan, etc.)
        `oneOverPower` - If you've pre-calculated oneOverPower and cached it, use this method to save one division operation over `vectorDistance(double[], double[], double)`.
      Returns:
        The length.

    - #### distSquaredCartesian

          public static double distSquaredCartesian(double[] vec1,
                                                    double[] vec2)

      The square of the cartesian Distance. Not really a distance, but useful if all that matters is comparing the result to another one.
      Parameters:
        `vec1` - The first point
        `vec2` - The second point
      Returns:
        The squared cartesian distance

    - #### getValues

          public FunctionValues getValues(Map context,
                                          LeafReaderContext readerContext)
                                   throws IOException

      Specified by:
        `getValues` in class `ValueSource`
      Throws:
        `IOException`

    - #### createWeight

          public void createWeight(Map context,
                                   IndexSearcher searcher)
                            throws IOException

      Overrides:
        `createWeight` in class `ValueSource`
      Throws:
        `IOException`

    - #### equals

          public boolean equals(Object o)

      Specified by:
        `equals` in class `ValueSource`

    - #### hashCode

          public int hashCode()

      Specified by:
        `hashCode` in class `ValueSource`

    - #### description

          public String description()

      Specified by:
        `description` in class `ValueSource`

Copyright © 2000-2016 Apache Software Foundation. All Rights Reserved.