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

## org.encog.mathutil
Class VectorAlgebra

    java.lang.Object
      org.encog.mathutil.VectorAlgebra

    public class VectorAlgebra

extends Object

Basic vector algebra operators. Vectors are represented as arrays of doubles. This class was created to support the calculations in the PSO algorithm. This class is thread safe. Contributed by: Geoffroy Noel https://github.com/goffer-looney

Author:
  Geoffroy Noel

Constructor Summary
`VectorAlgebra()`

Method Summary
`void` | `add(double[] v1, double[] v2)` v1 = v1 + v2
`void` | `clampComponents(double[] v, double maxValue)` For each components, reset their value to maxValue if their absolute value exceeds it.
`void` | `copy(double[] dst, double[] src)` dst = src Copy a vector.
`void` | `mul(double[] v, double k)` v = k * v The components of the vector are multiplied by k.
`void` | `mulRand(double[] v, double k)` v = k * U(0,1) * v The components of the vector are multiplied by k and a random number.
`void` | `neg(double[] v)` v = -v
`void` | `randomise(double[] v)` v = U(0, 0.1)
`void` | `randomise(double[] v, double maxValue)` v = U(-1, 1) * maxValue Randomise each component of a vector to [-maxValue, maxValue].
`void` | `sub(double[] v1, double[] v2)` v1 = v1 - v2

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

Constructor Detail

### VectorAlgebra

    public VectorAlgebra()

Method Detail

### add

    public void add(double[] v1,
                    double[] v2)

  v1 = v1 + v2

  Parameters:
    `v1` - an array of doubles
    `v2` - an array of doubles

### sub

    public void sub(double[] v1,
                    double[] v2)

  v1 = v1 - v2

  Parameters:
    `v1` - an array of doubles
    `v2` - an array of doubles

### neg

    public void neg(double[] v)

  v = -v

  Parameters:
    `v` - an array of doubles

### mulRand

    public void mulRand(double[] v,
                        double k)

  v = k * U(0,1) * v The components of the vector are multiplied by k and a random number. A new random number is generated for each component. Thread-safety depends on Random.nextDouble()

  Parameters:
    `v` - an array of doubles.
    `k` - a scalar.

### mul

    public void mul(double[] v,
                    double k)

  v = k * v The components of the vector are multiplied by k.

  Parameters:
    `v` - an array of doubles.
    `k` - a scalar.

### copy

    public void copy(double[] dst,
                     double[] src)

  dst = src Copy a vector.

  Parameters:
    `dst` - an array of doubles
    `src` - an array of doubles

### randomise

    public void randomise(double[] v)

  v = U(0, 0.1)

  Parameters:
    `v` - an array of doubles

### randomise

    public void randomise(double[] v,
                          double maxValue)

  v = U(-1, 1) * maxValue Randomise each component of a vector to [-maxValue, maxValue]. thread-safety depends on Random.nextDouble().

  Parameters:
    `v` - an array of doubles

### clampComponents

    public void clampComponents(double[] v,
                                double maxValue)

  For each components, reset their value to maxValue if their absolute value exceeds it.

  Parameters:
    `v` - an array of doubles
    `maxValue` - if -1 this function does nothing

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

Copyright © 2012. All Rights Reserved.