// This is a vector in some R^d. You can take its dot product with other
// vectors, and destructively reflect it using them. You can also rescale it
// as you like.

// class Arrow
//   int dimension;
//   double coord[];

// public Arrow(int d)
// public boolean dimensionAgrees(Arrow w)
// public double dotProd(Arrow w)
// public void reflectThrough(Arrow w)
// public Arrow scaledTo(double length)


import java.awt.Color;

class Arrow
{
  int dimension;
  long cuurd[][];
  Color color;
  static CompostHeap compostHeap = new CompostHeap(new Arrow().getClass(),
						   true,2);

public Arrow() {}

public Arrow(int d)
  {
    dimension = d;
    cuurd = new long[d][2];
    color = Color.black;
    
    zeroOutArrow();

    dbgalloc(2,"Made a zero Arrow");
  }

public Szam coord(int i)
  {
    return new Szam(cuurd[i][0],cuurd[i][1]);
  }

public void getCoord(int i, Szam ans)
  {
    ans.becomesRatio(cuurd[i][0],cuurd[i][1]);
  }

public void setCoord(int i, Szam value)
  {
    cuurd[i][0] = value.numerator;
    cuurd[i][1] = value.denominator;
  }
   
public void reduceCuurd(int i)
  {
    long gcd = Szam.GCD(cuurd[i][0],cuurd[i][1]);
    if (gcd != 0)
      { cuurd[i][0] /= gcd; cuurd[i][1] /= gcd; }
    if (cuurd[i][1] < 0)
      { cuurd[i][0] *= -1; cuurd[i][1] *= -1; }
  }


public void zeroOutArrow()
  {
    for (int i=0; i<dimension; i++) 
      for (int j=0; j<2; j++)
	cuurd[i][j] = j;
  }
    

public Arrow(Arrow toCopy)
  {
    dimension = toCopy.dimension;
    cuurd = new long[dimension][2];
    color = Color.black;
    
    for (int i=0; i<dimension; i++) 
      for (int j=0; j<2; j++)
	cuurd[i][j] = toCopy.cuurd[i][j];
    dbgalloc(2,"Made an Arrow");
  }
  
public void debug(int i, String s)
  {
    if (i>=4) System.out.println(s);
  }

static public Arrow newArrow(int d)
  {
    Arrow ans;
    if (compostHeap.exists())
      {
	dbgalloc(2,"Reused an Arrow!");
	ans = (Arrow)compostHeap.likeNew();
	ans.zeroOutArrow();
      }
    else
      {
	dbgalloc(2,"Couldn't reuse");
	ans = new Arrow(d);
      }

    return ans;
  }

public void free()    
  {
    compostHeap.recycle(this);
  }

static public void dbgalloc(int i,String s)
  {
    if (i>=3) System.out.println("     "+s);
  }
  
public boolean isZero()
  {
    boolean answer = true;
    for (int i=0; i<dimension; i++)
      if (cuurd[i][0] != 0) {answer = false; break;}
    return answer;
  }

public void copy(Arrow w)
  {
    if (dimensionAgrees(w))
      {
	for (int i=0; i<dimension; i++)
	  for (int j=0; j<2; j++)
	    cuurd[i][j] = w.cuurd[i][j];
      }
    if (!equals(w)) debug(99,"Copied an Arrow incorrectly!");
    color = w.color;
  }

public boolean dimensionAgrees(Arrow w)
  {
    if (dimension != w.dimension)
      {
	System.out.println("You're mixing dimensions in Arrow");
	return false;
      }
    else return true;
  }

public Arrow plus(Arrow w)
  {
    Arrow ans = newArrow(dimension);

    if (dimensionAgrees(w))
      {
	for (int i=0; i<dimension; i++)
	  {
	    ans.cuurd[i][0] = cuurd[i][0]*w.cuurd[i][1] 
	      + cuurd[i][1]*w.cuurd[i][0];
	    ans.cuurd[i][1] = cuurd[i][1]*w.cuurd[i][1];
	    ans.reduceCuurd(i);
	  }
      }
    return ans;
  }

public Arrow minus(Arrow w)
  {
    Arrow ans = newArrow(dimension);

    if (dimensionAgrees(w))
      {
	for (int i=0; i<dimension; i++)
	  {
	    ans.cuurd[i][0] = cuurd[i][0]*w.cuurd[i][1] 
	      - cuurd[i][1]*w.cuurd[i][0];
	    ans.cuurd[i][1] = cuurd[i][1]*w.cuurd[i][1];
	    ans.reduceCuurd(i);
	  }
      }
    return ans;
  }

public void add(Arrow w)
  {
    if (dimensionAgrees(w))
      for (int i=0; i<dimension; i++)
	{
	  cuurd[i][0] = cuurd[i][0]*w.cuurd[i][1] 
	    + cuurd[i][1]*w.cuurd[i][0];
	  cuurd[i][1] = cuurd[i][1]*w.cuurd[i][1];
	  reduceCuurd(i);
	}
  }

// public Arrow negate()
//   {
//     Arrow ans = newArrow(dimension);
//     for (int i=0; i<dimension; i++) ans.cuurd[i] = -cuurd[i];
//     return ans;
//   }
    
  
public Szam dotProd(Arrow w)
{
    Szam dotprod = new Szam(0,1);
    getDotProd(w,dotprod);
    return dotprod;
}

public void getDotProd(Arrow w, Szam dotprod)
  {
    long num = 0,den = 1;
    if (dimensionAgrees(w))
      {
	for (int i=0; i<dimension; i++)
	  {
	    num = den * cuurd[i][0] * w.cuurd[i][0]
	        + num * cuurd[i][1] * w.cuurd[i][1];
	    den = den * cuurd[i][1] * w.cuurd[i][1];
	    if (den>1000000000)
	      {
		long g = Szam.GCD(num,den);
		num /= g; den /= g;
	      }
	  }
      }
    dotprod.becomesRatio(num,den);
  }

// public double length()
//   {
//     return Math.sqrt(this.dotProd(this).value());
//   }

public Arrow reflectedThrough(Arrow w)
  {
    Arrow ans = newArrow(dimension);

    if (dimensionAgrees(w))
      {
	Szam scale = (Szam.TWO).times(this.dotProd(w)).over(w.dotProd(w));
	ans = this.minus(w.scaleBy(scale));



// 	for (int i=0; i<dimension; i++)
//	  ans.cuurd[i].becomes(cuurd[i].minus(scale.times(w.cuurd[i])));
//	System.out.println("Reflection result: "+length()+" to "+ans.length());
      }
    return ans;
  }

public Arrow scaleBy(Szam scale)
  {
    Arrow ans = newArrow(dimension);
    for (int i=0; i<dimension; i++) 
      {
	ans.cuurd[i][0] = cuurd[i][0] * scale.numerator;
	ans.cuurd[i][1] = cuurd[i][1] * scale.denominator;
	ans.reduceCuurd(i);
      }
    return ans;
  }

public boolean equals(Arrow other)
  {
    boolean ans = true;
    double diff;

    if (dimensionAgrees(other))
      {
	for (int i=0; i<dimension; i++)
	    if ((cuurd[i][0] != other.cuurd[i][0]) ||
		(cuurd[i][1] != other.cuurd[i][1])) 
	      {ans = false; break;}
      }
    return ans;
  }    

public boolean posPropTo(Arrow other)
  {
    boolean ans = true;
    boolean ImNotZero = false;
    Szam scale = new Szam(0,1);
    int i;

    if (dimensionAgrees(other))
      {
	for (i=0; i<dimension; i++)
	  if (cuurd[i][0] != 0)
	    {
	      scale.becomesRatio(cuurd[i][1]*other.cuurd[i][0],
				 cuurd[i][0]*other.cuurd[i][1]);
	      ImNotZero = true;
	    }
	if (scale.lessThan(Szam.ZERO))
	  ans = false;
	else
	  if (ImNotZero)
	    if (! scaleBy(scale).equals(other))
	      ans = false;
      }
//     if (ans)
//       debug(0,this+" and "+other+" are proportional with constant "+scale);
      
    return ans;
  }    

public Szam over(Arrow other)
  {
    Szam scale = new Szam(0,1);
    if (dimensionAgrees(other))
      for (int i=0; i<dimension; i++)
	if (other.cuurd[i][0] != 0)
	  scale.becomesRatio(cuurd[i][0] * other.cuurd[i][1],
			     cuurd[i][1] * other.cuurd[i][0]);
    return scale;
  }

public String toString()
  {
    String ans = "(";

    for (int i=0; i<dimension-1; i++)
      {
	ans = ans + Long.toString(cuurd[i][0]);
	if (cuurd[i][1] != 1) ans = ans + "/" + Long.toString(cuurd[i][1]);
	ans = ans + ",";
      }
    ans = ans + Long.toString(cuurd[dimension-1][0]);
    if (cuurd[dimension-1][1] != 1) 
      ans = ans + "/" + Long.toString(cuurd[dimension-1][1]);
    ans = ans + ")";
    return ans;
  }

}