Wojciech Jaworski / ENIAM

package is2.data;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

public final class FV extends IFV {

	private FV subfv1;
	private FV subfv2;
	private boolean negateSecondSubFV = false;

	private int size;

	// content of the nodes NxC
	private int m_index[];

	// type of the nodes NxT

	public FV() {
		this(10);
	}

	public FV(int initialCapacity) {
		m_index = new int[initialCapacity];
	}

	public FV(FV fv1, FV fv2) {
		subfv1 = fv1;
		subfv2 = fv2;
	}

	public FV(FV fv1, FV fv2, boolean negSecond) {
		this(0);
		subfv1 = fv1;
		subfv2 = fv2;
		negateSecondSubFV = negSecond;
	}

	/**
	 * Read a feature vector
	 * 
	 * @param index
	 * @param value
	 */
	public FV(DataInputStream dos, int capacity) throws IOException {
		this(capacity);
		size = m_index.length;

		for (int i = 0; i < size; i++)
			m_index[i] = dos.readInt();
	}

	/**
	 * Read a feature vector
	 * 
	 * @param index
	 * @param value
	 */
	public FV(DataInputStream dos) throws IOException {
		this(dos.readInt());
		size = m_index.length;

		for (int i = 0; i < size; i++)
			m_index[i] = dos.readInt();

	}

	/**
	 * Increases the capacity of this <tt>Graph</tt> instance, if necessary, to
	 * ensure that it can hold at least the number of nodes specified by the
	 * minimum capacity argument.
	 *
	 * @param minCapacity
	 *            the desired minimum capacity.
	 */
	private void ensureCapacity(int minCapacity) {

		if (minCapacity > m_index.length) {

			int oldIndex[] = m_index;

			int newCapacity = (m_index.length * 3) / 2 + 1;

			if (newCapacity < minCapacity)
				newCapacity = minCapacity;

			m_index = new int[newCapacity];
			System.arraycopy(oldIndex, 0, m_index, 0, oldIndex.length);

		}
	}

	final public int size() {
		return size;
	}

	final public boolean isEmpty() {
		return size == 0;
	}

	@Override
	final public void clear() {
		size = 0;
	}

	final public int createFeature(int i, double v) {

		ensureCapacity(size + 1);
		m_index[size] = i;
		size++;
		return size - 1;
	}

	final public int createFeature(int i) {

		ensureCapacity(size + 1);
		m_index[size] = i;
		size++;
		return size - 1;
	}

	final public int getIndex(int i) {
		return m_index[i];
	}

	public void setIndex(int p, int i) {
		m_index[p] = i;
	}

	/**
	 * Trims the capacity of this <tt>Graph</tt> instance to true size. An
	 * application can use this operation to minimize the storage of an
	 * <tt>Graph</tt> instance.
	 */
	public void trimToSize() {

		if (size < m_index.length) {

			int oldIndex[] = m_index;

			m_index = new int[size];
			System.arraycopy(oldIndex, 0, m_index, 0, size);

		}

	}

	@Override
	final public void add(int i) {
		if (i >= 0) {
			ensureCapacity(size + 1);
			m_index[size] = i;
			size++;
		}
	}

	final public void add(int[] i) {

		for (int element : i)
			add(element);

	}

	final public void put(int i, double f) {
		if (i >= 0)
			createFeature(i, f);
	}

	// fv1 - fv2
	public FV getDistVector(FV fl2) {
		return new FV(this, fl2, true);
	}

	public double getScore(double[] parameters, boolean negate) {
		double score = 0.0;

		if (null != subfv1) {
			score += subfv1.getScore(parameters, negate);

			if (null != subfv2) {
				if (negate)
					score += subfv2.getScore(parameters, !negateSecondSubFV);
				else
					score += subfv2.getScore(parameters, negateSecondSubFV);

			}
		}

		if (negate)
			for (int i = 0; i < size; i++)
				score -= parameters[m_index[i]];
		else
			for (int i = 0; i < size; i++)
				score += parameters[m_index[i]];

		return score;
	}

	final public float getScore(float[] parameters, boolean negate) {
		float score = 0.0F;

		if (null != subfv1) {
			score += subfv1.getScore(parameters, negate);

			if (null != subfv2) {
				if (negate)
					score += subfv2.getScore(parameters, !negateSecondSubFV);
				else
					score += subfv2.getScore(parameters, negateSecondSubFV);

			}
		}

		// warning changed the the value

		if (negate)
			for (int i = 0; i < size; i++)
				score -= parameters[m_index[i]];// *m_value[i];
		else
			for (int i = 0; i < size; i++)
				score += parameters[m_index[i]];// *m_value[i];

		return score;
	}

