Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## de.jstacs.utils
Class Normalisation

    java.lang.Object
      de.jstacs.utils.Normalisation

    public class Normalisation

extends Object

This class can be used for normalisation of any double array or a part of a double array.

Author:
  Jens Keilwagen

Constructor Summary
`Normalisation()`

Method Summary
`static double` | `getLogSum(double... lnVal)` Returns the log of the sum of values.
`static double` | `getLogSum(int start, int end, double... lnVal)` Returns the log of the sum of values.
`static double` | `logSumNormalisation(double[] d)` log-sum-normalisation on `d`
`static double` | `logSumNormalisation(double[] d, double offset)` log-sum-normalisation on `d` using offset `offset`
`static double` | `logSumNormalisation(double[] d, int startD, int endD)` log-sum-normalisation on `d` between `startD` and `endD`
`static double` | `logSumNormalisation(double[] d, int startD, int endD, double[] secondValues)` log-sum-normalisation on `d` between `startD` and `endD`
`static double` | `logSumNormalisation(double[] d, int startD, int endD, double[] secondValues, double[] dest, int startDest)` log-sum-normalisation on `d` between `startD` and `endD`, writing the result in `dest` starting at position `startDest`
`static double` | `logSumNormalisation(double[] d, int startD, int endD, double[] dest, int startDest)` log-sum-normalisation on `d` between `startD` and `endD`, writing the result in `dest` starting at position `startDest`
`static double` | `logSumNormalisation(double[] d, int startD, int endD, double offset, double[] secondValues, double[] dest, int startDest)` log-sum-normalisation on `d`, writing the result in `dest` starting at position start`using offset `offset``
`static double` | `logSumNormalisation(double[] d, int startD, int endD, double offset, double[] dest, int start)` log-sum-normalisation on `d` between `startD` and `endD`, writing the result in `dest` starting at position `startDest` using offset `offset`
`static void` | `normalisation(double[] d, double v)` normalisation on `d`, using the value `v` to normalize
`static void` | `normalisation(double[] d, double v, double[] dest, int start)` sum normalisation on `d`, writing the result in `dest` starting at position start`using the value `v` to normalize`
`static void` | `normalisation(double[] d, double v, int start, int end)` sum normalisation on `d`, starting at position start`, stopping at position `end`, using the value `v` to normalize`
`static double` | `sumNormalisation(double[] d)` sum normailsation on `d`
`static double` | `sumNormalisation(double[] d, double[] dest, int start)` sum normalisation on `d`, writing the result in `dest` starting at position start``

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### Normalisation

    public Normalisation()

Method Detail

### getLogSum

    public static double getLogSum(double... lnVal)

  Returns the log of the sum of values.

  Parameters:
    `lnVal` - the logs of the values, i.e. `lnVal[i] = Math.log( val[i] )`
  Returns:
    \log(\sum_i val[i])

### getLogSum

    public static double getLogSum(int start,
                                   int end,
                                   double... lnVal)

  Returns the log of the sum of values.

  Parameters:
    `start` - the first index in lnVal considered for the sum
    `end` - the index after the last index considered for the sum
    `lnVal` - the logs of the values, i.e. `lnVal[i] = Math.log( val[i] )`
  Returns:
    \log(\sum_{i=start}^{end - 1} val[i])

### logSumNormalisation

    public static double logSumNormalisation(double[] d)

  log-sum-normalisation on `d`

  Returns:
    the sum of `d`

### logSumNormalisation

    public static double logSumNormalisation(double[] d,
                                             int startD,
                                             int endD)

  log-sum-normalisation on `d` between `startD` and `endD`

  Returns:
    the sum of `d` between `startD` and `endD`

### logSumNormalisation

    public static double logSumNormalisation(double[] d,
                                             int startD,
                                             int endD,
                                             double[] secondValues)

  log-sum-normalisation on `d` between `startD` and `endD`

  Returns:
    the sum of `d` between `startD` and `endD` and `secondValue`

### logSumNormalisation

    public static double logSumNormalisation(double[] d,
                                             int startD,
                                             int endD,
                                             double[] dest,
                                             int startDest)

  log-sum-normalisation on `d` between `startD` and `endD`, writing the result in `dest` starting at position `startDest`

  Returns:
    the sum of `d` between `startD` and `endD`

### logSumNormalisation

    public static double logSumNormalisation(double[] d,
                                             int startD,
                                             int endD,
                                             double[] secondValues,
                                             double[] dest,
                                             int startDest)

  log-sum-normalisation on `d` between `startD` and `endD`, writing the result in `dest` starting at position `startDest`

  Returns:
    the sum of `d` between `startD` and `endD`

### logSumNormalisation

    public static double logSumNormalisation(double[] d,
                                             double offset)

  log-sum-normalisation on `d` using offset `offset`

  Returns:
    the sum of `d`

### logSumNormalisation

    public static double logSumNormalisation(double[] d,
                                             int startD,
                                             int endD,
                                             double offset,
                                             double[] dest,
                                             int start)

  log-sum-normalisation on `d` between `startD` and `endD`, writing the result in `dest` starting at position `startDest` using offset `offset`

  Returns:
    the sum of `d` between `startD` and `endD`

### logSumNormalisation

    public static double logSumNormalisation(double[] d,
                                             int startD,
                                             int endD,
                                             double offset,
                                             double[] secondValues,
                                             double[] dest,
                                             int startDest)

  log-sum-normalisation on `d`, writing the result in `dest` starting at position start`using offset `offset`

  `
  Returns:
    the sum of `d`

### sumNormalisation

    public static double sumNormalisation(double[] d)

  sum normailsation on `d`

  Returns:
    the sum of d

### sumNormalisation

    public static double sumNormalisation(double[] d,
                                          double[] dest,
                                          int start)

  sum normalisation on `d`, writing the result in `dest` starting at position start`

  `
  Returns:
    the sum of d

### normalisation

    public static void normalisation(double[] d,
                                     double v)

  normalisation on `d`, using the value `v` to normalize

### normalisation

    public static void normalisation(double[] d,
                                     double v,
                                     double[] dest,
                                     int start)

  sum normalisation on `d`, writing the result in `dest` starting at position start`using the value `v` to normalize

  `

### normalisation

    public static void normalisation(double[] d,
                                     double v,
                                     int start,
                                     int end)

  sum normalisation on `d`, starting at position start`, stopping at position `end`, using the value `v` to normalize

  `

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD