home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / kaffe-0.5p4-src.tgz / tar.out / contrib / kaffe / test / floats / TV.java < prev   
Text File  |  1996-09-28  |  3KB  |  161 lines
  1. import java.util.Random;
  2.  
  3. public class TV {
  4.     public static void main(String[] args)
  5.     {
  6.         int n = 5000;
  7.  
  8.         if (args.length > 0)
  9.         {
  10.             n = Integer.parseInt(args[0]);
  11.         }
  12.         System.out.println(n + " iterations.");
  13.  
  14.         Vec[] r = new Vec[n], a = new Vec[n], b = new Vec[n];
  15.  
  16.         System.out.println("Allocated vector vectors");
  17.  
  18.         Random random = new Random(89071);
  19.  
  20.         System.out.println("Allocated random number generator");
  21.  
  22.         for (int i = 0; i < n; i++)
  23.         {
  24.             a[i] = new Vec(
  25.                 random.nextDouble(),
  26.                 random.nextDouble(),
  27.                 random.nextDouble());
  28.             b[i] = new Vec(
  29.                 random.nextDouble(),
  30.                 random.nextDouble(),
  31.                 random.nextDouble());
  32.         }
  33.  
  34.         System.out.println("Starting...");
  35.  
  36.         long start = System.currentTimeMillis();
  37.         for (int i = 0; i < n; i++)
  38.         {
  39.             r[i] = Vec.cross(a[i] , b[i]);
  40.         }
  41.         long stop = System.currentTimeMillis();
  42.  
  43.         System.out.println("That took " + (stop - start) + " milliseconds.");
  44.     }
  45. }
  46.  
  47. class Vec {
  48.     public Vec()
  49.     {
  50.         v = new double[3];
  51.         v[0] = v[1] = v[2] = 0.0;
  52.     }
  53.     public Vec(double v0, double v1, double v2)
  54.     {
  55.         v = new double[3];
  56.         v[0] = v0;
  57.         v[1] = v1;
  58.         v[2] = v2;
  59.     }
  60.     public Vec(double[] _v)
  61.     {
  62.         v = _v;
  63.     }
  64.     public String toString()
  65.     {
  66.         return "( " + v[0] + ", " + v[1] + ", " + v[2] + " )";
  67.     }
  68.     public static double dot(Vec p, Vec q)
  69.     {
  70.         return
  71.             p.v[0] * q.v[0] +
  72.             p.v[1] * q.v[1] +
  73.             p.v[2] * q.v[2];
  74.     }
  75.     public static Vec cross(Vec p, Vec q)
  76.     {
  77.         return new Vec(
  78.             p.v[1] * q.v[2] - p.v[2] * q.v[1],
  79.             p.v[2] * q.v[0] - p.v[0] * q.v[2],
  80.             p.v[0] * q.v[1] - p.v[1] * q.v[0]);
  81.     }
  82.     public static double min(Vec p)
  83.     {
  84.         return Math.min(Math.min(p.v[0], p.v[1]), p.v[2]);
  85.     }
  86.     public static double max(Vec p)
  87.     {
  88.         return Math.max(Math.max(p.v[0], p.v[1]), p.v[2]);
  89.     }
  90.     public static Vec vmax(Vec p, Vec q)
  91.     {
  92.         return new Vec(
  93.             Math.max(p.v[0], q.v[0]),
  94.             Math.max(p.v[1], q.v[1]),
  95.             Math.max(p.v[2], q.v[2]));
  96.     }
  97.     public static Vec vmin(Vec p, Vec q)
  98.     {
  99.         return new Vec(
  100.             Math.min(p.v[0], q.v[0]),
  101.             Math.min(p.v[1], q.v[1]),
  102.             Math.min(p.v[2], q.v[2]));
  103.     }
  104.     public static double length(Vec p)
  105.     {
  106.         return Math.sqrt(p.v[0] * p.v[0] + p.v[1] * p.v[1] + p.v[2] * p.v[2]);
  107.     }
  108.     public static Vec add(Vec p, Vec q)
  109.     {
  110.         return new Vec(
  111.             p.v[0] + q.v[0],
  112.             p.v[1] + q.v[1],
  113.             p.v[2] + q.v[2]);
  114.     }
  115.     public static Vec neg(Vec p)
  116.     {
  117.         return new Vec(
  118.             -p.v[0],
  119.             -p.v[1],
  120.             -p.v[2]);
  121.     }
  122.     public static Vec sub(Vec p, Vec q)
  123.     {
  124.         return new Vec(
  125.             p.v[0] - q.v[0],
  126.             p.v[1] - q.v[1],
  127.             p.v[2] - q.v[2]);
  128.     }
  129.     public static Vec mul(double p, Vec q)
  130.     {
  131.         return new Vec(
  132.             p * q.v[0],
  133.             p * q.v[1],
  134.             p * q.v[2]);
  135.     }
  136.     public static Vec mul(Vec p, double q)
  137.     {
  138.         return new Vec(
  139.             p.v[0] * q,
  140.             p.v[1] * q,
  141.             p.v[2] * q);
  142.     }
  143.     public static Vec div(Vec p, double q)
  144.     {
  145.         double r = 1.0 / q;
  146.         return new Vec(
  147.             p.v[0] * r,
  148.             p.v[1] * r,
  149.             p.v[2] * r);
  150.     }
  151.     public double elt(int i)
  152.     {
  153.         return v[i];
  154.     }
  155.     public double[] elts()
  156.     {
  157.         return v;
  158.     }
  159.     protected double[] v;
  160. };
  161.