	final public int getScore(short[] parameters, boolean negate) {
		int score = 0;

		if (null != subfv1) {
			score += subfv1.getScore(parameters, negate);

			if (null != subfv2) {
				if (negate)
					score += subfv2.getScore(parameters, !negateSecondSubFV);
				else
					score += subfv2.getScore(parameters, negateSecondSubFV);

			}
		}

		// warning changed the value

		if (negate)
			for (int i = 0; i < size; i++)
				score -= parameters[m_index[i]];// *m_value[i];
		else
			for (int i = 0; i < size; i++)
				score += parameters[m_index[i]];// *m_value[i];

		return score;
	}

	public void update(double[] parameters, double[] total, double alpha_k, double upd) {
		update(parameters, total, alpha_k, upd, false);
	}

	public final void update(double[] parameters, double[] total, double alpha_k, double upd, boolean negate) {

		if (null != subfv1) {
			subfv1.update(parameters, total, alpha_k, upd, negate);

			if (null != subfv2) {
				if (negate)
					subfv2.update(parameters, total, alpha_k, upd, !negateSecondSubFV);
				else
					subfv2.update(parameters, total, alpha_k, upd, negateSecondSubFV);
			}
		}

		if (negate) {
			for (int i = 0; i < size; i++) {
				parameters[m_index[i]] -= alpha_k;// *getValue(i);
				total[m_index[i]] -= upd * alpha_k;// *getValue(i);
			}
		} else {
			for (int i = 0; i < size; i++) {
				parameters[m_index[i]] += alpha_k;// *getValue(i);
				total[m_index[i]] += upd * alpha_k;// *getValue(i);
			}
		}

	}

	public final void update(short[] parameters, short[] total, double alpha_k, double upd, boolean negate) {

		if (null != subfv1) {
			subfv1.update(parameters, total, alpha_k, upd, negate);

			if (null != subfv2) {
				if (negate)
					subfv2.update(parameters, total, alpha_k, upd, !negateSecondSubFV);
				else
					subfv2.update(parameters, total, alpha_k, upd, negateSecondSubFV);
			}
		}

		if (negate) {
			for (int i = 0; i < size; i++) {
				parameters[m_index[i]] -= alpha_k;// *getValue(i);
				total[m_index[i]] -= upd * alpha_k;// *getValue(i);
			}
		} else {
			for (int i = 0; i < size; i++) {
				parameters[m_index[i]] += alpha_k;// *getValue(i);
				total[m_index[i]] += upd * alpha_k;// *getValue(i);
			}
		}

	}

	public final void update(float[] parameters, float[] total, double alpha_k, double upd, boolean negate) {

		if (null != subfv1) {
			subfv1.update(parameters, total, alpha_k, upd, negate);

			if (null != subfv2 && negate) {
				subfv2.update(parameters, total, alpha_k, upd, !negateSecondSubFV);
			} else {
				subfv2.update(parameters, total, alpha_k, upd, negateSecondSubFV);
			}

		}

		if (negate) {
			for (int i = 0; i < size; i++) {
				parameters[getIndex(i)] -= alpha_k;
				total[getIndex(i)] -= upd * alpha_k;
			}
		} else {
			for (int i = 0; i < size; i++) {
				parameters[getIndex(i)] += alpha_k;
				total[getIndex(i)] += upd * alpha_k; //
			}
		}

	}

	public final void update(float[] parameters, float[] total, double alpha_k, double upd, boolean negate,
			float[] totalp, Long2IntInterface li) {

		if (null != subfv1) {
			subfv1.update(parameters, total, alpha_k, upd, negate, totalp, li);

			if (null != subfv2 && negate) {
				subfv2.update(parameters, total, alpha_k, upd, !negateSecondSubFV, totalp, li);
			} else {
				subfv2.update(parameters, total, alpha_k, upd, negateSecondSubFV, totalp, li);
			}
		}

		if (negate) {
			for (int i = 0; i < size; i++) {
				parameters[getIndex(i)] -= alpha_k;
				total[getIndex(i)] -= upd * alpha_k;

				totalp[li.l2i(getIndex(i))] -= upd * alpha_k;
				// totalp[getIndex(i)] -=upd*alpha_k;
			}
		} else {
			for (int i = 0; i < size; i++) {
				parameters[getIndex(i)] += alpha_k;
				total[getIndex(i)] += upd * alpha_k; //

				totalp[li.l2i(getIndex(i))] += upd * alpha_k;
				// totalp[getIndex(i)] +=upd*alpha_k;
			}
		}
	}

