encog.js

/*
 * Encog(tm) Core v0.1 - Javascript Version
 * http://www.heatonresearch.com/encog/
 * http://code.google.com/p/encog-java/

 * Copyright 2008-2012 Heaton Research, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *   
 * For more information on Heaton Research copyrights, licenses 
 * and trademarks visit:
 * http://www.heatonresearch.com/copyright
 */

/**
 * The main Encog namespace.  This is the only global property created by Encog.
 * @type {*}
 */
var ENCOG = ENCOG || {
    /**
     * The version of Encog that this is.
     * @property property
     * @type String
     * @final
     */
    VERSION : '1.0',

    /**
     * The Encog platform being used.
     * @property property
     * @type String
     * @final
     */
    PLATFORM : 'javascript',

    /**
     * The precision that Encog uses.
     * @property precision
     * @type String
     * @final
     */
    precision : 1e-10,

    /**
     * A newline character.
     * @property property
     * @type String
     * @final
     */
    NEWLINE : '\n',

    /**
     * The Encog type for activation functions.
     * @property ENCOG_TYPE_ACTIVATION
     * @type String
     * @final
     */
    ENCOG_TYPE_ACTIVATION : 'ActivationFunction',

    /**
     * The Encog type for RBF functions.
     * @property ENCOG_TYPE_ACTIVATION
     * @type String
     * @final
     */
    ENCOG_TYPE_RBF : 'RBF'
};

/**
 * The namespace function, used to define new namespaces.
 * @param namespaceString The namespace that is to be defined.
 * @method namespace
 * @return {Object} The newly created namespace, or existing one.
 */
ENCOG.namespace = function (namespaceString) {
    'use strict';

    var parts = namespaceString.split('.'),
        parent = window,
        currentPart = '',
        i,
        length;

    for (i = 0, length = parts.length; i < length; i += 1) {
        currentPart = parts[i];
        parent[currentPart] = parent[currentPart] || {};
        parent = parent[currentPart];
    }

    return parent;
};

ENCOG.namespace('ENCOG.ActivationSigmoid');
ENCOG.namespace('ENCOG.ActivationTANH');
ENCOG.namespace('ENCOG.ActivationLinear');
ENCOG.namespace('ENCOG.ActivationElliott');
ENCOG.namespace('ENCOG.ActivationElliottSymmetric');
ENCOG.namespace('ENCOG.RadialGaussian');
ENCOG.namespace('ENCOG.RadialMexicanHat');
ENCOG.namespace('ENCOG.Util');
ENCOG.namespace('ENCOG.MathUtil');
ENCOG.namespace('ENCOG.ArrayUtil');
ENCOG.namespace('ENCOG.BasicLayer');
ENCOG.namespace('ENCOG.BasicNetwork');
ENCOG.namespace('ENCOG.PropagationTrainer');
ENCOG.namespace('ENCOG.LinearErrorFunction');
ENCOG.namespace('ENCOG.LinearErrorFunction');
ENCOG.namespace('ENCOG.Swarm');
ENCOG.namespace('ENCOG.Anneal');
ENCOG.namespace('ENCOG.Genetic');
ENCOG.namespace('ENCOG.SOM');
ENCOG.namespace('ENCOG.TrainSOM');
ENCOG.namespace('ENCOG.ReadCSV');
ENCOG.namespace('ENCOG.EGFILE');

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// MathUtil: The following code provides math utilities for Encog                                            //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * The math utilities for Encog.
 * @class MathUtil
 * @constructor
 */
ENCOG.MathUtil = function () {
    'use strict';
};

/**
 * Calculate the hyperbolic tangent.
 * Unfortunately, Javascript does not have this built in.
 * @method tanh
 * @param x The value to calculate for.
 * @return {Number} The result from the calculation.
 */
ENCOG.MathUtil.tanh = function (x) {
    'use strict';
    var pos, neg;

    pos = Math.exp(x);
    neg = Math.exp(-x);

    return (pos - neg) / (pos + neg);

};

/**
 * Calculate the sign of a number, return 0 for zero,
 * 1 for positive, -1 for negative.
 * @method sign
 * @param x The value to calculate for.
 * @return {Number} The result.
 */
ENCOG.MathUtil.sign = function (x) {
    'use strict';
    if (Math.abs(x) < ENCOG.precision) {
        return 0;
    } else if (x > 0) {
        return 1;
    } else {
        return -1;
    }
};

/**
 * Calculate the euclidean distance between a1 and a2.  Use the specified starting index and length.
 * @param a1 The first array to consider.
 * @param a2 The second array to consider.
 * @param startIndex The starting index.
 * @param len The length.
 * @method euclideanDistance
 * @return {Number}
 */
ENCOG.MathUtil.euclideanDistance = function (a1, a2, startIndex, len) {
    'use strict';

    var result = 0, i, diff;
    for (i = startIndex; i < (startIndex + len); i += 1) {
        diff = a1[i] - a2[i];
        result += diff * diff;
    }
    return Math.sqrt(result);
};

/**
 * Determine which multi-dimensional array element, from lst, is the nearest to a1.
 * @param a1 A single-dimension array that is searched for in lst.
 * @param lst A 2d array that contains arrays with the same length of a1.
 * @param k The number of neighbors to find.
 * @param maxDist The maximum distance to consider.
 * @param startIndex The starting index.
 * @param len The length.
 * @return {Array} The k elements from lst that were the closest to a1.
 */
ENCOG.MathUtil.kNearest = function (a1, lst, k, maxDist, startIndex, len) {
    'use strict';
    var result = [], tempDist = [], idx = 0, worstIdx = -1, dist, agent;

    while (idx < lst.length) {
        agent = lst[idx];
        if (a1 !== agent) {
            dist = ENCOG.MathUtil.euclideanDistance(a1, agent, startIndex, len);

            if (dist < maxDist) {
                if (result.length < k) {
                    result.push(agent);
                    tempDist.push(dist);
                    worstIdx = ENCOG.ArrayUtil.arrayMaxIndex(tempDist);
                } else {
                    if (dist < tempDist[worstIdx]) {
                        tempDist[worstIdx] = dist;
                        result[worstIdx] = agent;
                        worstIdx = ENCOG.ArrayUtil.arrayMaxIndex(tempDist);
                    }
                }
            }
        }

        idx += 1;
    }

    return result;
};

/**
 * Generate a random floating point number.
 * @param low The first array to consider.
 * @param high The second array to consider.
 * @method randomFloat
 * @return {Number}
 */
