package mikera.vectorz.impl;

import java.util.Iterator;

import mikera.arrayz.Arrayz;
import mikera.arrayz.INDArray;
import mikera.arrayz.impl.IStridedArray;
import mikera.matrixx.AMatrix;
import mikera.matrixx.Matrixx;
import mikera.matrixx.impl.AStridedMatrix;
import mikera.matrixx.impl.StridedMatrix;
import mikera.vectorz.AVector;
import mikera.vectorz.Op;
import mikera.vectorz.Op2;
import mikera.vectorz.Vector;
import mikera.vectorz.Vectorz;
import mikera.vectorz.util.DoubleArrays;
import mikera.vectorz.util.ErrorMessages;
import mikera.vectorz.util.VectorzException;

/**
 * Abstract base class for vectors backed by a double[] array with a constant stride
 * 
 * The double array can be directly accessed for performance purposes
 * 
 * @author Mike
 */
public abstract class AStridedVector extends AArrayVector implements IStridedArray {
	protected AStridedVector(int length, double[] data) {
		super(length,data);
	}

	private static final long serialVersionUID = -7239429584755803950L;

	/**
	 * Gets the underlying double[] data array for this vector
	 */
	@Override
	public final double[] getArray() {
		return data;
	}
	
	/**
	 * Gets the offset into the underlying double[] data array for the first element of this vector
	 */
	@Override
	public abstract int getArrayOffset();
	
	/**
	 * Gets the stride of this strided vector.
	 * @return
	 */
	public abstract int getStride();
	
	@Override
	public AStridedVector ensureMutable() {
		if (isFullyMutable()) return this;
		return clone();
	}
	
	@Override
	public boolean isRangeZero(int start, int length) {
		int stride=getStride();
		int offset=getArrayOffset()+start*stride;
		return DoubleArrays.isZero(data, offset, length,stride);
	}
	
	@Override public double dotProduct(double[] data, int offset) {
		return DoubleArrays.dotProduct(data,offset,getArray(), getArrayOffset(), getStride(), length());
	}
	
	@Override
	public double dotProduct(AVector v) {
		checkLength(v.length());
		return v.dotProduct(getArray(), getArrayOffset(), getStride());
	}

	
	@Override
	public double elementSum() {
		return DoubleArrays.elementSum(getArray(), getArrayOffset(), getStride(), length());
	}
	
	@Override
	public double elementProduct() {
		int len=length();
		double[] array=getArray();
		int offset=getArrayOffset();
		int stride=getStride();
		double result=1.0;
		for (int i=0; imax) max=d;
		}
		return max;
	}
	
	@Override
	public double elementMin(){
		int len=length();
		double[] array=getArray();
		int offset=getArrayOffset();
		int stride=getStride();
		double min = Double.MAX_VALUE;
		for (int i=0; i iterator() {
		return new StridedElementIterator(getArray(),getArrayOffset(),length(),getStride());
	}
	
	@Override
	public int getStride(int dimension) {
		if (dimension!=0) throw new IllegalArgumentException(ErrorMessages.invalidDimension(this, dimension));
		return getStride();
	}
	
	@Override
	public double elementSquaredSum() {
		return DoubleArrays.elementSquaredSum(data, getArrayOffset(), length,getStride());
	}
	
	@Override
	public void getElements(double[] dest, int destOffset) {
		int offset=getArrayOffset();
		int stride=getStride();
		for (int i=0; i0) {
			int offset=getArrayOffset();
			if ((offset<0)||(offset>=data.length)) throw new VectorzException("offset out of bounds: "+offset);
			int lastIndex=offset+(getStride()*(length-1));
			if ((lastIndex<0)||(lastIndex>=data.length)) throw new VectorzException("lastIndex out of bounds: "+lastIndex);
		}
		super.validate();
	}
}