	private static IntIntHash hm1;
	private static IntIntHash hm2;

	public int dotProduct(FV fl2) {

		if (hm1 == null)
			hm1 = new IntIntHash(size(), 0.4F);
		else
			hm1.clear();

		addFeaturesToMap(hm1);

		if (hm2 == null)
			hm2 = new IntIntHash(fl2.size, 0.4F);
		else
			hm2.clear();

		fl2.addFeaturesToMap(hm2);

		int[] keys = hm1.keys();

		int result = 0;
		for (int key : keys)
			result += hm1.get(key) * hm2.get(key);

		return result;

	}

	public double twoNorm(FV fl2) {

		if (hm1 == null)
			hm1 = new IntIntHash(size(), 0.4F);
		else
			hm1.clear();

		addFeaturesToMap(hm1);

		if (hm2 == null)
			hm2 = new IntIntHash(fl2.size, 0.4F);
		else
			hm2.clear();

		fl2.addFeaturesToMap(hm2);

		int[] keys = hm1.keys();

		int result = 0;
		for (int key : keys)
			result += hm1.get(key) * hm2.get(key);

		return Math.sqrt(result);

	}

	public void addFeaturesToMap(IntIntHash map) {

		if (null != subfv1) {
			subfv1.addFeaturesToMap(map);

			if (null != subfv2) {
				subfv2.addFeaturesToMap(map, negateSecondSubFV);

			}
		}

		for (int i = 0; i < size; i++)
			if (!map.adjustValue(getIndex(i), 1))
				map.put(getIndex(i), 1);

	}

	private void addFeaturesToMap(IntIntHash map, boolean negate) {

		if (null != subfv1) {
			subfv1.addFeaturesToMap(map, negate);

			if (null != subfv2) {
				if (negate)
					subfv2.addFeaturesToMap(map, !negateSecondSubFV);
				else
					subfv2.addFeaturesToMap(map, negateSecondSubFV);

			}
		}

		if (negate) {
			for (int i = 0; i < size; i++)
				if (!map.adjustValue(getIndex(i), -1))
					map.put(getIndex(i), -1);
		} else {
			for (int i = 0; i < size; i++)
				if (!map.adjustValue(getIndex(i), 1))
					map.put(getIndex(i), 1);
		}

	}

	@Override
	public final String toString() {
		StringBuilder sb = new StringBuilder();
		toString(sb);
		return sb.toString();
	}

	private final void toString(StringBuilder sb) {
		if (null != subfv1) {
			subfv1.toString(sb);

			if (null != subfv2)
				subfv2.toString(sb);
		}
		for (int i = 0; i < size; i++)
			sb.append(getIndex(i)).append(' ');
	}

	public void writeKeys(DataOutputStream dos) throws IOException {

		// int keys[] = keys();
		// dos.writeInt(keys.length);
		// for(int i=0;i<keys.length;i++) {
		// dos.writeInt(keys[i]);
		// }

		// int keys[] = keys();
		dos.writeInt(size);
		for (int i = 0; i < size; i++) {
			dos.writeInt(m_index[i]);
		}

	}

	public void readKeys(DataInputStream dos) throws IOException {

		int keys = dos.readInt();
		for (int i = 0; i < keys; i++)
			createFeature(dos.readInt(), 1.0);

	}

	final public static FV cat(FV f1, FV f2) {
		if (f1 == null)
			return f2;
		if (f2 == null)
			return f1;
		return new FV(f1, f2);
	}

	final public static FV cat(FV f1, FV f2, FV f3) {
		return FV.cat(f1, FV.cat(f2, f3));
	}

	final public static FV cat(FV f1, FV f2, FV f3, FV f4) {
		return FV.cat(f1, FV.cat(f2, FV.cat(f3, f4)));
	}

	final public static FV read(DataInputStream dis) throws IOException {
		int cap = dis.readInt();
		if (cap == 0)
			return null;
		return new FV(dis, cap);

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see is2.IFV#getScore()
	 */
	@Override
	public double getScore() {
		// System.out.println("not implemented");
		// TODO Auto-generated method stub
		return 0;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see is2.IFV#clone()
	 */
	@Override
	public IFV clone() {
		FV f = new FV(this.size);
		for (int i = 0; i < this.size; i++) {
			f.m_index[i] = m_index[i];
		}
		f.size = this.size;
		return f;
	}

}