/* * $RCSfile: Linear.java,v $ * $Revision: 1.8 $ * $Date: 2004/10/24 03:05:29 $ * * NeuralNetworkToolkit * Copyright (C) 2004 Universidade de Brasília * * This file is part of NeuralNetworkToolkit. * * NeuralNetworkToolkit is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * NeuralNetworkToolkit is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with NeuralNetworkToolkit; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - 02111-1307 - USA. */package neuralnetworktoolkit.normalization;/** * Linear normalization (or "Normalization into an Interval").<br> * <br> * Implementation according the description avaiable in * <a href="http://www.ivorix.com/en/products/tech/norm/"> * http://www.ivorix.com/en/products/tech/norm/</a>. *  * @version $Revision: 1.8 $ - $Date: 2004/10/24 03:05:29 $ *  * @author <a href="mailto:rodbra@pop.com.br">Rodrigo C. M. Coimbra</a> * @author <a href="mailto:hugoiver@yahoo.com.br">Hugo Iver V. Gon?alves</a> */public class Linear extends Normalization {	private double[] upperLimit;	private double[] lowerLimit;	private double[] upperValue;	private double[] lowerValue;	/* 	 * @see neuralnetworktoolkit.normalization.INormalization#normalize(double[][])	 */	public double[][] normalize(double[][] originalData) {		double[][] normalizedData;				if ((upperLimit == null) || (lowerLimit == null)				|| (upperValue == null) || (lowerValue == null)) {			setupParameters(originalData);					}		normalizedData = transform(originalData);				return normalizedData;			} //normalize()		/* 	 * @see neuralnetworktoolkit.normalization.INormalization#unnormalize(double[][])	 */	public double[][] unnormalize(double[][] normalizedData) {		double[][] originalData;				originalData = new double[normalizedData.length][normalizedData[0].length];						for (int j = 0; j < normalizedData[0].length; j++) {			for (int i = 0; i < normalizedData.length; i++) {												originalData[i][j] = 						((normalizedData[i][j]-lowerLimit[j])						* (upperValue[j] - lowerValue[j]))						/ (upperLimit[j] - lowerLimit[j])						+ lowerValue[j];															}		}		return originalData;			} //unnormalize()	/* 	 * @see neuralnetworktoolkit.normalization.INormalization#setupParameters(double[][])	 */	public void setupParameters(double[][] originalData) {		upperLowerLimitsSetup(originalData);		upperLowerValuesSetup(originalData);	} //train()	/* 	 * @see neuralnetworktoolkit.normalization.Normalization#transform(double[][])	 */	protected double[][] transform(double[][] originalData) {		double[][] normalizedData;				normalizedData = new double[originalData.length][originalData[0].length];				for (int j = 0; j < originalData[0].length; j++) {			for (int i = 0; i < originalData.length; i++) {				normalizedData[i][j] =					(originalData[i][j] - lowerValue[j])						* (upperLimit[j] - lowerLimit[j])						/ (upperValue[j] - lowerValue[j])						+ lowerLimit[j];			}		}		return normalizedData;			} //transform()		/**	 * 	 * @param originalData	 */	private void upperLowerLimitsSetup(double[][] originalData) {		lowerLimit = new double[originalData[0].length];		upperLimit = new double[originalData[0].length];				for(int i = 0; i < originalData[0].length; i++) {			lowerLimit[i] = -1;			upperLimit[i] = 1;					}			} //upperLowerLimitsSetup()		/**	 * 	 * @param originalData	 */	private void upperLowerValuesSetup(double[][] originalData) {		lowerValue = new double[originalData[0].length];		upperValue = new double[originalData[0].length];				for(int i = 0; i < lowerValue.length; i++) {			lowerValue[i] = Double.MAX_VALUE;			upperValue[i] = Double.MIN_VALUE;					}				for (int j = 0; j < originalData[0].length; j++) {			for (int i = 0; i < originalData.length; i++) {				if (originalData[i][j] > upperValue[j]) {					upperValue[j] = originalData[i][j];				}				if (originalData[i][j] < lowerValue[j]) {					lowerValue[j] = originalData[i][j];				}			}		}	} //upperLowerValuesSetup()	/**	 * @return Returns the lowerLimit.	 */	public double[] getLowerLimit() {		return lowerLimit;			} //getLowerLimit()		/**	 * @return Returns the lowerValue.	 */	public double[] getLowerValue() {		return lowerValue;			} //getLowerValue()		/**	 * @return Returns the upperLimit.	 */	public double[] getUpperLimit() {		return upperLimit;			} //getUpperLimit()		/**	 * @return Returns the upperValue.	 */	public double[] getUpperValue() {		return upperValue;			} //getUpperValue()	} //Linear