package cc.mallet.types;

import java.io.*;

public class DenseVector extends DenseMatrix implements Vector, Serializable
{

	public DenseVector (double[] values, boolean copy)
	{
		if (copy) {
			this.values = new double[values.length];
			System.arraycopy (values, 0, this.values, 0, values.length);
		} else
			this.values = values;
	}

	public DenseVector (double[] values) { this (values, true); }

	public DenseVector (int size) { this (new double[size], false); }
	
	public int getNumDimensions () { return 1; }
	public int getDimensions (int[] sizes) { sizes[0] = values.length; return 1; }
	
	public double value (int[] indices) {
		assert (indices.length == 1);
		return values[indices[0]];
	}

	public double value (int index) {
		return values[index];
	}
	
	public void setValue (int[] indices, double value) {
		assert (indices.length == 1);
		values[indices[0]] = value;
	}

	public void setValue (int index, double value) {
		values[index] = value;
	}

	public void columnPlusEquals (int columnIndex, double value)
	{
		values[columnIndex] += value;
	}
	
	public ConstantMatrix cloneMatrix () {
		return new DenseVector (values, true);
	}

	public int singleIndex (int[] indices) { assert (indices.length == 1); return indices[0]; }
	public void singleToIndices (int i, int[] indices) { indices[0] = i; }

    
	// Copy the contents of Matrix m into this Vector starting at index
	// i in this Vector, laying out Matrix m in "getSingle()" order.
	// Return the next index that could be set in this DenseVector after
	// the indices filled by Matrix m.
	public final int arrayCopyFrom (int i, Matrix m) {
		if (m instanceof DenseVector) {
			System.arraycopy (((DenseVector)m).values, 0, values, i, ((DenseVector)m).values.length);
			return i + ((DenseVector)m).values.length;
		} else if (m instanceof Matrix2) {
			((Matrix2)m).arrayCopyInto (values, i);
			return i + m.singleSize();
		} else {
			for (int j = 0; j < m.singleSize(); j++)
				values[i++] = m.singleValue (j);
			return i;
		}
	}
    
    /** Copy values from an array into this vector. The array should have the
     * same size as the vector */
    public final void arrayCopyFrom( double[] a ) 
    {
	arrayCopyFrom(a,0);
    }

    /** Copy values from an array starting at a particular index into this 
     * vector. The array must have at least as many values beyond the starting
     * index as there are in the vector.
     *
     * @return Next uncopied index in the array.
     */
    public final int arrayCopyFrom( double [] a , int startingArrayIndex )
    {
	System.arraycopy( a, startingArrayIndex, values, 0, values.length );

	return startingArrayIndex + values.length;
    }
	
	// Copy the contents of this Vector into Matrix m starting at index
	// i in this Vector, setting values in Matrix m in "setSingle()" order.
	// Return the next index that could be gotten after the indices copied 
	// into Matrix m.
	public final int arrayCopyTo (int i, Matrix m) {
		if (m instanceof DenseVector) {
			System.arraycopy (values, i, ((DenseVector)m).values, 0, ((DenseVector)m).values.length);
			return i + ((DenseVector)m).values.length;
		} else if (m instanceof Matrix2) {
			((Matrix2)m).arrayCopyFrom (values, i);
			return i + m.singleSize();
		} else {
			for (int j = 0; j < m.singleSize(); j++)
				m.setSingleValue (j, values[i++]);
			return i;
		}
	}

	public final int arrayCopyTo (int i, double[] a) {
		System.arraycopy (values, i, a, 0, a.length);
		return i + a.length;
	}

    
    /** Copy the contents of this vector into an array starting at a particular
     * index. 
     *
     * @return Next available index in the array 
     */
     public final int arrayCopyInto (double[] array, int startingArrayIndex)
	{
		System.arraycopy (values, 0, array, startingArrayIndex, values.length);
		return startingArrayIndex + values.length;
	}
	
	public void addTo (double[] v)
	{
		assert (v.length == values.length);
		for (int i = 0; i < values.length; i++)
			v[i] += values[i];
	}

	public void addTo (double[] v, double factor)
	{
		assert (v.length == values.length);
		for (int i = 0; i < values.length; i++)
			v[i] += values[i] * factor;
	}
	

	public static double sum (double[] v)
	{
		double sum = 0;
		for (int i = 0; i < v.length; i++)
			sum += v[i];
		return sum;
	}
	
	public static double normalize (double[] v)
	{
		double sum = 0;
		for (int i = 0; i < v.length; i++)
			sum += v[i];
		assert (sum != 0);
		for (int i = 0; i < v.length; i++)
			v[i] /= sum;
		return sum;
	}

	public static double max (double[] v)
	{
		double max = Double.NEGATIVE_INFINITY;
		for (int i = 0; i < v.length; i++)
			if (v[i] > max)
				max = v[i];
		return max;
	}

	public static void print (double[] v)
	{
		System.out.print ("[");
		for (int i = 0; i < v.length; i++)
			System.out.print (" " + v[i]);
		System.out.println ("]");
	}
	
	public static void print (int[] v)
	{
		System.out.print ("[");
		for (int i = 0; i < v.length; i++)
			System.out.print (" " + v[i]);
		System.out.println ("]");
	}

	// Serialization
	
	private static final long serialVersionUID = 1;
	private static final int CURRENT_SERIAL_VERSION = 0;
	
	private void writeObject (ObjectOutputStream out) throws IOException {
		int i, size;
		out.writeInt (CURRENT_SERIAL_VERSION);
	}
	
	private void readObject (ObjectInputStream in) throws IOException, ClassNotFoundException {
		int version = in.readInt ();
	}

}
