view src/samer/maths/Mathx.java @ 0:bf79fb79ee13

Initial Mercurial check in.

/*
 *	Mathx.java	
 *
 *	Copyright (c) 2000, Samer Abdallah, King's College London.
 *	All rights reserved.
 *
 *	This software is provided AS iS and WITHOUT ANY WARRANTY; 
 *	without even the implied warranty of MERCHANTABILITY or 
 *	FITNESS FOR A PARTICULAR PURPOSE.
 */

package samer.maths;

/**
	A Class full of static functions, mainly for manipulating
	double arrays.
  */

public class Mathx
{
	private static double [] zeros = null;
	private static int zlength = 0;

	public double [] doubleArray(int n) { return new double[n]; }
	
	/** set to zeros */
	public static void zero(double [] x)
	{
		if (zlength<x.length) {
			zlength = x.length;
			zeros = new double[zlength];
			for (int i=0; i<zlength; i++) zeros[i]=0;
		}
		System.arraycopy(zeros,0,x,0,x.length);
	}

	/** set all to given value */
	public static void setAll(double [] x, double a) {
		for (int i=0; i<x.length; i++) x[i]=a;
	}
	
	/** log in place */
	public static void log(double [] x) {
		for (int i=0; i<x.length; i++) x[i]=Math.log(x[i]);
	}

	/** negate in place */
	public static void negate(double [] x) {
		for (int i=0; i<x.length; i++) x[i]=-x[i];
	}

	/** negate to y: x[i]=y[i] for all i */
	public static void negate(double [] x, double [] y) {
		for (int i=0; i<x.length; i++) y[i]=-x[i];
	}

	/** subtract: x[i]=y[i]-z[i] for all i */
	public static void sub(double [] x, double [] y, double [] z) {
		for (int i=0; i<x.length; i++) x[i]=y[i]-z[i];
	}

	public static void sub(int n, double [] x, double [] y, double [] z) {
		for (int i=0; i<n; i++) x[i]=y[i]-z[i];
	}

	/** subtract in place y: x[i]-=y[i] for all i */
	public static void sub(double [] x, double [] y) {
		for (int i=0; i<x.length; i++) x[i]-=y[i];
	}
	
	public static void sub(int n, double [] x, double [] y) {
		for (int i=0; i<n; i++) x[i]-=y[i];
	}

	
	/** subtract scalar in place y: x[i]-=y for all i */
	public static void sub(double [] x, double y) {
		for (int i=0; i<x.length; i++) x[i]-=y;
	}

	/** add two arrays: x[i]=y[i]+z[i] for all i */
	public static void add(double [] x, double [] y, double [] z) {
		for (int i=0; i<x.length; i++) x[i]=y[i]+z[i];
	}

	/** add in place y: x[i]+=y[i] for all i */
	public static void add(double [] x, double [] y) {
		for (int i=0; i<x.length; i++) x[i]+=y[i];
	}

	public static void add(int n, double [] x, double [] y) {
		for (int i=0; i<n; i++) x[i]+=y[i];
	}

	/** add scalar in place y: x[i]+=y for all i */
	public static void add(double [] x, double y) {
		for (int i=0; i<x.length; i++) x[i]+=y;
	}

	/** return sum of elements in x */
	public static double sum(double [] x)
	{
		double total=0;
		for (int i=0; i<x.length; i++) total+=x[i];
		return total;
	}

	public static void muladd(int n, double [] x, double [] y, double k) {
		for (int i=0; i<n; i++) x[i]+=k*y[i];
	}

	/** return product of elements in x */
	public static double prod(double [] x)
	{
		double total=1;
		for (int i=0; i<x.length; i++) total*=x[i];
		return total;
	}

	/** multiply by scalar in place: x[i] *=k */
	public static void mul(double [] x, double k) {
		for (int i=0; i<x.length; i++) x[i]*=k;
	}

	public static void mul(int n, double [] x, double k) {
		for (int i=0; i<n; i++) x[i]*=k;
	}

	/** scalar multiply  x[i] = k*y[i] */
	public static void mul(double [] x, double [] y, double k) {
		for (int i=0; i<x.length; i++) x[i]=k*y[i];
	}

