code: 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 ();
  	}
  
  }
  