public class Vector {
	public int n; //dimensión
	public double[] x;
	public Vector(int n) {
		this.n=n;
		x=new double[n];
		for(int i=0; i<n; i++){
			x[i]=0.0;
		}
	}
	public Vector(double[] x) {
		this.x=x;
		n=x.length;
	}
}

public class Matriz implements Cloneable{
	public int n; //dimensión
	public double[][] x;
	public Matriz(int n) {
		this.n=n;
		x=new double[n][n];
		for(int i=0; i<n; i++){
			for(int j=0; j<n; j++){
				x[i][j]=0.0;
			}
		}
	}
	public Matriz(double[][] x) {
		this.x=x;
		n=x.length;
	}
	public Object clone(){
		Matriz obj=null;
		try{
			obj=(Matriz)super.clone();
		}catch(CloneNotSupportedException ex){
			System.out.println(" no se puede duplicar");
		}
		obj.x=(double[][])obj.x.clone();
		for(int i=0; i<obj.x.length; i++){
			obj.x[i]=(double[])obj.x[i].clone();
		}
		return obj;
	}

//producto de una matriz por un vector columna (nxn) (nx1)= (nx1)
	static Vector producto(Matriz a, Vector v){
		int n=v.n; //dimensión
		Vector b=new Vector(n);
		for(int i=0; i<n; i++){
			for(int k=0; k<n; k++){
				b.x[i]+=a.x[i][k]*v.x[k];
			}
		}
		return b;
	}
//matriz inversa
	static Matriz inversa(Matriz d){
		int n=d.n; //dimensión de la matriz
		Matriz a=(Matriz)d.clone();
		Matriz b=new Matriz(n); //matriz de los términos independientes
		Matriz c=new Matriz(n); //matriz de las incógnitas
//matriz unidad
		for(int i=0; i<n; i++){
			b.x[i][i]=1.0;
		}
//transformación de la matriz y de los términos independientes
		for(int k=0; k<n-1; k++){
			for(int i=k+1; i<n; i++){
//términos independientes
				for(int s=0; s<n; s++){
					b.x[i][s]-=a.x[i][k]*b.x[k][s]/a.x[k][k];
				}
//elementos de la matriz
				for(int j=k+1; j<n; j++){
					a.x[i][j]-=a.x[i][k]*a.x[k][j]/a.x[k][k];
				}
			}
		}
//cálculo de las incógnitas, elementos de la matriz inversa
		for(int s=0; s<n; s++){
			c.x[n-1][s]=b.x[n-1][s]/a.x[n-1][n-1];
			for(int i=n-2; i>=0; i--){
				c.x[i][s]=b.x[i][s]/a.x[i][i];
				for(int k=n-1; k>i; k--){
					c.x[i][s]-=a.x[i][k]*c.x[k][s]/a.x[i][i];
				}
			}
		}
		return c;
	} 
}
      

class Colision {
	public static void main(String[] args) {
//datos
		double ang=0*Math.PI/180;
		double mu=0.1;
		double e=0.94;
		double u1=3.5;
		double M=0.5;
		double k=0.5;   //discos
//incógnitas
		double v1;
		double v2;
		double w1;
		double w2;
		double fi1;
		double fi2;
		double Q;
		if(ang==0){
//choques frontales
			v1=(M-e)*u1/(1+M);
			v2=M*(1+e)*u1/(1+M);
			fi1=.0;
			fi2=0.0;
			w1=0.0;
			w2=0.0;
		}else{
//choques oblicuos
			double[][] matriz={
		{Math.sin(ang), Math.cos(ang), -Math.sin(ang), -Math.cos(ang), 1.0, 1.0},
			{0.0, M, 0.0, 1.0, 0.0, 0.0},
			{M, 0.0, 1.0, 0.0, 0.0, 0.0},
		{-Math.cos(ang), Math.sin(ang), Math.cos(ang), -Math.sin(ang),0.0, 0.0},
			{Math.sin(ang), Math.cos(ang), 0.0, 0.0, -k, 0.0},
			{0.0, 0.0, Math.sin(ang), Math.cos(ang), 0.0, k}
			};
			Matriz coef=new Matriz(matriz);
			double[] vector={
				0.0,
				0.0,
				(M*u1),
				(e*u1*Math.cos(ang)),
				(u1*Math.sin(ang)),
				0.0
				};
			Vector ter=new Vector(vector);
			Vector solucion=Matriz.producto(Matriz.inversa(coef), ter);
			System.out.println("No desliza ");
//desliza o no desliza?
			double V1x=solucion.x[0];
			double V1y=solucion.x[1];
			double V2x=solucion.x[2];
			double V2y=solucion.x[3];
			w1=solucion.x[4];
			w2=solucion.x[5];
			double A=mu*(V1y*Math.sin(ang)-(V1x-u1)*Math.cos(ang));
			double B=u1*Math.sin(ang)-V1x*Math.sin(ang)-V1y*Math.cos(ang);
			if(A<B){
//desliza
				coef.x[0][0]=Math.sin(ang)-mu*Math.cos(ang);
				coef.x[0][1]=Math.cos(ang)+mu*Math.sin(ang);
				coef.x[0][2]=0.0;
				coef.x[0][3]=0.0;
				coef.x[0][4]=0.0;
				coef.x[0][5]=0.0;
				ter.x[0]=-mu*u1*Math.cos(ang)+u1*Math.sin(ang);
				solucion=Matriz.producto(Matriz.inversa(coef), ter);
				V1x=solucion.x[0];
				V1y=solucion.x[1];
				V2x=solucion.x[2];
				V2y=solucion.x[3];
				w1=solucion.x[4];
				w2=solucion.x[5];
				double comprobar=V2y*Math.cos(ang)+V2x*Math.sin(ang)-
				mu*(-V2y*Math.sin(ang)+V2x*Math.cos(ang));
				System.out.println("desliza - comprobar"+comprobar);
			}
			v1=Math.sqrt(V1x*V1x+V1y*V1y);
			fi1=Math.atan2(V1y,V1x);
			v2=Math.sqrt(V2x*V2x+V2y*V2y);
			fi2=Math.atan2(V2y,V2x);
		}
//energía perdida en la colisión
		Q=M*v1*v1/2+M*k*w1*w1/2+v2*v2/2+k*w2*w2/2-M*u1*u1/2;
//imprime los resultados
		System.out.println("primera partícula: v. c.m. "+v1+" dirección "+
		(180*fi1/Math.PI)+" v. angular "+w1);
		System.out.println("segunda partícula: v. c.m. "+v2+" dirección "+
		(180*fi2/Math.PI)+" v. angular "+w2);
		System.out.println("energía perdida en la colisión "+Q);
	}
}