	/** elementwise multiply in place: x[i] *=y[i] */
	public static void mul(double [] x, double [] y) {
		for (int i=0; i<x.length; i++) x[i]*=y[i];
	}

	/** elementwise multiply  x[i] =y[i]*z[i] */
	public static void mul(double [] x, double [] y, double [] z) {
		for (int i=0; i<x.length; i++) x[i]=y[i]*z[i];
	}

	/** elementwise divide in place: x[i] /=y[i] */
	public static void div(double [] x, double [] y) {
		for (int i=0; i<x.length; i++) x[i]/=y[i];
	}

	/** elementwise divide: x[i]=y[i]/z[i] */
	public static void div(double [] x, double [] y, double [] z) {
		for (int i=0; i<x.length; i++) x[i]=y[i]/z[i];
	}

	/** return maximum element of x */
	public static double max(double [] x)
	{
		double xmax=x[0];
		for (int i=1; i<x.length; i++) if (x[i]>xmax) xmax=x[i];
		return xmax;
	}

	/** return minimum element of x */
	public static double min(double [] x)
	{
		double xmin=x[0];
		for (int i=1; i<x.length; i++) if (x[i]<xmin) xmin=x[i];
		return xmin;
	}
	
	/** return index of supremum of elements in x */
	public static int argmax(double [] x)
	{
		double xmax=x[0];
		int	 imax=0;
		for (int i=1; i<x.length; i++) {
			if (x[i]>xmax) { xmax=x[i]; imax=i; }
		}
		return imax;
	}

	/** return dot product of a and b: sum_i a[i]*b[i] */
	public static double dot( double [] a, double [] b)
	{
		double t=0;
		for (int i=0; i<a.length; i++) t+=a[i]*b[i];
		return t;
	}

	/** return 2-norm of a: sum_i a[i]*a[i] */
	public static double norm2( double [] a)
	{
		double t=0;
		for (int i=0; i<a.length; i++) t+=a[i]*a[i];
		return t;
	}

	public static double norm2( int n, double [] a)
	{
		double t=0;
		for (int i=0; i<n; i++) t+=a[i]*a[i];
		return t;
	}

	/** copy a to b: b[i]=a[i] */
	public static void copy( double [] a, double [] b) {
		System.arraycopy(a,0,b,0,a.length);
	}

	/** return copy a in new array */
	public static double [] copy( double [] a) {
		double [] b = new double[a.length];
		System.arraycopy(a,0,b,0,a.length);
		return b;
	}

	public static double tanh(double t) {
//		if (t<-24) return -1;
//		if (t>24) return 1;
		if (t<0) { double z=Math.exp(2*t); return (z-1)/(z+1); }
		else     { double z=Math.exp(-2*t); return (1-z)/(1+z); }
	}
	
	public static double atanh(double t) { return Math.log((1+t)/(1-t))/2; }
	public static double cosh(double t) { double z=Math.exp(-t); return (1/z+z)/2; }
	public static double sinh(double t) { double z=Math.exp(-t); return (1/z-z)/2; }

	/** matrix multiplication: y[i] = sum_j A[i][j] x[j] */
	public static void mul( double [] y, double [][]A, double [] x)
	{
		int n=y.length;
		int m=x.length;
		double [] arow;

		for (int i=0; i<n; i++) {
			double t=0;
			arow=A[i];
			for (int j=0; j<m; j++) t+=arow[j]*x[j];
			y[i]=t;
		}
	}


	/** set each elements of a by extracting successive values from g */
	public static void set( double[] a, Generator g) {
		g.next(a);
		// int n=a.length; for (int i=0; i<n; i++) a[i]=g.next();
	}

	/** increment each element of a by a value extracted from g */
	public void add( double[] a, Generator g) {
		int n=a.length; for (int i=0; i<n; i++) a[i]+=g.next();
	}

	/** set each element using a function of its index */
	public static void index( double[] a) {
		for (int i=0; i<a.length; i++) a[i]=(double)i;
	}

	public static void indexFr( double[] a) {
		int N=a.length; for (int i=0; i<N; i++) a[i]=(double)i/N;
	}

	/** set each element using a function of its index */
	public static void table( double[] a, Function f) {
		index(a); f.apply(a);
	}
}