source: trunk/sources/LibSVM/RangeTransform.cs @ 2285

/*
 * SVM.NET Library
 * Copyright (C) 2008 Matthew Johnson
 * 
 * This program 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 3 of the License, or
 * (at your option) any later version.
 * 
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */


using System;
using System.IO;

namespace SVM
{
    /// <remarks>
    /// Class which encapsulates a range transformation.
    /// </remarks>
    public class RangeTransform : IRangeTransform
    {
        private double[] _inputStart;
        private double[] _inputScale;
        private double _outputStart;
        private double _outputScale;
        private int _length;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="minValues">The minimum values in each dimension.</param>
        /// <param name="maxValues">The maximum values in each dimension.</param>
        /// <param name="lowerBound">The desired lower bound for all dimensions.</param>
        /// <param name="upperBound">The desired upper bound for all dimensions.</param>
        public RangeTransform(double[] minValues, double[] maxValues, double lowerBound, double upperBound)
        {
            _length = minValues.Length;
            if(maxValues.Length != _length)
                throw new Exception("Number of max and min values must be equal.");
            _inputStart = new double[_length];
            _inputScale = new double[_length];
            for (int i = 0; i < _length; i++)
            {
                _inputStart[i] = minValues[i];
                _inputScale[i] = maxValues[i] - minValues[i];
            }
            _outputStart = lowerBound;
            _outputScale = upperBound - lowerBound;
        }
        private RangeTransform(double[] inputStart, double[] inputScale, double outputStart, double outputScale, int length)
        {
            _inputStart = inputStart;
            _inputScale = inputScale;
            _outputStart = outputStart;
            _outputScale = outputScale;
            _length = length;
        }
        /// <summary>
        /// Transforms the input array based upon the values provided.
        /// </summary>
        /// <param name="input">The input array</param>
        /// <returns>A scaled array</returns>
        public Node[] Transform(Node[] input)
        {
            Node[] output = new Node[input.Length];
            for (int i = 0; i < _length; i++)
            {
                int index = input[i].Index;
                double value = input[i].Value;
                output[i] = new Node(index, Transform(value, index));
            }
            return output;
        }

        /// <summary>
        /// Transforms this an input value using the scaling transform for the provided dimension.
        /// </summary>
        /// <param name="input">The input value to transform</param>
        /// <param name="index">The dimension whose scaling transform should be used</param>
        /// <returns>The scaled value</returns>
        public double Transform(double input, int index)
        {
            index--;
            double tmp = input - _inputStart[index];
            if (_inputScale[index] == 0)
                return 0;
            tmp /= _inputScale[index];
            tmp *= _outputScale;
            return tmp + _outputStart;
        }
        /// <summary>
        /// Writes this Range transform to a stream.
        /// </summary>
        /// <param name="stream">The stream to write to</param>
        /// <param name="r">The range to write</param>
        public static void Write(Stream stream, RangeTransform r)
        {
            StreamWriter output = new StreamWriter(stream);
            output.WriteLine(r._length);
            output.Write(r._inputStart[0]);
            for(int i=1; i<r._inputStart.Length; i++)
                output.Write(" " + r._inputStart[i]);
            output.WriteLine();
            output.Write(r._inputScale[0]);
            for (int i = 1; i < r._inputScale.Length; i++)
                output.Write(" " + r._inputScale[i]);
            output.WriteLine();
            output.WriteLine("{0} {1}", r._outputStart, r._outputScale);
            output.Flush();
        }

        /// <summary>
        /// Writes this Range transform to a file.    This will overwrite any previous data in the file.
        /// </summary>
        /// <param name="outputFile">The file to write to</param>
        /// <param name="r">The Range to write</param>
        public static void Write(string outputFile, RangeTransform r)
        {
            FileStream s = File.Open(outputFile, FileMode.Create);
            try
            {
                Write(s, r);
            }
            finally
            {
                s.Close();
            }
        }

        /// <summary>
        /// Reads a Range transform from a file.
        /// </summary>
        /// <param name="inputFile">The file to read from</param>
        /// <returns>The Range transform</returns>
        public static RangeTransform Read(string inputFile)
        {
            FileStream s = File.OpenRead(inputFile);
            try
            {
                return Read(s);
            }
            finally
            {
                s.Close();
            }
        }

        /// <summary>
        /// Reads a Range transform from a stream.
        /// </summary>
        /// <param name="stream">The stream to read from</param>
        /// <returns>The Range transform</returns>
        public static RangeTransform Read(Stream stream)
        {
            StreamReader input = new StreamReader(stream);
            int length = int.Parse(input.ReadLine());
            double[] inputStart = new double[length];
            double[] inputScale = new double[length];
            string[] parts = input.ReadLine().Split();
            for (int i = 0; i < length; i++)
                inputStart[i] = double.Parse(parts[i]);
            parts = input.ReadLine().Split();
            for (int i = 0; i < length; i++)
                inputScale[i] = double.Parse(parts[i]);
            parts = input.ReadLine().Split();
            double outputStart = double.Parse(parts[0]);
            double outputScale = double.Parse(parts[1]);
            return new RangeTransform(inputStart, inputScale, outputStart, outputScale, length);
        }
    }
}