ENCOG.MathUtil.randomFloat = function (low, high) {
    'use strict';
    return (Math.random * (high - low)) + low;
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ArrayUtil: The following code provides array utilities for Encog                                          //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * The Encog array utilities.
 * @class ArrayUtil
 * @constructor
 */
ENCOG.ArrayUtil = function () {
    'use strict';
};

/**
 * Fill an array with a specific value.
 * @method fillArray
 * @param arr The array to fill.
 * @param start The starting index.
 * @param stop The stopping index.
 * @param v The value to fill.
 */
ENCOG.ArrayUtil.fillArray = function (arr, start, stop, v) {
    'use strict';
    var i;

    for (i = start; i < stop; i += 1) {
        arr[i] = v;
    }
};

/**
 * Create a new floating point array.
 * @param sz The size of the array to create.
 * @method newFloatArray
 * @return {Array}
 */
ENCOG.ArrayUtil.newFloatArray = function (sz) {
    'use strict';
    var result;
    result = [];
    while (sz > 0) {
        result.push(0.0);
        sz-=1;
    }
    return result;
};

/**
 * Create a new int array.
 * @param sz The size of the array to create.
 * @method newIntArray
 * @return {Array}
 */
ENCOG.ArrayUtil.newIntArray = function (sz) {
    'use strict';
    var result;
    result = [];
    while ((sz -= 1) > 0) {
        result.push(0);
    }
    return result;
};

/**
 * Fill a 2D array.
 * @param arr The size of the array to create.
 * @param v The value to fill the array with.
 * @method fillArray2D
 */
ENCOG.ArrayUtil.fillArray2D = function (arr, v) {
    'use strict';
    var i, j, row;

    for (i = 0; i < arr.length; i += 1) {
        row = arr[i];
        for (j = 0; j < row.length; j += 1) {
            row[j] = v;
        }
    }
};


/**
 * Randomize an array.
 * @param arr The array to randomize.
 * @param start The starting index in the array.
 * @param stop The stopping index in the array.
 * @param low The low-end of the random range.
 * @param high The high-end of the random range.
 * @method randomizeArray
 */
ENCOG.ArrayUtil.randomizeArray = function (arr, start, stop, low, high) {
    'use strict';
    var i;

    for (i = start; i < stop; i += 1) {
        arr[i] = ENCOG.MathUtil.randomFloat(low, high);
    }
};

/**
 * Randomize a 2D array.
 * @param arr The array to randomize.
 * @param low The low-end of the random range.
 * @param high The high-end of the random range.
 * @method randomizeArray2D
 */
ENCOG.ArrayUtil.randomizeArray2D = function (arr, low, high) {
    'use strict';
    var i, j, row;

    for (i = 0; i < arr.length; i += 1) {
        row = arr[i];
        for (j = 0; j < row.length; j += 1) {
            row[j] = ENCOG.MathUtil.randomFloat(low, high);
        }
    }
};

/**
 * Allocate an array of zeros of the specified size.
 * @method allocate1D
 * @param x The size of the array.
 */
ENCOG.ArrayUtil.allocate1D = function (x) {
    'use strict';
    var i, result;

    result = [];
    for (i = 0; i < x; i += 1) {
        result[i] = 0;
    }

    return result;
};

/**
 * Allocate a 2D array of booleans.
 * @param rows The number of rows.
 * @param cols The number of columns.
 * @return {Array} The allocated array.
 */
ENCOG.ArrayUtil.allocateBoolean2D = function (rows, cols) {
    'use strict';
    var result, row, col, temp;

    result = [
        []
    ];

    for (row = 0; row < rows; row += 1) {
        temp = [];
        for (col = 0; col < cols; col += 1) {
            temp[col] = false;
        }
        result[row] = temp;
    }

    return result;
};

/**
 * Copy an array.
 * @method arrayCopy
 * @param source The source array.
 * @param sourceStart The index to start at in the source.
 * @param target The target array.
 * @param targetStart The target starting index.
 * @param count The count of values to copy.
 */
ENCOG.ArrayUtil.arrayCopy = function (source, sourceStart, target, targetStart, count) {
    'use strict';
    var i;

    for (i = 0; i < count; i += 1) {
        target[i + targetStart] = source[i + sourceStart];
    }
};

/**
 * Generate benchmark data.  This is a random training set.
 * @method generateBenchmarkData
 * @param rowCount The number of rows to generate.
 * @param colCount The number of columns to generate.
 * @return {Array} The resulting array.
 */
ENCOG.ArrayUtil.generateBenchmarkData = function (rowCount, colCount) {
    'use strict';
    var result, item, row, col;

    result = [
        []
    ];

    for (row = 0; row < rowCount; row += 1) {
        item = [];
        for (col = 0; col < colCount; col += 1) {
            item[col] = (Math.random() * 2) - 1;
        }
        result[row] = item;
    }

    return result;
};

/**
 * Calculate the mean of one dimension in the 2D array a1.
 * @method arrayMean
 * @param a1 A 2D array.
 * @param idx The second dimension in a1 to calculate the mean of.
 * @return {Number} The mean of each idx element of a1.
 */
ENCOG.ArrayUtil.arrayMean = function (a1, idx) {
    'use strict';
    var result, i;

    result = 0;
    for (i = 0; i < a1.length; i += 1) {
        result += a1[i][idx];
    }
    result /= a1.length;
    return result;
};

/**
 * Determine the index of the minimum value in an array.
 * @method arrayMinIndex
 * @param a1 A 1D array.
 * @return {Number} Index of the minimum value in the array.
 */
ENCOG.ArrayUtil.arrayMinIndex = function (a1) {
    'use strict';
    var result, resultIndex, i;

    result = Number.MAX_VALUE;
    resultIndex = -1;

    for (i = 0; i < a1.length; i += 1) {
        if (a1[i] < result) {
            result = a1[i];
            resultIndex = i;
        }
    }
    return resultIndex;
};

/**
 * Determine the index of the maximum value in an array.
 * @method arrayMinIndex
 * @param a1 A 1D array.
 * @return {Number} Index of the maximum value in the array.
 */
ENCOG.ArrayUtil.arrayMaxIndex = function (a1) {
    'use strict';
    var result, resultIndex, i;

    result = Number.MIN_VALUE;
    resultIndex = -1;

    for (i = 0; i < a1.length; i += 1) {
        if (a1[i] > result) {
            result = a1[i];
            resultIndex = i;
        }
    }
    return resultIndex;
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Util: The following code provides general utilities for Encog                                             //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Strip leading, and ending, quotes from a string.  If the quotes are there.
 * @method stripQuotes
 * @param s The string to process.
 * @return {String} The string, with stripped quotes.
 */
ENCOG.Util.stripQuotes = function (s) {
    'use strict';
    var l = s.length;
    if (s[0] === '\"' || s[0] === '\'') {
        s = s.substr(1);
        l -= 1;
    }

    if (s[l - 1] === '\"' || s[l - 1] === '\'') {
        s = s.substr(0, l - 1);
    }

    return s;
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Activation Functions: The following code implements activation functions used by Encog.                    //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * The sigmoid activation function takes on a sigmoidal shape. Only positive
 * numbers are generated. Do not use this activation function if negative number
 * output is desired.
 * @constructor
 * @class ActivationSigmoid
 */
ENCOG.ActivationSigmoid = function () {
    'use strict';
};
ENCOG.ActivationSigmoid.prototype = {
    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : "ActivationSigmoid",

    /**
     * The Encog Type of this object.
     * @property encogType
     * @type String
     * @final
     */
    encogType : ENCOG.ENCOG_TYPE_ACTIVATION,

    /**
     * Calculate the activation function for the specified value.
     * @method activationFunction
     * @param x An array to calculate the values for.
     * @param start The starting point in the array to calculate.
     * @param size The size to calculate.
     */
    activationFunction : function (x, start, size) {
        'use strict';
        var i;

        for (i = start; i < start + size; i += 1) {
            x[i] = 1.0 / (1.0 + Math.exp(-1 * x[i]));
        }
    },

    /**
     * Calculate the derivative. For efficiency both the before and after
     * activation values are passed in.  Many activation derivatives can
     * be more efficiently calculated using the value after the regular
     * activation is calculated.
     * @param b The value before the regular activation was calculated.
     * @param a The value after the regular activation was calculated.
     * @return {Number} The result.
     */
    derivativeFunction : function (b, a) {
        'use strict';
        return a * (1.0 - a);
    }
};

/**
 * Create a Sigmoid activation function.
 * @method create
 * @return {ENCOG.ActivationSigmoid} The newly created activation function.
 */
ENCOG.ActivationSigmoid.create = function () {
    'use strict';
    return new ENCOG.ActivationSigmoid();
};

/**
 * The hyperbolic tangent activation function takes the curved shape of the
 * hyperbolic tangent. This activation function produces both positive and
 * negative output. Use this activation function if both negative and positive
 * output is desired.
 * @constructor
 * @class ActivationTANH
 */
ENCOG.ActivationTANH = function () {
    'use strict';
};

ENCOG.ActivationTANH.prototype = {
    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : "ActivationTANH",
    encogType : ENCOG.ENCOG_TYPE_ACTIVATION,

    /**
     * Calculate the activation function for the specified value.
     * @method activationFunction
     * @param x An array to calculate the values for.
     * @param start The starting point in the array to calculate.
     * @param size The size to calculate.
     */
    activationFunction : function (x, start, size) {
        'use strict';
        var i;

        for (i = start; i < start + size; i += 1) {
            x[i] = ENCOG.MathUtil.tanh(x[i]);
        }
    },

    /**
     * Calculate the derivative. For efficiency both the before and after
     * activation values are passed in.  Many activation derivatives can
     * be more efficiently calculated using the value after the regular
     * activation is calculated.
     * @param b The value before the regular activation was calculated.
     * @param a The value after the regular activation was calculated.
     * @return {Number} The result.
     */
    derivativeFunction : function (b, a) {
        'use strict';
        return (1.0 - a * a);
    }
};

/**
 * Create a TANH activation function.
 * @method create
 * @return {ENCOG.ActivationTANH} The newly created activation function.
 */
ENCOG.ActivationTANH.create = function () {
    'use strict';
    return new ENCOG.ActivationTANH();
};

/**
 * The Linear layer is really not an activation function at all. The input is
 * simply passed on, unmodified, to the output. This activation function is
 * primarily theoretical and of little actual use. Usually an activation
 * function that scales between 0 and 1 or -1 and 1 should be used.
 * @constructor
 * @class ActivationLinear
 */
ENCOG.ActivationLinear = function () {
    'use strict';
};
ENCOG.ActivationLinear.prototype = {

    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : "ActivationLinear",

    /**
     * The encog type of this object.
     * @property encogType
     * @type String
     * @final
     */
    encogType : ENCOG.ENCOG_TYPE_ACTIVATION,

    /**
     * Calculate the activation function for the specified value.
     * @method activationFunction
     */
    activationFunction : function () {
        'use strict';
    },

    /**
     * Calculate the derivative. For efficiency both the before and after
     * activation values are passed in.  Many activation derivatives can
     * be more efficiently calculated using the value after the regular
     * activation is calculated.
     * @return {Number} The result.
     */
    derivativeFunction : function () {
        'use strict';
        return 1.0;
    }
};

/**
 * Create a Linear activation function.
 * @method create
 * @return {ENCOG.ActivationTANH} The newly created activation function.
 */
ENCOG.ActivationLinear.create = function () {
    'use strict';
    return new ENCOG.ActivationLinear();
};

/**
 * Computationally efficient alternative to ActivationSigmoid.
 * Its output is in the range [0, 1], and it is derivable.
 *
 * It will approach the 0 and 1 more slowly than Sigmoid so it
 * might be more suitable to classification tasks than predictions tasks.
 *
 * Elliott, D.L. "A better activation function for artificial neural networks", 1993
 * http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.46.7204&rep=rep1&type=pdf
 * @constructor
 * @class ActivationElliott
 */
ENCOG.ActivationElliott = function () {
    'use strict';
};

ENCOG.ActivationElliott.prototype = {

    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : "ActivationElliott",

    /**
     * The encog type of this object.
     * @property encogType
     * @type String
     * @final
     */
    encogType : ENCOG.ENCOG_TYPE_ACTIVATION,
    slope : 1,

    /**
     * Calculate the activation function for the specified value.
     * @method activationFunction
     * @param x An array to calculate the values for.
     * @param start The starting point in the array to calculate.
     * @param size The size to calculate.
     */
    activationFunction : function (x, start, size) {
        'use strict';
        var i;

        for (i = start; i < start + size; i += 1) {
            x[i] = ((x[i] * this.slope) / 2) / (1 + Math.abs(x[i] * this.slope)) + 0.5;
        }
    },

    /**
     * Calculate the derivative. For efficiency both the before and after
     * activation values are passed in.  Many activation derivatives can
     * be more efficiently calculated using the value after the regular
     * activation is calculated.
     * @param b The value before the regular activation was calculated.
     * @param a The value after the regular activation was calculated.
     * @return {Number} The result.
     */
    derivativeFunction : function (b, a) {
        'use strict';
        return this.slope / (2.0 * (1.0 + Math.abs(b * this.slope)) * (1 + Math.abs(b * this.slope)));
    }
};

/**
 * Create a Elliott activation function.
 * @method create
 * @return {ENCOG.ActivationElliott} The newly created activation function.
 */
ENCOG.ActivationElliott.create = function (s) {
    'use strict';
    var result = new ENCOG.ActivationElliott();
    result.slope = s || 1;
    return result;
};

//

/**
 * Computationally efficient alternative to ActivationTANH.
 * Its output is in the range [-1, 1], and it is derivable.
 *
 * It will approach the -1 and 1 more slowly than Tanh so it
 * might be more suitable to classification tasks than predictions tasks.
 *
 * Elliott, D.L. "A better activation function for artificial neural networks", 1993
 * http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.46.7204&rep=rep1&type=pdf
 * @constructor
 * @class ActivationElliottSymmetric
 */
ENCOG.ActivationElliottSymmetric = function () {
    'use strict';
};

ENCOG.ActivationElliottSymmetric.prototype = {

    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : "ActivationElliottSymmetric",

    /**
     * The encog type of this object.
     * @property encogType
     * @type String
     * @final
     */
    encogType : ENCOG.ENCOG_TYPE_ACTIVATION,
    slope : 1,

    /**
     * Calculate the activation function for the specified value.
     * @method activationFunction
     * @param x An array to calculate the values for.
     * @param start The starting point in the array to calculate.
     * @param size The size to calculate.
     */
    activationFunction : function (x, start, size) {
        'use strict';
        var i;
        for (i = start; i < start + size; i += 1) {
            x[i] = (x[i] * this.slope) / (1 + Math.abs(x[i] * this.slope));
        }
    },

    /**
     * Calculate the derivative. For efficiency both the before and after
     * activation values are passed in.  Many activation derivatives can
     * be more efficiently calculated using the value after the regular
     * activation is calculated.
     * @param b The value before the regular activation was calculated.
     * @param a The value after the regular activation was calculated.
     * @return {Number} The result.
     */
    derivativeFunction : function (b, a) {
        'use strict';
        var d = (1.0 + Math.abs(b * this.slope));
        return this.slope / (d * d);
    }
};

/**
 * Create Elliott Symmetric activation function.
 * @method create
 * @return {ENCOG.ActivationElliottSymmetric} The newly created activation function.
 */
ENCOG.ActivationElliottSymmetric.create = function (s) {
    'use strict';
    var result = new ENCOG.ActivationElliottSymmetric();
    result.slope = s || 1;
    return result;
};


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Radial Basis Functions: The following code implements Radial Basis Functions used by Encog                 //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

ENCOG.RadialGaussian = function () {
    'use strict';
};

ENCOG.RadialGaussian.prototype = {

    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : "RadialGaussian",

    /**
     * The encog type of this object.
     * @property encogType
     * @type String
     * @final
     */
    encogType : ENCOG.ENCOG_TYPE_RBF,
    center : [],
    width : 1,
    peak : 1,

    /**
     * Calculate the activation function for the specified value.
     * @method calculate
     * @param x An array to calculate the values for.
     */
    calculate : function (x) {
        'use strict';

        var value = 0, i;

        for (i = 0; i < this.center.length; i += 1) {
            value += Math.pow(x[i] - this.center[i], 2) / (2.0 * this.width * this.width);
        }
        return this.peak * Math.exp(-value);
    }
};

/**
 * Create a gaussian RBF.
 * @method create
 * @return {ENCOG.ActivationElliottSymmetric} The newly created activation function.
 */
ENCOG.RadialGaussian.create = function (thePeak, theCenters, theWidth) {
    'use strict';
    var result = new ENCOG.RadialGaussian();
    result.peak = thePeak || 1;
    result.centers = theCenters;
    result.width = theWidth || 1;
    return result;
};

ENCOG.RadialMexicanHat = function () {
    'use strict';
};

ENCOG.RadialMexicanHat.prototype = {

    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : "RadialMexicanHat",

    /**
     * The encog type of this object.
     * @property encogType
     * @type String
     * @final
     */
    encogType : ENCOG.ENCOG_TYPE_RBF,
    center : [],
    width : [],
    peak : 1,

    /**
     * Calculate the activation function for the specified value.
     * @method calculate
     * @param x An array to calculate the values for.
     */
    calculate : function (x) {
        'use strict';

        // calculate the "norm", but don't take square root
        // don't square because we are just going to square it
        var norm = 0, i;
        for (i = 0; i < this.center.length; i += 1) {
            norm += Math.pow(x[i] - this.center[i], 2);
        }

        // calculate the value

        return this.peak * (1 - norm) * Math.exp(-norm / 2);
    }
};

/**
 * Create a Mexican Hat RBF.
 * @method create
 * @return {ENCOG.ActivationElliottSymmetric} The newly created activation function.
 */
ENCOG.RadialMexicanHat.create = function (thePeak, theCenters, theWidth) {
    'use strict';
    var result = new ENCOG.RadialMexicanHat();
    result.peak = thePeak || 1;
    result.centers = theCenters;
    result.width = theWidth || 1;
    return result;
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Error Functions: The following implements Error Functions ued by Encog                                     //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * The Linear Error function is used to calculate the value that propagation
 * training seeks to minimize. The linear function simply subtracts
 * desired from actual values.
 * @class LinearErrorFunction
 * @constructor
 */
ENCOG.LinearErrorFunction = function () {
    'use strict';
};

ENCOG.LinearErrorFunction.prototype = {
    /**
     * Calculate the error value for the ideal and actual results.
     * @method calculateError
     * @param ideal The ideal output.
     * @param actual The actual output.
     * @param error The resulting error.
     */
    calculateError : function (ideal, actual, error) {
        'use strict';
        var i;
        for (i = 0; i < actual.length; i += 1) {
            error[i] = ideal[i] - actual[i];
        }

    }
};

/**
 * Create the linear error function.
 * @return {ENCOG.LinearErrorFunction}
 */
ENCOG.LinearErrorFunction.create = function () {
    'use strict';
    return new ENCOG.LinearErrorFunction();
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Feedforward Neural Network: The following code implements Feedforward neural networks for Encog            //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * The BasicLayer class is used to specify neural networks.  Once
 * the neural network is created, this class is no longer used.
 * @class BasicLayer
 * @constructor
 */
ENCOG.BasicLayer = function () {
    'use strict';
};

ENCOG.BasicLayer.prototype = {

    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : 'BasicLayer',

    /**
     * The activation function to use for this layer.
     * @property activation
     * @type {Object}
     */
    activation : null,

    /**
     * The neuron count for this layer.
     * @property count The neuron count.
     * @type {number}
     */
    count : null,

    /**
     * The activation level for the bias neuron.  Typically 1
     * if there are bias neurons, or zero if none.
     * @property biasActivation
     * @type {number}
     */
    biasActivation : null,

    /**
     * If this layer has context fed by other layers, this
     * property points to those other layers.
     * @property contextFedBy
     * @type {number}
     */
    contextFedBy : null,

    /**
     * Calculate the total count, including bias, of neurons.
     * @method calcTotalCount
     * @return {*}
     */
    calcTotalCount : function () {
        'use strict';
        if (this.contextFedBy === null) {
            return this.count + (this.hasBias() ? 1 : 0);
        } else {
            return this.count + (this.hasBias() ? 1 : 0)
                + this.contextFedBy.count;
        }
    },

    /**
     * Determine if this layer has bias.
     * @return {Boolean} True, if this layer has bias.
     */
    hasBias : function () {
        'use strict';
        return Math.abs(this.biasActivation) > ENCOG.precision;
    },

    /**
     * Calculate the count of context neurons.
     * @return {*} The count of context neurons.
     */
    calcContextCount : function () {
        'use strict';
        if (this.contextFedBy === null) {
            return 0;
        } else {
            return this.contextFedBy.count;
        }
    }
};

/**
 * Create a BasicLayer.
 * @param activation The activation function used by this layer.
 * @param count The neuron count for this layer.
 * @param biasActivation The bias activation for this layer, specify
 * 1 (or desired activation) to have a bias neuron, or 0 for none.
 * @return {ENCOG.BasicLayer} The newly created layer.
 */
ENCOG.BasicLayer.create = function (activation, count, biasActivation) {
    'use strict';
    var result;

    if (activation.encogType !== ENCOG.ENCOG_TYPE_ACTIVATION) {
        throw new Error("Invalid activation function.");
    }
    result = new ENCOG.BasicLayer();
    result.activation = activation;
    result.count = count;
    result.biasActivation = biasActivation;
    result.contextFedBy = null;
    return result;
};

/**
 * Basic Network, provides neural network functionality.
 *
 * @class BasicNetwork
 * @constructor
 **/
ENCOG.BasicNetwork = function () {
    'use strict';
};
ENCOG.BasicNetwork.prototype = {
    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : 'BasicNetwork',

    /**
     * The input neuron count.
     * @property inputCount
     * @type number
     */
    inputCount : null,

    /**
     * The output neuron count.
     * @property outputCount
     * @type number
     */
    outputCount : null,

    /**
     * The individual layer neuron counts.
     * @property layerCounts
     * @type Array
     */
    layerCounts : null,

    /**
     * The individual layer neuron context counts.
     * @property layerContextCount
     * @type Array
     */
    layerContextCount : null,

    /**
     * The weight indexes.
     * @property weightIndex
     * @type Array
     */
    weightIndex : null,

    /**
     * The individual layer indexes.
     * @property layerIndex
     * @type Array
     */
    layerIndex : null,

    /**
     * The activation functions.
     * @property activationFunctions
     * @type Array
     */
    activationFunctions : null,

    /**
     * The layer feed counts.  These are neurons that are actually fed from
     * the previous layer (i.e. not bias or context).
     * @property layerFeedCounts
     * @type Array
     */
    layerFeedCounts : null,

    /**
     * The context target feed counts.
     * @property contextTargetSize
     * @type Array
     */
    contextTargetOffset : null,

    /**
     * The context target sizes.
     * @property contextTargetSize
     * @type Array
     */
    contextTargetSize : null,

    /**
     * The activation level for bias neurons on this layer.
     * @property biasActivation
     * @type Array
     */
    biasActivation : null,

    /**
     * The layer to begin training at.
     * @property beginTraining
     * @type Number
     */
    beginTraining : null,

    /**
     * The layer to end training at.
     * @property endTraining
     * @type Number
     */
    endTraining : null,

    /**
     * The weights of the neural network.
     * @property weights
     * @type Array
     */
    weights : null,

    /**
     * The layer outputs.
     * @property layerOutput
     * @type Array
     */
    layerOutput : null,

    /**
     * The layer sums.
     * @property layerOutput
     * @type Array
     */
    layerSums : null,

    /**
     * The connection limit.
     * @property layerOutput
     * @type Number
     */
    connectionLimit : ENCOG.precision,

    clearContext : function () {
        'use strict';
        var index, i, hasBias;

        index = 0;
        for (i = 0; i < this.layerIndex.length; i += 1) {

            hasBias = (this.layerContextCount[i] + this.layerFeedCounts[i]) !== this.layerCounts[i];

            // fill in regular neurons
            ENCOG.ArrayUtil.fillArray(this.layerOutput, index, index + this.layerFeedCounts[i], 0);
            index += this.layerFeedCounts[i];

            // fill in the bias
            if (hasBias) {
                this.layerOutput[index] = this.biasActivation[i];
                index += 1;
            }

            // fill in context
            ENCOG.ArrayUtil.fillArray(this.layerOutput, index, index + this.layerContextCount[i], 0);
            index += this.layerContextCount[i];
        }
    },

    randomize : function () {
        'use strict';
        var i;
        for (i = 0; i < this.weights.length; i += 1) {
            this.weights[i] = (Math.random() * 2.0) - 1.0;
        }
    },

    computeLayer : function (currentLayer) {
        'use strict';
        var inputIndex, outputIndex, inputSize, outputSize, index, limitX, limitY,
            x, sum, offset, y;

        inputIndex = this.layerIndex[currentLayer];
        outputIndex = this.layerIndex[currentLayer - 1];
        inputSize = this.layerCounts[currentLayer];
        outputSize = this.layerFeedCounts[currentLayer - 1];

        index = this.weightIndex[currentLayer - 1];

        limitX = outputIndex + outputSize;
        limitY = inputIndex + inputSize;

        // weight values
        for (x = outputIndex; x < limitX; x += 1) {
            sum = 0;
            for (y = inputIndex; y < limitY; y += 1) {
                sum += this.weights[index] * this.layerOutput[y];
                index += 1;
            }
            this.layerSums[x] = sum;
            this.layerOutput[x] = sum;
        }

        this.activationFunctions[currentLayer - 1].activationFunction(
            this.layerOutput,
            outputIndex,
            outputSize
        );

        // update context values
        offset = this.contextTargetOffset[currentLayer];

        ENCOG.ArrayUtil.arrayCopy(this.layerOutput, outputIndex,
            this.layerOutput, offset, this.contextTargetSize[currentLayer]);
    },

    compute : function (input, output) {
        'use strict';
        var sourceIndex, i, offset;

        sourceIndex = this.layerOutput.length
            - this.layerCounts[this.layerCounts.length - 1];

        ENCOG.ArrayUtil.arrayCopy(input, 0, this.layerOutput, sourceIndex,
            this.inputCount);

        for (i = this.layerIndex.length - 1; i > 0; i -= 1) {
            this.computeLayer(i);
        }

        // update context values
        offset = this.contextTargetOffset[0];

        ENCOG.ArrayUtil.arrayCopy(this.layerOutput, 0, this.layerOutput,
            offset, this.contextTargetSize[0]);

        ENCOG.ArrayUtil.arrayCopy(this.layerOutput, 0, output, 0, this.outputCount);
    },
    evaluate : function (inputData, idealData) {
        'use strict';
        var i, j, input, ideal, output, diff, globalError, setSize;

        output = [];
        globalError = 0;
        setSize = 0;

        for (i = 0; i < inputData.length; i += 1) {
            input = inputData[i];
            ideal = idealData[i];
            this.compute(input, output);
            for (j = 0; j < ideal.length; j += 1) {
                diff = ideal[j] - output[j];
                globalError += diff * diff;
                setSize += 1;
            }
        }

        return globalError / setSize;
    }


};


ENCOG.BasicNetwork.create = function (layers) {
    'use strict';
    var layerCount, result, index, neuronCount, weightCount, i, j, layer, nextLayer, neuronIndex;

    result = new ENCOG.BasicNetwork();

    if( layers!=null ) {
        layerCount = layers.length;

        result.inputCount = layers[0].count;
        result.outputCount = layers[layerCount - 1].count;

        result.layerCounts = ENCOG.ArrayUtil.allocate1D(layerCount);
        result.layerContextCount = ENCOG.ArrayUtil.allocate1D(layerCount);
        result.weightIndex = ENCOG.ArrayUtil.allocate1D(layerCount);
        result.layerIndex = ENCOG.ArrayUtil.allocate1D(layerCount);
        result.activationFunctions = ENCOG.ArrayUtil.allocate1D(layerCount);
        result.layerFeedCounts = ENCOG.ArrayUtil.allocate1D(layerCount);
        result.contextTargetOffset = ENCOG.ArrayUtil.allocate1D(layerCount);
        result.contextTargetSize = ENCOG.ArrayUtil.allocate1D(layerCount);
        result.biasActivation = ENCOG.ArrayUtil.allocate1D(layerCount);

        index = 0;
        neuronCount = 0;
        weightCount = 0;

        for (i = layers.length - 1; i >= 0; i -= 1) {
            layer = layers[i];
            nextLayer = null;

            if (i > 0) {
                nextLayer = layers[i - 1];
            }

            result.biasActivation[index] = layer.biasActivation;
            result.layerCounts[index] = layer.calcTotalCount();
            result.layerFeedCounts[index] = layer.count;
            result.layerContextCount[index] = layer.calcContextCount();
            result.activationFunctions[index] = layer.activation;

            neuronCount += layer.calcTotalCount();

            if (nextLayer !== null) {
                weightCount += layer.count * nextLayer.calcTotalCount();
            }

            if (index === 0) {
                result.weightIndex[index] = 0;
                result.layerIndex[index] = 0;
            } else {
                result.weightIndex[index] = result.weightIndex[index - 1]
                    + (result.layerCounts[index] * result.layerFeedCounts[index - 1]);
                result.layerIndex[index] = result.layerIndex[index - 1]
                    + result.layerCounts[index - 1];
            }

            neuronIndex = 0;
            for (j = layers.length - 1; j >= 0; j -= 1) {
                if (layers[j].contextFedBy === layer) {
                    result.hasContext = true;
                    result.contextTargetSize[index] = layers[j].calcContextCount();
                    result.contextTargetOffset[index] = neuronIndex
                        + (layers[j].calcTotalCount() - layers[j]
                        .calcContextCount());
                }
                neuronIndex += layers[j].calcTotalCount();
            }

            index += 1;
        }

        result.beginTraining = 0;
        result.endTraining = result.layerCounts.length - 1;

        result.weights = ENCOG.ArrayUtil.allocate1D(weightCount);
        result.layerOutput = ENCOG.ArrayUtil.allocate1D(neuronCount);
        result.layerSums = ENCOG.ArrayUtil.allocate1D(neuronCount);

        result.clearContext();
    }
    return result;
};

/**
 * Propagation training, includes RPROP and Back Propagation.
 *
 * @class PropagationTrainer
 * @constructor
 **/
ENCOG.PropagationTrainer = function () {
    'use strict';
};

ENCOG.PropagationTrainer.prototype = {
    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : 'PropagationTrainer',
    /**
     * The POSITIVE ETA value. This is specified by the resilient propagation
     * algorithm. This is the percentage by which the deltas are increased by if
     * the partial derivative is greater than zero.
     */
    POSITIVE_ETA : 1.2,

    /**
     * The NEGATIVE ETA value. This is specified by the resilient propagation
     * algorithm. This is the percentage by which the deltas are increased by if
     * the partial derivative is less than zero.
     */
    NEGATIVE_ETA : 0.5,

    /**
     * The minimum delta value for a weight matrix value.
     */
    DELTA_MIN : 1e-6,

    /**
     * The maximum amount a delta can reach.
     */
    MAX_STEP : 50,

    /**
     * The network that is being trained.
     *
     * @property network
     * @type Object
     * @default null
     **/
    network : null,

    /**
     * The input training data.
     *
     * @property trainingInput
     * @type Array
     * @default null
     **/
    trainingInput : null,

    /**
     * The ideal results from training.
     *
     * @property trainingIdeal
     * @type Array
     * @default null
     **/
    trainingIdeal : null,

    /**
     * The type of training:
     *
     * "BPROP" - Backpropagation.
     * "RPROP" - Resilient propagation.
     *
     * @property type
     * @type String
     * @default null
     **/
    type : null,

    /**
     * The learning rate.
     *
     * @property learningRate
     * @type number
     * @default null
     **/
    learningRate : null,

    /**
     * The momentum.
     *
     * @property momentum
     * @type number
     * @default null
     **/
    momentum : null,

    /**
     * The layer detla's, these are used to calculate the gradients.
     *
     * @property layerDelta
     * @type Array
     * @default null
     **/
    layerDelta : null,

    /**
     * The gradients.
     *
     * @property gradients
     * @type Array
     * @default null
     **/
    gradients : null,

    /**
     * The last gradients.
     *
     * @property lastGradient
     * @type Array
     * @default null
     **/
    lastGradient : null,

    /**
     * The last weight deltas.
     *
     * @property lastDelta
     * @type Array
     * @default null
     **/
    lastDelta : null,

    /**
     * The actual output from the neural network.
     *
     * @property actual
     * @type number
     * @default null
     **/
    actual : null,

    /**
     * The flat spot adjustment.
     *
     * @property flatSpot
     * @type number
     * @default null
     **/
    flatSpot : null,

    /**
     * The error function.
     *
     * @property errorFunction
     * @type Function
     * @default LinearErrorFunction
     **/
    errorFunction : ENCOG.LinearErrorFunction.create(),

    /**
     * The weight update values.
     *
     * @property updateValues
     * @type number
     * @default null
     **/
    updateValues : null,

    processLevel : function (currentLevel) {
        'use strict';
        var toLayerIndex, fromLayerIndex, index, fromLayerSize, toLayerSize, activation,
            currentFlatSpot, yi, output, sum, xi, wi, y, x;

        fromLayerIndex = this.network.layerIndex[currentLevel + 1];
        toLayerIndex = this.network.layerIndex[currentLevel];
        fromLayerSize = this.network.layerCounts[currentLevel + 1];
        toLayerSize = this.network.layerFeedCounts[currentLevel];

        index = this.network.weightIndex[currentLevel];
        activation = this.network.activationFunctions[currentLevel + 1];
        currentFlatSpot = this.flatSpot[currentLevel + 1];

        // handle weights
        yi = fromLayerIndex;
        for (y = 0; y < fromLayerSize; y += 1) {
            output = this.network.layerOutput[yi];
            sum = 0;
            xi = toLayerIndex;
            wi = index + y;
            for (x = 0; x < toLayerSize; x += 1) {
                this.gradients[wi] += output * this.layerDelta[xi];
                sum += this.network.weights[wi] * this.layerDelta[xi];
                wi += fromLayerSize;
                xi += 1;
            }

            this.layerDelta[yi] = sum
                * (activation.derivativeFunction(this.network.layerSums[yi], this.network.layerOutput[yi]) + currentFlatSpot);
            yi += 1;
        }
    },

    learnBPROP : function () {
        'use strict';
        var i, delta;

        for (i = 0; i < this.network.weights.length; i += 1) {
            delta = (this.gradients[i] * this.learningRate) + (this.lastDelta[i] * this.momentum);
            this.lastDelta[i] = delta;
            this.network.weights[i] += delta;
        }
    },

    learnRPROP : function () {
        'use strict';
        var delta, change, weightChange, i;

        for (i = 0; i < this.network.weights.length; i += 1) {
            // multiply the current and previous gradient, and take the
            // sign. We want to see if the gradient has changed its sign.
            change = ENCOG.MathUtil.sign(this.gradients[i] * this.lastGradient[i]);
            weightChange = 0;

            // if the gradient has retained its sign, then we increase the
            // delta so that it will converge faster
            if (change > 0) {
                delta = this.updateValues[i]
                    * this.POSITIVE_ETA;
                delta = Math.min(delta, this.MAX_STEP);
                weightChange = ENCOG.MathUtil.sign(this.gradients[i]) * delta;
                this.updateValues[i] = delta;
                this.lastGradient[i] = this.gradients[i];
            } else if (change < 0) {
                // if change<0, then the sign has changed, and the last
                // delta was too big
                delta = this.updateValues[i]
                    * this.NEGATIVE_ETA;
                delta = Math.max(delta, this.DELTA_MIN);
                this.updateValues[i] = delta;
                weightChange = -this.lastDelta[i];
                // set the previous gradient to zero so that there will be no
                // adjustment the next iteration
                this.lastGradient[i] = 0;
            } else if (change === 0) {
                // if change==0 then there is no change to the delta
                delta = this.updateValues[i];
                weightChange = ENCOG.MathUtil.sign(this.gradients[i]) * delta;
                this.lastGradient[i] = this.gradients[i];
            }

            this.network.weights[i] += weightChange;
        }
    },


    process : function (input, ideal, s) {
        'use strict';
        var i, j, delta;

        this.network.compute(input, this.actual);

        for (j = 0; j < ideal.length; j += 1) {
            delta = this.actual[j] - ideal[j];
            this.globalError = this.globalError + (delta * delta);
            this.setSize += 1;
        }

        this.errorFunction.calculateError(ideal, this.actual, this.layerDelta);

        for (i = 0; i < this.actual.length; i += 1) {
            this.layerDelta[i] = ((this.network.activationFunctions[0]
                .derivativeFunction(this.network.layerSums[i], this.network.layerOutput[i]) + this.flatSpot[0]))
                * (this.layerDelta[i] * s);
        }

        for (i = this.network.beginTraining; i < this.network.endTraining; i += 1) {
            this.processLevel(i);
        }
    },

    iteration : function () {
        'use strict';
        var i;
        this.globalError = 0;
        this.setSize = 0;
        this.actual = [];

        ENCOG.ArrayUtil.fillArray(this.gradients, 0, this.gradients.length, 0);
        ENCOG.ArrayUtil.fillArray(this.lastDelta, 0, this.lastDelta.length, 0);

        for (i = 0; i < this.trainingInput.length; i += 1) {
            this.process(this.trainingInput[i], this.trainingIdeal[i], 1.0);
        }

        if (this.type === "BPROP") {
            this.learnBPROP();
        } else if (this.type === "RPROP") {
            this.learnRPROP();
        }

        this.error = this.globalError / this.setSize;
    }

};

ENCOG.PropagationTrainer.create = function (network, input, ideal, type, learningRate, momentum) {
    'use strict';
    var result = new ENCOG.PropagationTrainer();
    result.network = network;
    result.trainingInput = input;
    result.trainingIdeal = ideal;
    result.type = type;
    result.learningRate = learningRate;
    result.momentum = momentum;

    result.layerDelta = ENCOG.ArrayUtil.newFloatArray(network.layerOutput.length);
    result.gradients = ENCOG.ArrayUtil.newFloatArray(network.weights.length);
    result.lastGradient = ENCOG.ArrayUtil.newFloatArray(network.weights.length);
    result.lastDelta = ENCOG.ArrayUtil.newFloatArray(network.weights.length);
    result.actual = ENCOG.ArrayUtil.newFloatArray(network.outputCount);
    result.flatSpot = ENCOG.ArrayUtil.newFloatArray(network.layerOutput.length);

    result.updateValues = ENCOG.ArrayUtil.newFloatArray(network.weights.length);

    ENCOG.ArrayUtil.fillArray(result.lastGradient, 0, result.lastGradient.length, 0);
    ENCOG.ArrayUtil.fillArray(result.updateValues, 0, result.updateValues.length, 0.1);
    ENCOG.ArrayUtil.fillArray(result.flatSpot, 0, network.weights.length, 0);

    return result;
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Swarm: The following code implements Encog swarm                                                          //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Swarm algorithm.
 *
 * @class Swarm
 * @constructor
 **/
ENCOG.Swarm = function () {
    'use strict';
};


ENCOG.Swarm.prototype = {
    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : 'Swarm',

    /**
     * An array of agents.
     * @property agents
     * @type Array
     */
    agents : null,

    /**
     * A call back that is called with the neighbors of each agent.
     * Format: callbackNeighbors(currentIndex,neighbors).
     * @property NAME
     * @type function
     * @final
     */
    callbackNeighbors : null,

    /**
     * The degree to which cohesion is applied to steering the agent.
     * Cohesion is the desire to move towards groups of other agents.
     * @property constCohesion
     * @type number
     */
    constCohesion : 0.01,

    /**
     * The degree to which alignment is applied to steering the agent.
     * Alignment is the desire to keep all particles moving in the same direction.
     * @property constAlignment
     * @type number
     */
    constAlignment : 0.5,

    /**
     * The degree to which separation is applied to steering the agent.
     * Separation is the desire to not be too close to another particle.
     * @property constSeparation
     * @type number
     */
    constSeparation : 0.25,

    iteration : function () {
        'use strict';
        var i, neighbors, meanX, meanY, dx, dy, targetAngle, nearest, separation, alignment, cohesion, turnAmount;

        // loop over all particles.
        for (i = 0; i < this.agents.length; i += 1) {
            ///////////////////////////////////////////////////////////////
            // Begin implementation of three very basic laws of flocking.
            ///////////////////////////////////////////////////////////////
            targetAngle = 0;

            neighbors = ENCOG.MathUtil.kNearest(this.agents[i], this.agents, 5, Number.MAX_VALUE, 0, 2);
            nearest = ENCOG.MathUtil.kNearest(this.agents[i], this.agents, 5, 10, 0, 2);

            // 1. Separation - avoid crowding neighbors (short range repulsion)
            separation = 0;
            if (nearest.length > 0) {
                meanX = ENCOG.ArrayUtil.arrayMean(nearest, 0);
                meanY = ENCOG.ArrayUtil.arrayMean(nearest, 1);
                dx = meanX - this.agents[i][0];
                dy = meanY - this.agents[i][1];
                separation = (Math.atan2(dx, dy) * 180 / Math.PI) - this.agents[i][2];
                separation += 180;
            }

            // 2. Alignment - steer towards average heading of neighbors
            alignment = 0;

            if (neighbors.length > 0) {
                alignment = ENCOG.ArrayUtil.arrayMean(neighbors, 2) - this.agents[i][2];
            }

            if (this.callbackNeighbors !== null) {
                this.callbackNeighbors(i, neighbors);
            }

            // 3. Cohesion - steer towards average position of neighbors (long range attraction)
            cohesion = 0;

            if (neighbors.length > 0) {
                meanX = ENCOG.ArrayUtil.arrayMean(this.agents, 0);
                meanY = ENCOG.ArrayUtil.arrayMean(this.agents, 1);
                dx = meanX - this.agents[i][0];
                dy = meanY - this.agents[i][1];
                cohesion = (Math.atan2(dx, dy) * 180 / Math.PI) - this.agents[i][2];
            }

            // perform the turn
            // The degree to which each of the three laws is applied is configurable.
            // The three default ratios that I provide work well.
            turnAmount = (cohesion * this.constCohesion) + (alignment * this.constAlignment) + (separation * this.constSeparation);

            this.agents[i][2] += turnAmount;

            ///////////////////////////////////////////////////////////////
            // End implementation of three very basic laws of flocking.
            ///////////////////////////////////////////////////////////////
        }
    }
};

ENCOG.Swarm.create = function (agents) {
    'use strict';
    var result = new ENCOG.Swarm();
    result.agents = agents;
    return result;
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Anneal: The following code implements Simulated Annealing                                                 //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Simulated Annealing algorithm.
 *
 * @class Anneal
 * @constructor
 **/
ENCOG.Anneal = function () {
    'use strict';
};


ENCOG.Anneal.prototype = {
    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : 'Anneal',

    /**
     * The current solution.
     * @property solution
     * @type Array
     */
    solution : null,

    /**
     * A function that is used to score the potential solutions. The score function
     * must accept an array of doubles and return a score.
     *
     * @property scoreSolution
     * @type Function
     * @default null
     **/
    scoreSolution : null,

    /**
     * Randomize a solution according to the specified temperature.  The higher the
     * temperature the more randomness.
     *
     * @property scoreSolution
     * @type Function
     * @default null
     **/
    randomize : null,

    /**
     * The starting temperature for each iteration.
     *
     * @property constStartTemp
     * @type number
     * @default 10.0
     **/
    constStartTemp : 10.0,

    /**
     * The stopping temperature for each iteration.
     *
     * @property constStopTemp
     * @type number
     * @default 2.0
     **/
    constStopTemp : 2.0,

    /**
     * The number of cycles to go from the starting temperature to the stopping.
     *
     * @property constCycles
     * @type number
     * @default 10.0
     **/
    constCycles : 10,


    iteration : function () {
        'use strict';

        var bestArray, temperature, bestScore, curScore, i;

        bestArray = this.solution.slice();

        temperature = this.constStartTemp;
        bestScore = this.scoreSolution(this.solution);

        for (i = 0; i < this.constCycles; i += 1) {
            this.randomize(this.solution, temperature);
            curScore = this.scoreSolution(this.solution);

            if (curScore < bestScore) {
                bestArray = this.solution.slice();
                bestScore = curScore;
            }

            this.solution = bestArray.slice();

            temperature *= Math.exp(Math.log(this.constStopTemp
                / this.constStartTemp)
                / (this.constCycles - 1));
        }
    }
};

ENCOG.Anneal.create = function (solution) {
    'use strict';
    var result = new ENCOG.Anneal();
    result.solution = solution;
    return result;
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Genetic Algorithm: The following code implements a Genetic Algorithm                                       //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Genetic learning algorithm.
 *
 * @class Genetic
 * @constructor
 **/
ENCOG.Genetic = function () {
    'use strict';
};


ENCOG.Genetic.prototype = {
    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : 'Genetic',

    /**
     * The current population.
     * @property solution
     * @type Array
     */
    population : null,

    /**
     * A function that is used to score the potential solutions. The score function
     * must accept an array of doubles and return a score.
     *
     * @property scoreSolution
     * @type Function
     * @default null
     **/
    scoreSolution : null,

    /**
     * A function that will mutate the specified solution.  The mutation method must
     * access an array of doubles that will be mutated.
     *
     * @property mutate
     * @type Function
     * @default null
     **/
    mutate : null,

    /**
     * Perform a crossover and return two offspring.  crossover should be called as follows:
     *
     * crossover(mother,father,child1,child2);
     *
     * @property crossover
     * @type Function
     * @default null
     **/
    crossover : null,

    /**
     * The percent of offspring that will be mutated.
     * @property constMutationPercent
     * @type number
     * @default 0.1
     **/
    constMutationPercent : 0.1,

    /**
     * The percent of the population that will mate.
     * @property constMatePercent
     * @type number
     * @default 0.24
     **/
    constMatePercent : 0.24,

    /**
     * The percent of the population that can be chosen for mating.
     * @property constMatingPopulationPercent
     * @type number
     * @default 0.5
     **/
    constMatingPopulationPercent : 0.5,

    iteration : function () {
        'use strict';

        var countToMate, offspringCount, offspringIndex, matingPopulationSize, motherID, fatherID;

        countToMate = Math.floor(this.population.length * this.constMatePercent);
        offspringCount = countToMate * 2;
        offspringIndex = this.population.length - offspringCount;
        matingPopulationSize = Math.floor(this.population.length * this.constMatingPopulationPercent);

        // mate and form the next generation

        for (motherID = 0; motherID < countToMate; motherID++) {
            fatherID = Math.floor(Math.random() * matingPopulationSize);
            this.crossover(
                this.population[motherID].data,
                this.population[fatherID].data,
                this.population[offspringIndex].data,
                this.population[offspringIndex + 1].data);

            // mutate, if needed
            if (Math.random() > this.constMutationPercent) {
                this.mutate(this.population[offspringIndex].data);
            }

            if (Math.random() > this.constMutationPercent) {
                this.mutate(this.population[offspringIndex].data);
            }

            // score the two new offspring
            this.population[offspringIndex].score = this.scoreSolution(this.population[offspringIndex].data);
            this.population[offspringIndex + 1].score = this.scoreSolution(this.population[offspringIndex + 1].data);

            // move to the next one
            offspringIndex += 2;
        }

        this.sortPopulation();
    },
    createPopulation : function (size, generate) {
        'use strict';
        var i, d, l;

        this.population = [];
        for (i = 0; i < size; i++) {
            d = generate();
            l = this.scoreSolution(d);
            this.population[i] = {
                'data' : d,
                'score' : l
            };
        }

        this.sortPopulation();
    },
    getSolution : function () {
        return this.population[0].data;
    },
    sortPopulation : function () {
        this.population.sort(function (a, b) {
            return a.score - b.score
        });
    }
};


ENCOG.Genetic.create = function () {
    return new ENCOG.Genetic();
};


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SOM: The following code implements a Self Organizing Map                                                  //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * A self organizing map (SOM).
 *
 * @class SOM
 * @constructor
 **/
ENCOG.SOM = function () {
    'use strict';
};

ENCOG.SOM.prototype = {

    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : "SOM",

    /**
     * Holds the weights for the SOM.
     *
     * @property weights
     * @type Array
     * @default null
     **/
    weights : null,

    /**
     * The input neuron count for the SOM
     *
     * @property inputCount
     * @type int
     * @default 0
     **/
    inputCount : 0,

    /**
     * The output neuron count for the SOM
     *
     * @property outputCount
     * @type int
     * @default 0
     **/
    outputCount : 0,

    /**
     * Determine which output neuron the input matches with best.
     * @method classify
     * @param inputData The input data.
     */
    classify : function (inputData) {
        'use strict';

        var minDist, result, i, dist;

        if (inputData.length > this.inputCount) {
            throw new Error(
                "Can't classify SOM with input size of " + this.inputCount
                    + " with input data of count " + inputData.length);
        }

        minDist = Number.POSITIVE_INFINITY;
        result = -1;

        for (i = 0; i < this.outputCount; i += 1) {
            dist = ENCOG.MathUtil.euclideanDistance(inputData, this.weights[i], 0, this.inputCount);
            if (dist < minDist) {
                minDist = dist;
                result = i;
            }
        }

        return result;
    }
};

/**
 * Create a SOM network.
 * @method create
 * @return {ENCOG.ActivationElliottSymmetric} The newly created activation function.
 */
ENCOG.SOM.create = function (theInputCount, theOutputCount) {
    'use strict';
    var result = new ENCOG.SOM();
    result.inputCount = theInputCount;
    result.outputCount = theOutputCount;
    result.weights = ENCOG.ArrayUtil.allocateBoolean2D(theOutputCount, theInputCount);
    return result;
};

// train SOM

ENCOG.TrainSOM = function () {
    'use strict';
};

ENCOG.TrainSOM.prototype = {

    /**
     * The name of this object.
     * @property NAME
     * @type String
     * @final
     */
    NAME : "SOM",

    weights : null,
    som : null,
    learningRate : 0.5,
    correctionMatrix : null,
    trainingInput : null,
    worstDistance : 0,


    /**
     * Perform a training iteration.
     * @method iteration
     */
    iteration : function () {
        'use strict';

        var i, input, bmu;

        // Reset the correction matrix for this synapse and iteration.
        ENCOG.ArrayUtil.fillArray2D(this.correctionMatrix, 0);

        // Determine the BMU for each training element.
        for (i = 0; i < this.trainingInput.length; i++) {
            input = this.trainingInput[i];

            bmu = this.calculateBMU(input);

            this.train(bmu, input);

            this.applyCorrection();
        }

        // update the error
        //setError(this.bmuUtil.getWorstDistance() / 100.0);

    },
    reset : function () {
        ENCOG.MathUtil.randomizeArray2D(this.weights, -1, 1);
    },
    calculateBMU : function (input) {
        var result, lowestDistance, i, distance;

        result = 0;

        if (input.length > this.som.inputCount) {
            throw new Error(
                "Can't train SOM with input size of " + this.inputCount
                    + " with input data of count " + input.length);
        }

        // Track the lowest distance so far.
        lowestDistance = Number.POSITIVE_INFINITY;

        for (i = 0; i < this.som.outputCount; i++) {
            distance = ENCOG.MathUtil.euclideanDistance(this.som.weights[i], input, 0, this.som.weights[i].length);

            // Track the lowest distance, this is the BMU.
            if (distance < lowestDistance) {
                lowestDistance = distance;
                result = i;
            }
        }

        // Track the worst distance, this is the error for the entire network.
        if (lowestDistance > this.worstDistance) {
            this.worstDistance = lowestDistance;
        }

        return result;
    },
    train : function (bmu, input) {

    },
    applyCorrection : function () {

    }
};

/**
 * Create trainer for a SOM.
 * @method create
 * @return {ENCOG.ActivationElliottSymmetric} The newly created activation function.
 */
ENCOG.TrainSOM.create = function (theSom, theLearningRate) {
    'use strict';
    var result = new ENCOG.TrainSOM();
    result.som = theSom;
    result.learningRate = theLearningRate;
    result.correctionMatrix = ENCOG.ArrayUtil.allocateBoolean2D(this.som.outputCount, this.som.inputCount);
    return result;
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Read CSV: The following is used to read CSV files                                                         //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Read data that is in CSV format.
 *
 * @class ReadCSV
 * @constructor
 **/
ENCOG.ReadCSV = function () {
    'use strict';
};

ENCOG.ReadCSV.prototype = {
    /**
     * Holds the regular expression for parsing.
     *
     * @property regStr
     * @type String
     * @default null
     **/
    regStr : null,

    /**
     * The input data parsed from the CSV.
     *
     * @property inputData
     * @type Array
     * @default null
     **/
    inputData : null,

    /**
     * Holds the ideal data parsed from the CSV.
     *
     * @property idealData
     * @type Array
     * @default null
     **/
    idealData : null,

    /**
     * Holds the number of columns that make up the input data.
     *
     * @property inputCount
     * @type int
     * @default null
     **/
    inputCount : 0,

    /**
     * Holds the number of columns that make up the ideal data.
     *
     * @property idealCount
     * @type int
     * @default null
     **/
    idealCount : 0,

    /**
     * Holds the regular expression for parsing
     * @property delimiter
     * @type String
     * @default ','
     **/
    delimiter : ',',

    readCSV : function (csv, theInputCount, theIdealCount) {
        var currentIndex, regex, matches, value, d;

        this.inputCount = theInputCount;
        this.idealCount = theIdealCount;

        regex = new RegExp(this.regStr, "gi");

        // allocate input and ideal arrays
        this.inputData = [
            []
        ];
        this.idealData = [
            []
        ];

        currentIndex = 0;

        while (matches = regex.exec(csv)) {
            // obtain delimiter
            d = matches[ 1 ];

            // new row
            if (d.length && (d != this.delimiter)) {
                this.inputData.push([]);
                this.idealData.push([]);
                currentIndex = 0;
            }

            // do we need to remove quotes from value?
            if (matches[ 2 ]) {
                value = matches[ 2 ].replace(
                    new RegExp("\"\"", "g"),
                    "\""
                );

            } else {
                value = matches[ 3 ];
            }

            // add value to either input or ideal
            if (currentIndex < this.inputCount) {
                this.inputData[ this.inputData.length - 1 ].push(value);
            } else {
                this.idealData[ this.idealData.length - 1 ].push(value);
            }
            currentIndex += 1;
        }
    }
};

ENCOG.ReadCSV.create = function (theDelimiter) {
    'use strict';
    var result = new ENCOG.ReadCSV();

    result.delimiter = (theDelimiter || ",");

    result.regStr =
        // Delimiters
        "(\\" + result.delimiter + "|\\r?\\n|\\r|^)" +
            // Quoted fields
            "(?:\"([^\"]*(?:\"\"[^\"]*)*)\"|" +
            // Standard fields
            "([^\"\\" + result.delimiter + "\\r\\n]*))";
    return result;
};

ENCOG.ReadCSV.fromCommaListInt = function (str) {
    'use strict';
    var result, parts, i;

    result = [];
    parts = str.split(',');

    for (i = 0; i < parts.length; i+=1) {
        result.push(parseInt(parts[i],10));
    }


    return result;
};

ENCOG.ReadCSV.fromCommaListFloat = function (str) {
    'use strict';
    var result, parts, i;

    result = [];
    parts = str.split(',');

    for (i = 0; i < parts.length; i+=1) {
        result.push(parseFloat(parts[i]));
    }

    return result;
};

ENCOG.ReadCSV.toCommaList = function (arr) {
    'use strict';
    var result, i;

    result = '';

    for (i = 0; i < arr.length; i+=1) {
        if (i > 0) {
            result += ',';
        }
        result += arr[i];
    }

    return result;
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// EGFILE: The following code is used for the processing of EG files                                         //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**
 * Read data stored in the Encog EG format.
 *
 * @class EGFILE
 * @constructor
 **/
ENCOG.EGFILE = function () {
    'use strict';
};


ENCOG.EGFILE.save = function (obj) {
    'use strict';
    var result = "", now, i, af;

    now = (new Date()).getTime();

    result += 'encog,BasicNetwork,' + ENCOG.PLATFORM + ',3.1.0,1,' + now + ENCOG.NEWLINE;
    result += '[BASIC]' + ENCOG.NEWLINE;
    result += '[BASIC:PARAMS]' + ENCOG.NEWLINE;
    result += '[BASIC:NETWORK]' + ENCOG.NEWLINE;
    result += 'beginTraining=' + obj.beginTraining + ENCOG.NEWLINE;
    result += 'connectionLimit=' + obj.connectionLimit + ENCOG.NEWLINE;
    result += 'contextTargetOffset=' + ENCOG.ReadCSV.toCommaList(obj.contextTargetOffset) + ENCOG.NEWLINE;
    result += 'contextTargetSize=' + ENCOG.ReadCSV.toCommaList(obj.contextTargetSize) + ENCOG.NEWLINE;
    result += 'endTraining=' + obj.endTraining + ENCOG.NEWLINE;
    result += 'hasContext=' + (obj.hasContext ? 't' : 'f') + ENCOG.NEWLINE;
    result += 'inputCount=' + obj.inputCount + ENCOG.NEWLINE;
    result += 'layerCounts=' + ENCOG.ReadCSV.toCommaList(obj.layerCounts) + ENCOG.NEWLINE;
    result += 'layerFeedCounts=' + ENCOG.ReadCSV.toCommaList(obj.layerFeedCounts) + ENCOG.NEWLINE;
    result += 'layerContextCount=' + ENCOG.ReadCSV.toCommaList(obj.layerContextCount) + ENCOG.NEWLINE;
    result += 'layerIndex=' + ENCOG.ReadCSV.toCommaList(obj.layerIndex) + ENCOG.NEWLINE;
    result += 'output=' + ENCOG.ReadCSV.toCommaList(obj.layerOutput) + ENCOG.NEWLINE;
    result += 'outputCount=' + obj.outputCount + ENCOG.NEWLINE;
    result += 'weightIndex=' + ENCOG.ReadCSV.toCommaList(obj.weightIndex) + ENCOG.NEWLINE;
    result += 'weights=' + ENCOG.ReadCSV.toCommaList(obj.weights) + ENCOG.NEWLINE;
    result += 'biasActivation=' + ENCOG.ReadCSV.toCommaList(obj.biasActivation) + ENCOG.NEWLINE;
    result += '[BASIC:ACTIVATION]' + ENCOG.NEWLINE;
    for (i = 0; i < obj.activationFunctions.length; i+=1) {
        af = obj.activationFunctions[i];
        result += '\"';
        result += af.NAME;
        result += '\"' + ENCOG.NEWLINE;
    }
    return result;
};

ENCOG.EGFILE.load = function (str) {
    'use strict';
    var lines, currentLine, parts;

    currentLine = 0;

    lines = str.match(/^.*([\n\r]+|$)/gm);

    while (lines[currentLine].trim().length === 0) {
        currentLine+=1;
    }

    parts = lines[currentLine].trim().split(',');

    if (parts[0] !== 'encog') {
        throw new Error("Not a valid Encog EG file.");
    }

    if (parts[1] === 'BasicNetwork') {
        return ENCOG.EGFILE.loadBasicNetwork(str);
    } else {
        throw new Error("Encog Javascript does not support: " + parts[1]);
    }
};

ENCOG.EGFILE._loadNetwork = function (lines, currentLine, result) {
    var idx, line, name, value;

    while (currentLine < lines.length) {
        line = lines[currentLine].trim();

        if (line[0] == '[') {
            break;
        }

        currentLine++;
        idx = line.indexOf('=');

        if (idx == -1) {
            throw new Error("Invalid line in BasicNetwork file: " + line);
        }

        name = line.substr(0, idx).trim().toLowerCase();
        value = line.substr(idx + 1).trim();

        if (name == 'begintraining') {
            result.beginTraining = parseInt(value);
        }
        else if (name == 'connectionlimit') {
            result.connectionLimit = parseFloat(value);
        }
        else if (name == 'contexttargetoffset') {
            result.contextTargetOffset = ENCOG.ReadCSV.fromCommaListInt(value);
        }
        else if (name == 'contexttargetsize') {
            result.contextTargetSize = ENCOG.ReadCSV.fromCommaListInt(value);
        }
        else if (name == 'endtraining') {
            result.endTraining = parseInt(value);
        }
        else if (name == 'hascontext') {
            result.hasContext = (value.toLowerCase() == 'f');
        }
        else if (name == 'inputcount') {
            result.inputCount = parseInt(value);
        }
        else if (name == 'layercounts') {
            result.layerCounts = ENCOG.ReadCSV.fromCommaListInt(value);
        }
        else if (name == 'layerfeedcounts') {
            result.layerFeedCounts = ENCOG.ReadCSV.fromCommaListInt(value);
        }
        else if (name == 'layercontextcount') {
            result.layerContextCount = ENCOG.ReadCSV.fromCommaListInt(value);
        }
        else if (name == 'layerindex') {
            result.layerIndex = ENCOG.ReadCSV.fromCommaListInt(value);
        }
        else if (name == 'output') {
            result.layerOutput = ENCOG.ReadCSV.fromCommaListFloat(value);
        }
        else if (name == 'outputcount') {
            result.outputCount = parseInt(value);
        }
        else if (name == 'weightindex') {
            result.weightIndex = ENCOG.ReadCSV.fromCommaListInt(value);
        }
        else if (name == 'weights') {
            result.weights = ENCOG.ReadCSV.fromCommaListFloat(value);
        }
        else if (name == 'biasactivation') {
            result.biasActivation = ENCOG.ReadCSV.fromCommaListFloat(value);
        }
    }

    result.layerSums = [];
    ENCOG.ArrayUtil.fillArray(result.layerSums, 0, result.layerSums, 0);

    return currentLine;
};

ENCOG.EGFILE._loadActivation = function (lines, currentLine, result) {
    var i, line;

    result.activationFunctions = [];

    i = 0;
    while (currentLine < lines.length) {

        line = lines[currentLine++].trim();

        if (line[0] == '[') {
            break;
        }

        line = ENCOG.Util.stripQuotes(line);

        if (line == 'ActivationLinear') {
            result.activationFunctions[i] = ENCOG.ActivationLinear.create();
        } else if (line == 'ActivationSigmoid') {
            result.activationFunctions[i] = ENCOG.ActivationSigmoid.create();
        } else if (line == 'ActivationTANH') {
            result.activationFunctions[i] = ENCOG.ActivationTANH.create();
        } else if (line == 'ActivationElliott') {
            result.activationFunctions[i] = ENCOG.ActivationElliott.create();
        } else if (line == 'ActivationElliottSymmetric') {
            result.activationFunctions[i] = ENCOG.ActivationElliottSymmetric.create();
        }

        i += 1;
    }

    return currentLine;
};

ENCOG.EGFILE.loadBasicNetwork = function (str) {
    var lines, currentLine, line, parts, result;

    currentLine = 0;

    lines = str.match(/^.*([\n\r]+|$)/gm);

    while (lines[currentLine].trim().length == 0) {
        currentLine++;
    }

    parts = lines[currentLine++].trim().split(',');

    if (parts[0] != 'encog') {
        throw new Error("Not a valid Encog EG file.");
    }

    if (parts[1] != 'BasicNetwork') {
        throw new Error("Not a BasicNetwork EG file.");
    }

    result = new ENCOG.BasicNetwork();

    while (currentLine < lines.length) {
        line = lines[currentLine++].trim();

        if (line == '[BASIC:NETWORK]') {
            currentLine = this._loadNetwork(lines, currentLine, result);
        } else if (line == '[BASIC:ACTIVATION]') {
            currentLine = this._loadActivation(lines, currentLine, result);
        }
    }

    return result;
};