Exemple #1
0
  public void mouseDragged(MouseEvent evt) {
    Graphics g = canvas.getGraphics();
    g.setColor(color);

    if (type == 0) {
      g.setXORMode(canvas.getBackground());
      g.drawRect(start.x, start.y, end.x - start.x, end.y - start.y);
      end = evt.getPoint();
      g.drawRect(start.x, start.y, end.x - start.x, end.y - start.y);
    } else if (type == 1) {
      int radius;

      g.setXORMode(canvas.getBackground());

      radius = (int) Math.sqrt(Math.pow(end.x - start.x, 2) + Math.pow(end.y - start.y, 2));

      g.drawOval(start.x - radius, start.y - radius, 2 * radius, 2 * radius);
      end = evt.getPoint();

      radius = (int) Math.sqrt(Math.pow(end.x - start.x, 2) + Math.pow(end.y - start.y, 2));

      g.drawOval(start.x - radius, start.y - radius, 2 * radius, 2 * radius);
    } else if (type == 2) {
      g.setXORMode(canvas.getBackground());
      g.drawOval(start.x, start.y, end.x - start.x, end.y - start.y);
      end = evt.getPoint();
      g.drawOval(start.x, start.y, end.x - start.x, end.y - start.y);
    }
  }
Exemple #2
0
  public void mouseReleased(MouseEvent evt) {
    Graphics g = canvas.getGraphics();
    g.setColor(color);
    g.setPaintMode();
    end = evt.getPoint();

    if (type == 0) {
      g.drawRect(start.x, start.y, end.x - start.x, end.y - start.y);

      if (filled.getState() == true) g.fillRect(start.x, start.y, end.x - start.x, end.y - start.y);

      status.setText("2. Ecke des Rechtecks festgelegt");
    } else if (type == 1) {
      int radius;

      radius = (int) Math.sqrt(Math.pow(end.x - start.x, 2) + Math.pow(end.y - start.y, 2));

      g.drawOval(start.x - radius, start.y - radius, 2 * radius, 2 * radius);

      if (filled.getState() == true)
        g.fillOval(start.x - radius, start.y - radius, 2 * radius, 2 * radius);

      status.setText("Radius des Kreises festgelegt");
    } else if (type == 2) {
      g.drawOval(start.x, start.y, end.x - start.x, end.y - start.y);

      if (filled.getState() == true) g.fillOval(start.x, start.y, end.x - start.x, end.y - start.y);

      status.setText("Radius der Ellipse festgelegt");
    }
  }
Exemple #3
0
  private void spawnRandomers() {
    for (int i = 0; i < randomN; i++) {
      float x = (float) Math.random() * width;
      float y = (float) Math.random() * height;
      float r =
          (float)
              Math.sqrt(
                  Math.pow(((Player) players.get(0)).getX() - x, 2)
                      + Math.pow(((Player) players.get(0)).getY() - x, 2));

      while (r < distanceLimit) {
        x = (float) Math.random() * width;
        y = (float) Math.random() * height;
        r =
            (float)
                Math.sqrt(
                    Math.pow(((Player) players.get(0)).getX() - x, 2)
                        + Math.pow(((Player) players.get(0)).getY() - y, 2));
      }

      enemies.add(new EnemyTypes.Random(x, y, 0.5f, borders));
    }

    spawnRandomersB = false;
  }
Exemple #4
0
 public double distanciaEuclidiana(int x1, int x2, int y1, int y2) {
   double a, b, c;
   a = Math.pow(x2 - x1, 2);
   b = Math.pow(y2 - y1, 2);
   c = Math.sqrt(a + b);
   return (c);
 }
  public void paint(Graphics g) {
    level = level_in;
    left_width_factor = (float) Math.pow(2.0, -1 / left_alpha);
    right_width_factor = (float) Math.pow(2.0, -1 / right_alpha);
    left_height_factor = (float) Math.pow(2.0, -2 / (3 * left_alpha));
    right_height_factor = (float) Math.pow(2.0, -2 / (3 * right_alpha));

    x = (float) 600 / 2.0f;
    y = (float) 500 / 10.0f;

    x1 = x;
    y01 = y + height;

    drawbranch(g, width, (int) x, 500 - (int) y, (int) x1, 500 - (int) y01);
    turtle_r = height;
    turtle_theta = point(x, y, x1, y01);
    turtle_x = x;
    turtle_y = y;
    turn(left_angle);
    generate(g, x1, y01, left_width_factor * width, left_height_factor * height, left_angle, level);
    turtle_theta = point(x, y, x1, y01);
    turn(-right_angle);
    generate(g, x1, y01, width, left_height_factor * height, right_angle, level);
    g.drawString("Fractal.java", 10, 10);
  }
Exemple #6
0
 private long normalizeMax(long l) {
   int exp = (int) Math.log10((double) l);
   long multiple = (long) Math.pow(10.0, exp);
   int i = (int) (l / multiple);
   l = (i + 1) * multiple;
   return l;
 }
    public void paintIcon(Component c, Graphics g, int x, int y) {
      Color color = c == null ? Color.GRAY : c.getBackground();
      // In a compound sort, make each succesive triangle 20%
      // smaller than the previous one.
      int dx = (int) (size / 2 * Math.pow(0.8, priority));
      int dy = descending ? dx : -dx;
      // Align icon (roughly) with font baseline.
      y = y + 5 * size / 6 + (descending ? -dy : 0);
      int shift = descending ? 1 : -1;
      g.translate(x, y);

      // Right diagonal.
      g.setColor(color.darker());
      g.drawLine(dx / 2, dy, 0, 0);
      g.drawLine(dx / 2, dy + shift, 0, shift);

      // Left diagonal.
      g.setColor(color.brighter());
      g.drawLine(dx / 2, dy, dx, 0);
      g.drawLine(dx / 2, dy + shift, dx, shift);

      // Horizontal line.
      if (descending) {
        g.setColor(color.darker().darker());
      } else {
        g.setColor(color.brighter().brighter());
      }
      g.drawLine(dx, 0, 0, 0);

      g.setColor(color);
      g.translate(-x, -y);
    }
Exemple #8
0
 public static String readableFileSize(long size) {
   if (size <= 0) return "0";
   final String[] units = new String[] {"B", "KB", "MB", "GB", "TB"};
   int digitGroups = (int) (Math.log10(size) / Math.log10(1024));
   return new DecimalFormat("#,##0.#").format(size / Math.pow(1024, digitGroups))
       + " "
       + units[digitGroups];
 }
  /*------------------------------------------------------------------*/
  double getInitialCausalCoefficientMirrorOnBounds(double[] c, double z, double tolerance) {
    double z1 = z, zn = Math.pow(z, c.length - 1);
    double sum = c[0] + zn * c[c.length - 1];
    int horizon = c.length;

    if (0.0 < tolerance) {
      horizon = 2 + (int) (Math.log(tolerance) / Math.log(Math.abs(z)));
      horizon = (horizon < c.length) ? (horizon) : (c.length);
    }
    zn = zn * zn;
    for (int n = 1; (n < (horizon - 1)); n++) {
      zn = zn / z;
      sum = sum + (z1 + zn) * c[n];
      z1 = z1 * z;
    }
    return (sum / (1.0 - Math.pow(z, 2 * c.length - 2)));
  } /* end getInitialCausalCoefficientMirrorOnBounds */
Exemple #10
0
  private Picture initialImage() {
    pic2 = new Picture(500, 600);
    pic1 = new Picture(500, 600);

    for (int x = 0; x < pic2.width(); x++)
      for (int y = 0; y < pic2.height(); y++) {
        double dist = 1.0 - Math.sqrt((x - 300) * (x - 300) + (y - 200) * (y - 200)) / 500;
        int red =
            (int)
                (dist < 0.5
                    ? 0
                    : Math.min(Math.pow(dist, 0.4) + Math.pow(dist - 0.5, 0.1), 1.0) * 255);
        int green = (int) (dist * 255);
        int blue = 0;
        pic2.set(x, y, new Color(red, green, blue));
      }
    return pic2;
  }
 public double getValue(DatanVector x) {
   double result;
   double a = sqrt2pi * x.getElement(1);
   if (a < small) f = big;
   else f = Math.log(a);
   result = (double) y.length * f;
   for (int i = 0; i < y.length; i++) {
     f = Math.pow((y[i] - x.getElement(0)), 2.) / (2. * x.getElement(1) * x.getElement(1));
     result += f;
   }
   return result;
 }
  // calculate and display amounts
  private void calculateJButtonActionPerformed(ActionEvent event) {
    resultJTextArea.setText("Rate (%)\tAmount after 10 years");
    DecimalFormat dollars = new DecimalFormat("$0.00");

    int principal = Integer.parseInt(principalJTextField.getText());

    // for loop to calculate interest
    for (int rate = 5; rate <= 10; rate++) {
      double amount = (double) principal * Math.pow(1 + ((double) rate / 100), 10);
      resultJTextArea.append("\n" + rate + "\t" + dollars.format(amount));
    } // end for
  } // end method calculateJButtonActionPerformed
 protected void plotScatterDiagram() {
   // plot sample as one dimensional scatter plot and Gaussian
   double xmax = 5.;
   double xmin = -5.;
   DatanGraphics.openWorkstation(getClass().getName(), "E3Min_1.ps");
   DatanGraphics.setFormat(0., 0.);
   DatanGraphics.setWindowInComputingCoordinates(xmin, xmax, 0., .5);
   DatanGraphics.setViewportInWorldCoordinates(-.15, .9, .16, .86);
   DatanGraphics.setWindowInWorldCoordinates(-.414, 1., 0., 1.);
   DatanGraphics.setBigClippingWindow();
   DatanGraphics.chooseColor(2);
   DatanGraphics.drawFrame();
   DatanGraphics.drawScaleX("y");
   DatanGraphics.drawScaleY("f(y)");
   DatanGraphics.drawBoundary();
   double xpl[] = new double[2];
   double ypl[] = new double[2];
   // plot scatter diagram
   DatanGraphics.chooseColor(1);
   for (int i = 0; i < y.length; i++) {
     xpl[0] = y[i];
     xpl[1] = y[i];
     ypl[0] = 0.;
     ypl[0] = .1;
     DatanGraphics.drawPolyline(xpl, ypl);
   }
   // draw Gaussian corresponding to solution
   int npl = 100;
   xpl = new double[npl];
   ypl = new double[npl];
   double fact = 1. / (Math.sqrt(2. * Math.PI) * x.getElement(1));
   double dpl = (xmax - xmin) / (double) (npl - 1);
   for (int i = 0; i < npl; i++) {
     xpl[i] = xmin + (double) i * dpl;
     ypl[i] = fact * Math.exp(-.5 * Math.pow((xpl[i] - x.getElement(0)) / x.getElement(1), 2.));
   }
   DatanGraphics.chooseColor(5);
   DatanGraphics.drawPolyline(xpl, ypl);
   // draw caption
   String sn = "N = " + nny;
   numForm.setMaximumFractionDigits(3);
   numForm.setMinimumFractionDigits(3);
   String sx1 = ", x_1# = " + numForm.format(x.getElement(0));
   String sx2 = ", x_2# = " + numForm.format(x.getElement(1));
   String sdx1 = ", &D@x_1# = " + numForm.format(Math.sqrt(cx.getElement(0, 0)));
   String sdx2 = ", &D@x_2# = " + numForm.format(Math.sqrt(cx.getElement(1, 1)));
   caption = sn + sx1 + sx2 + sdx1 + sdx2;
   DatanGraphics.setBigClippingWindow();
   DatanGraphics.chooseColor(2);
   DatanGraphics.drawCaption(1., caption);
   DatanGraphics.closeWorkstation();
 }
  public void showStats() {
    DecimalFormat twoPlaces = new DecimalFormat("0.00");
    int sumd = 0, sumdsq = 0;
    int maxd = 0, mind = gSize - 1;
    double p, q;
    maxdCount = 0;
    p = CAGridStatic.params.pr;
    q = CAGridStatic.params.pl;
    for (int i = 0; i < gSize; i++) if (dCount[i] > maxdCount) maxdCount = dCount[i];
    for (int i = 0; i < runCount; i++) {
      sumd = sumd + savedd[i];
      sumdsq = sumdsq + saveddsq[i];
      if (savedd[i] < mind) mind = savedd[i];
      if (savedd[i] > maxd) maxd = savedd[i];
    }
    runStats[0] = maxit * (p - q); // expected d
    runStats[1] = (maxit * (p + q) + maxit * (maxit - 1) * Math.pow(p - q, 2.0)); // expected dsq
    runStats[2] = (double) sumd / (double) (runCount); // av d from this run
    runStats[3] = ((double) sumdsq) / ((double) (runCount));
    runStats[4] = maxdCount;

    if (runCount > 0) {
      System.out.println(
          "expected d: "
              + twoPlaces.format(runStats[0])
              + " expected dsq "
              + twoPlaces.format(runStats[1]));
      System.out.println(
          "av d: " + twoPlaces.format(runStats[2]) + " av d sq " + twoPlaces.format(runStats[3]));
      System.out.println("range of d: " + mind + " to " + maxd);
      System.out.println("maxdCount " + maxdCount);
      System.out.println("runCount = " + runCount);
      /* for debug java.io.FileWriter file;
      try {
      	file = new java.io.FileWriter("stuff.dat");
      	java.io.BufferedWriter buffer = new java.io.BufferedWriter(file);
      	for (int i=0;i<runCount;i++){
      		buffer.write(savedd[i]+" "+saveddsq[i]+"\n");
      	}
      	buffer.close();

      } catch (IOException e) {
      	// TODO Auto-generated catch block
      	e.printStackTrace();
      }*/

    }
  }
  // calculate and display amounts
  private void calculateJButtonActionPerformed(ActionEvent event) {
    // declare variables to store user input
    double principal = Double.parseDouble(principalJTextField.getText());
    double rate = Double.parseDouble(interestRateJTextField.getText());

    Integer integerObject = (Integer) yearsJSpinner.getValue();
    Integer year = integerObject.intValue();

    yearlyBalanceJTextArea.setText("Year\tAmount on Deposit");
    DecimalFormat dollars = new DecimalFormat("$0.00");

    // calculate the total value for each year
    for (int count = 1; count <= year; count++) {
      double amount = principal * Math.pow((1 + rate / 100), count);
      yearlyBalanceJTextArea.append("\n" + count + "\t" + dollars.format(amount));
    } // end for
  } // end method calculateJButtonActionPerformed
Exemple #16
0
 public void makeRelationsButtonActionPerformed(ActionEvent evt) {
   System.out.println("In make relationships");
   int k = stakeholders.size();
   for (Iterator<Stakeholder> s = stakeholders.iterator(); s.hasNext(); ) {
     Stakeholder stakeholder = s.next();
     int place = (int) Math.pow(2.0, (double) k);
     int random = (int) (Math.random() * place);
     place /= 2;
     System.out.println(random);
     for (int i = k - 1; i >= 0; i--) {
       System.out.printf("if(%d >= %d)\n", random, place);
       if (random >= place) {
         System.out.printf("%s.addI(%s)%n", stakeholder.getName(), stakeholders.get(i).getName());
         stakeholder.addInfluence(stakeholders.get(i).getName(), (int) (Math.random() * 4));
         random -= place;
       }
       place /= 2;
     }
   }
 }
Exemple #17
0
  private void removeFullRows() {
    int n_full = countFullRows();
    score_label.addValue((int) (10 * Math.pow(2, n_full) - 10));
    if (n_full == 0) return;

    sounds.playDestroyRows(n_full);

    if (num_rows_deleted / DELETED_ROWS_PER_LEVEL
        != (num_rows_deleted + n_full) / DELETED_ROWS_PER_LEVEL) {
      timer.faster();
      level_label.addValue(n_full / DELETED_ROWS_PER_LEVEL + 1);
      level_label.repaint();
    }

    rows_deleted_label.addValue(n_full);
    num_rows_deleted += n_full;

    for (int i = ROWS - 1; i >= 0; i--) while (rowIsFull(i)) removeRow(i);

    game_grid.repaint();
  }
 /**
  * Gets called when clicking the save button. Puts data back into Worker and fires
  * ListSelectionEvent in Worker, so that the 3D View is updated.
  */
 public void save() {
   short[] tmpFrame = frame;
   changedStateSinceSave = false;
   short reihe = 0;
   for (int j = 0; j < 8; j++) {
     for (int i = 0; i < 8; i++) {
       reihe += ((short) Math.pow(2, i)) * ledStatus[i][j];
     }
     tmpFrame[(8 * (li + 1) + j) - 8] = reihe;
     reihe = 0;
   }
   frame = tmpFrame;
   worker.getAnimation(animI).getFrame(frameI).setData(frame);
   ListSelectionEvent layerChanged =
       new ListSelectionEvent(
           LedFrame.frameList,
           LedFrame.frameList.getSelectedIndex(),
           LedFrame.frameList.getSelectedIndex(),
           false);
   LedFrame.valueChanged(layerChanged);
   dispose();
 }
 public void readFNum() {
   // work in nybbles: 0-9=0-9, a=. b=E, c=E-, d=rsvd e=neg f=end
   float f = 0;
   boolean neg = false;
   int exp = 0;
   int eval = 0;
   float mul = 1;
   byte work = data[pos++];
   while (true) {
     if (work == (byte) 0xdd) {
       work = data[pos++];
     }
     int nyb = (work >> 4) & 0xf;
     work = (byte) ((work << 4) | 0xd);
     if (nyb < 10) {
       if (exp != 0) { // working on the exponent
         eval = eval * 10 + nyb;
       } else if (mul == 1) { // working on an int
         f = f * 10 + nyb;
       } else { // working on decimal part
         f += nyb * mul;
         mul /= 10f;
       }
     } else if (nyb == 0xa) { // decimal
       mul = 0.1f;
     } else if (nyb == 0xb) { // E+
       exp = 1;
     } else if (nyb == 0xc) { // E-
       exp = -1;
     } else if (nyb == 0xe) { // neg
       neg = true;
     } else {
       break;
     }
   }
   fnum = (neg ? -1 : 1) * f * (float) Math.pow(10, eval * exp);
 }
Exemple #20
0
 public boolean contains(Point p) {
   int distance = (int) (Math.sqrt(Math.pow(p.x - centre.x, 2) + Math.pow(p.y - centre.y, 2)));
   return (distance < size / 2);
 }
 public double getValue(DatanVector x, double t) {
   return x.getElement(0) * Math.pow(t, x.getElement(1));
 }
Exemple #22
0
 public void setDecimals(int decimals) {
   this.decimals = decimals;
   this.decimalsMultiplier = Math.pow(10.0, decimals);
 }
 public void actionPerformed(ActionEvent ae) {
   String s = ae.getActionCommand();
   if (s.equals("Dodawanie")) {
     tekst = "";
     tekst2 = "";
     wynik = "";
     tekst += textField1.getText();
     wynik += "1";
     textField1.setText("");
   } else if (s.equals("Odejmowanie")) {
     tekst = "";
     tekst2 = "";
     wynik = "";
     tekst += textField1.getText();
     wynik += "2";
     textField1.setText("");
   } else if (s.equals("Mnozenie")) {
     tekst = "";
     tekst2 = "";
     wynik = "";
     tekst += textField1.getText();
     wynik += "3";
     textField1.setText("");
   } else if (s.equals("Dzielenie")) {
     tekst = "";
     tekst2 = "";
     wynik = "";
     tekst += textField1.getText();
     wynik += "4";
     textField1.setText("");
   } else if (s.equals("Potegowanie")) {
     tekst = "";
     tekst2 = "";
     wynik = "";
     tekst += textField1.getText();
     wynik += "5";
     textField1.setText("");
   } else if (s.equals("Pierwiastek")) {
     tekst = "";
     tekst2 = "";
     wynik = "";
     tekst += textField1.getText();
     int a = Integer.parseInt(tekst);
     f = (double) Math.sqrt(a);
     textField1.setText("" + zao.format(f));
   } else if (s.equals("Wynik")) {
     tekst2 += textField1.getText();
     int a = Integer.parseInt(tekst);
     int b = Integer.parseInt(tekst2);
     int w = Integer.parseInt(wynik);
     if (w == 1) {
       c = a + b;
       textField1.setText("" + c);
     }
     if (w == 2) {
       c = a - b;
       textField1.setText("" + c);
     }
     if (w == 3) {
       c = a * b;
       textField1.setText("" + c);
     }
     if (w == 4) {
       c = a / b;
       textField1.setText("" + c);
     }
     if (w == 5) {
       c = (int) Math.pow(a, b);
       textField1.setText("" + c);
     }
   } else if (s.equals("Czysc")) {
     tekst = "";
     tekst2 = "";
     wynik = "";
     textField1.setText("");
   }
 }
Exemple #24
0
class LJ3MD {
  static final int D = 3;
  public int N = 256;
  private int DOF = N * D - D * (D + 1) / 2;
  double rho = 0.256;
  double dt = 0.002; // time step for integrating Newton's equation
  public double L = 10.0; // side of the box
  public double Vol = 1000.0;
  double rc = 2.5; // cut-off radius
  double epsilon = 0.001; // interaction strength
  public double kT = 1.0; // temperature times Boltzmann constant
  double x[][]; // position, from 0 to 1
  double v[][], f[][]; //  velocity and force
  double xwrap[][]; // wrapped coordinates
  double K, U, Us, E; // kinetic, potential, and total energy
  double Vir, p; // virial and pressure
  boolean thermostat = true; // use thermostat
  boolean ljPotential = true;
  double ushift;
  double Utail; // potential energy tail correction
  double ptail; // pressure tail correction
  int step; // simulation steps

  double boltK = 1.38 * Math.pow(10, -23);
  Ave avU = new Ave(), avK = new Ave(), avp = new Ave();

  /** constructor */
  LJ3MD(double den) {
    init(den);
  }

  /** initialize system */
  public void init(double den) {
    int i, j, k, id;

    DOF = N * D - D * (D + 1) / 2;
    setDensity(den);
    step = 0;
    x = new double[N][D];
    v = new double[N][D];
    f = new double[N][D];
    xwrap = new double[N][D];
    for (id = 0; id < N; id++) for (j = 0; j < D; j++) v[id][j] = 0.0;

    int N1 = (int) (pow(2 * N, 1.0 / D) + .999999); // # of particles per side (cubic lattic)
    double a = 1. / N1;
    for (id = 0, i = 0; i < N1 && id < N; i++) // place particles on a cubic lattice
    for (j = 0; j < N1 && id < N; j++)
        for (k = 0; k < N1 && id < N; k++) {
          if ((i + j + k) % 2 != 0) continue;
          x[id][0] = a * (i + .5);
          x[id][1] = a * (j + .5);
          x[id][2] = a * (k + .5);
          id++;
        }
  }

  /** set density and recalculate tail corrections */
  void setDensity(double den) {
    rho = den;
    Vol = N / rho;
    L = pow(Vol, 1.0 / D);

    /* compute shifts and tail corrections */
    if ((rc = 2.5) > .5 * L) rc = .5 * L;
    double irc = 1. / rc, irc3 = irc * irc * irc, irc6 = irc3 * irc3;
    ushift = 4.0 * irc6 * (irc6 - 1);
    Utail = 8.0 * PI / 9 * rho * N * (irc6 - 3) * irc3;
    ptail = 16.0 * PI / 9 * rho * rho * (irc6 - 1.5) * irc3;

    clearData();
  }

  void clearData() {
    step = 0;
    avU.clear();
    avK.clear();
    avp.clear();
  }

  /** integrate Newton's equation by one step, velocity Verlet */
  void vv() {
    double dth = dt * .5, dtl = dt / L;

    for (int id = 0; id < N; id++) // velocity-verlet, first half
    for (int d = 0; d < D; d++) {
        v[id][d] += f[id][d] * dth;
        x[id][d] += v[id][d] * dtl;
      }

    force(); // compute force

    for (int id = 0; id < N; id++) // velocity-verlet, second half
    for (int d = 0; d < D; d++) v[id][d] += f[id][d] * dth;

    rmcom(); // rm angular momentum however isn't good idea due to
    // pbc and minimal image convension
    K = vrescale(0.02); // compute kinetic energy and adjust velocity
    E = K + Us;
    step++;
    avU.add(U);
    avK.add(K);
    avp.add(p);
  }

  /** calculate potential energy and force half-box cutoff, minimal distance image */
  double xij[] = new double[D];

  void force() {
    int i, j, d, prcnt = 0;
    double invr2, invr6, r2, fscal, tmp;

    // clear the force and energy
    U = 0.0;
    Vir = 0.0;
    for (i = 0; i < N; i++) for (d = 0; d < D; d++) f[i][d] = 0.0;

    // loop over pairs of particles and compute energy (1) Lennard-Jones, (2) WCA;

    // LJ 12-6

    for (i = 0; i < N - 1; i++) {
      for (j = i + 1; j < N; j++) {
        rv3Diff(xij, x[i], x[j]);
        vpbc(xij);
        r2 = vsqr(xij);

        // (1)
        if (ljPotential) {

          if (r2 > rc * rc) continue; // if r > rc: break
          invr2 = 1.0 / r2;
          invr6 = invr2 * invr2 * invr2;
          fscal = invr6 * (48.0 * invr6 - 24.0);
          Vir += fscal;
          fscal *= invr2;
          for (d = 0; d < D; d++) {
            tmp = xij[d] * fscal;
            f[i][d] += tmp;
            f[j][d] -= tmp;
          }
          U += 4.0 * invr6 * (invr6 - 1.0);

        }

        // (2)
        else {

          if (r2 > 1.2599210492 * rc * rc) {

          } else {
            invr2 = 1.0 / r2;
            invr6 = invr2 * invr2 * invr2;
            fscal = invr6 * (48.0 * invr6 - 24.0);
            Vir += fscal;
            fscal *= invr2;
            for (d = 0; d < D; d++) {
              tmp = xij[d] * fscal;
              f[i][d] += tmp;
              f[j][d] -= tmp;
            }
            U += 4.0 * invr6 * (invr6 - 1.0) + epsilon;
          }
        }

        prcnt++;
      }
    }

    Us = U - prcnt * ushift;
    U += Utail;
    p = rho * kT + Vir / (3 * Vol) + ptail;
  }

  Random rng = new Random();

  /** velocity rescaling thermostat */
  double vrescale(double dt) {
    double ek1 = getEKin();

    if (!thermostat) return ek1;
    double ekav = .5f * kT * DOF;
    double amp = 2 * sqrt(ek1 * ekav * dt / DOF);
    double ek2 = ek1 + (ekav - ek1) * dt + amp * rng.nextGaussian();
    if (ek2 < 0) ek2 = ek1;
    double s = sqrt(ek2 / ek1);
    for (int i = 0; i < N; i++) for (int d = 0; d < D; d++) v[i][d] *= s;
    return ek2;
  }

  /** remove motion of the center of mass */
  void rmcom() {
    for (int d = 0; d < D; d++) { // remove the center of mass motion
      double vc = 0.0;
      for (int id = 0; id < N; id++) vc += v[id][d];
      vc /= N;
      for (int id = 0; id < N; id++) v[id][d] -= vc;
    }
  }

  private void rv3Diff(double c[], double a[], double b[]) {
    c[0] = a[0] - b[0];
    c[1] = a[1] - b[1];
    c[2] = a[2] - b[2];
  }

  private double rv3Dot(double a[], double b[]) {
    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
  }

  /** return the kinetic energy */
  double getEKin() {
    double ek = 0.0;
    for (int i = 0; i < N; i++) ek += rv3Dot(v[i], v[i]);
    return .5 * ek;
  }

  /** image with the minimal distance */
  double pbc(double a) {
    return L * (a - ((int) (a + 1000.5) - 1000));
  }

  void vpbc(double v[]) {
    v[0] = pbc(v[0]);
    v[1] = pbc(v[1]);
    v[2] = pbc(v[2]);
  }

  double vsqr(double v[]) {
    return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
  }

  /** wrap coordinates back into box */
  public double[][] getXWrap() {
    for (int i = 0; i < N; i++)
      for (int d = 0; d < D; d++) {
        double xx = x[i][d] + 1000.0;
        xwrap[i][d] = (xx - (int) xx) * L;
      }
    return xwrap;
  }
}
Exemple #25
0
  /** Get an image based on index numbers */
  public BufferedImage getIndexedImage(
      int x, int y, int zoom, int cacheZoom, GMapListener listener) {

    if (listener != null) {
      if (!getGDataSource().isCached(x, y, zoom)) {
        listener.updateGMapPainting();
        listener.updateGMapMessage(GMap.MESSAGE_DOWNLOADING);
      } else {
        listener.updateGMapMessage(GMap.MESSAGE_PAINTING);
      }
    }

    BufferedImage thumbImage = getGDataSource().getImage(x, y, zoom, true);

    if (thumbImage == null) return defaultImage;

    // if we dont have to paint cache, return here
    if (cacheZoom == (GPhysicalPoint.MIN_ZOOM - 1) || cacheZoom >= zoom) return thumbImage;

    BufferedImage paintedImage =
        new BufferedImage(
            GDataSource.sourceSize.width,
            GDataSource.sourceSize.height,
            BufferedImage.TYPE_INT_ARGB);
    Graphics2D graphics2D = paintedImage.createGraphics();
    graphics2D.drawImage(
        thumbImage, 0, 0, GDataSource.sourceSize.width, GDataSource.sourceSize.height, null);

    // now lets move to painting the cache
    double imageNum = Math.pow(2, zoom - cacheZoom);

    // draw cache lines
    int startX = (int) (imageNum * x);
    int startY = (int) (imageNum * y);

    // get composite to restore later, set new transparent composite
    Composite originalComposite = graphics2D.getComposite();
    graphics2D.setComposite(opacity40);

    // draw grid
    for (int i = 0; i < imageNum; i++) {
      for (int j = 0; j < imageNum; j++) {
        // points
        Point upperLeft =
            new Point(
                (int) (GDataSource.sourceSize.width / imageNum) * i,
                (int) (GDataSource.sourceSize.height / imageNum) * j);
        Dimension size =
            new Dimension(
                (int) (GDataSource.sourceSize.width / imageNum),
                (int) (GDataSource.sourceSize.height / imageNum));

        // draw lines
        graphics2D.setColor(new Color(100, 100, 100));
        graphics2D.drawLine(upperLeft.x, upperLeft.y, upperLeft.x + size.width, upperLeft.y);
        graphics2D.drawLine(upperLeft.x, upperLeft.y, upperLeft.x, upperLeft.y + size.height);

        // check if file exists
        if (getGDataSource().isCached(startX + i, startY + j, cacheZoom))
          graphics2D.setColor(Color.RED);
        else graphics2D.setColor(new Color(155, 155, 155));

        // shade rectangle
        graphics2D.fillRect(upperLeft.x, upperLeft.y, size.width, size.height);
      }
    }

    // restore composite
    graphics2D.setComposite(originalComposite);

    return paintedImage;
  }
Exemple #26
0
  public int ai_move(int[][] board) {
    if (running) {
      System.out.println(
          "This AI appears to be running multiple ai_moves simultaneously. That can't be right.");
    }
    running = true;
    try {
      // System.out.println(2 + Math.random());
      if (recording) {
        if (out == null) {
          try {
            int ind = 1;
            File f = null;
            while (true) {
              try {
                Scanner sc = new Scanner(new File("AIReplay" + ind + ".txt"));
                ind++;
              } catch (Exception e) {
                break;
              }
            }
            out = new PrintWriter(new File("AIReplay" + ind + ".txt"));
            filename = "AIReplay" + ind + ".txt";
            out.println("AI Version: " + VERSION);
          } catch (Exception e) {
            System.out.println("Could not write to file.");
          }
        }
        fprint(board);
      }
      // if (fml == null) fml = new PrintWriter (new File("fmldebug.txt"));
      if (thisAIIsCheating && max(board) < 8) {
        board[0][0] = GameGUI.win_target;
      }
      if (debug2) sc.nextLine();
      if (debug2) print(board);
      if (debug) System.out.println("New cycle.");
      if (debug) sc.nextLine();
      if (dumbai) name += "Dumby";
      turn++;
      if (!queue.isEmpty()) {
        int temp = queue.removeFirst();
        if (temp > 0) {
          running = false;
          return temp;
        }
      }
      int boardsum = 0;
      for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
          boardsum += board[i][j];
        }
      }
      boolean report = debug;
      /*if (Math.random() < 0.0001) {
      report = true;
      for (int i = 0; i < 4; i++) {
      	System.out.println(Arrays.toString(board[i]));
      }
      for (int i = 0; i < 4; i++) {
      	System.out.println(movable(board, i));
      }
      System.out.println();
      sc.nextLine();
      }*/
      if (dumbai) {
        if (!name.endsWith("Dumby")) name += "Dumby";
        System.out.println(turn);
        running = false;
        if (turn % 600 == 599) return KeyEvent.VK_DOWN;
        if (turn % 3 == 0) return KeyEvent.VK_UP;
        if (turn % 6 < 3) return KeyEvent.VK_LEFT;
        return KeyEvent.VK_RIGHT;
      } else {
        if (name.indexOf(".") < 0) name += VERSION;
      }
      // gamestart processing
      /*if(board[0][0] == 0) {
      	if (board[1][0] > board[0][1]) {
      		return KeyEvent.VK_UP;
      	}
      	if (board[1][0] < board[0][1]) {
      		return KeyEvent.VK_LEFT;
      	}
      	if (Math.random() < 0.5) return KeyEvent.VK_UP;
      	return KeyEvent.VK_LEFT;
      }*/
      long[] pref = {10, 20, 1, 1}; // LEFT, UP, RIGHT, DOWN

      // check if moving right/down is safe
      boolean occupied = true;

      for (int i = 0; i < 4; i++) {
        if (board[0][i] == 0) occupied = false;
        if (i < 3 && board[0][i] == board[0][i + 1]) occupied = false;
      }
      if (!occupied) {
        // pref[2] -= 100000000;
      }
      occupied = true;
      for (int i = 0; i < 4; i++) {
        if (board[i][0] == 0) occupied = false;
        if (i < 3 && board[i][0] == board[i + 1][0]) occupied = false;
      }
      if (!occupied) {
        // pref[3] -= 100000000;
      }

      pref[0] += 5;
      pref[1] += 5;

      // System.out.println(6 + Math.random());
      // simulate
      sum_board = sum(board);
      delta_sum_board_7over8 = delta(sum_board * 7 / 8);
      if (debug) print(board);
      max_depth = 0;
      for (int m = 0; m < 4; m++) {
        if (debug) System.out.println("Now testing move: " + m);
        int[][] sim = simulate(board, m);
        if (Arrays.deepEquals(sim, board)) {
          if (out != null) out.println("Move " + m + " invalid; skipping");
          if (GameGUI.out != null) GameGUI.out.println("Move " + m + " invalid; skipping");
          continue;
        }
        long worst = (long) 1999999999 * 1000000000;
        long avg = 0;
        int numt = 0;
        for (int i = 0; i < 4; i++) {
          for (int j = 0; j < 4; j++) {
            if (sim[i][j] > 0) continue;
            sim[i][j] = 2;
            long temp = predictor(sim, iter_max / (int) Math.pow((countBlank(sim) + 1), 1.6), 1);
            if (temp < worst) worst = temp;
            avg += 9 * temp;
            sim[i][j] = 4;
            temp = predictor(sim, iter_max / (int) Math.pow((countBlank(sim) + 1), 1.6), 1);
            if (temp < worst) worst = temp;
            avg += temp;
            sim[i][j] = 0;
            numt += 10;
          }
        }
        if (countBlank(sim) == 0) {
          long temp = predictor(sim, iter_max / (int) pow((countBlank(sim) + 1), 2), 1);
          if (temp < worst) worst = temp;
          avg += temp;
          numt++;
        }
        avg /= numt;
        worst = (worst_weight * worst + avg) / (worst_weight + 1);
        if (countBlank(sim) >= 8 && max(board) < 64) worst = avg;
        if (debug || debug2) System.out.println("Move " + m + " final eval: " + worst);
        if (out != null) out.println("Move " + m + " final eval: " + worst);
        if (GameGUI.out != null) GameGUI.out.println("Move " + m + " final eval: " + worst);
        pref[m] += worst;
      }
      if (debug2) System.out.println("Max depth: " + max_depth);
      if (out != null) out.println("Max depth: " + max_depth);
      if (GameGUI.out != null) GameGUI.out.println("Max depth: " + max_depth);

      // System.out.println(5 + Math.random());
      // process output
      int[] dir = new int[4];
      dir[0] = KeyEvent.VK_LEFT;
      dir[1] = KeyEvent.VK_UP;
      dir[2] = KeyEvent.VK_RIGHT;
      dir[3] = KeyEvent.VK_DOWN;
      if (report) System.out.println("Pref: " + Arrays.toString(pref));
      for (int i = 0; i < 4; i++) {
        int best = 0;
        for (int j = 0; j < 4; j++) {
          if (pref[j] > pref[best]) {
            best = j;
          }
        }
        pref[best] = Long.MIN_VALUE;
        if (movable(board, best)) {
          if (report) {
            report = false;
            if (debug) System.out.println("Chosen: " + best);
            if (debug) sc.nextLine();
          }
          // if (pref[best] < -50000000) queue.add(best - 2);
          running = false;
          return dir[best];
        }
        // System.out.println("Unmovable: " + best);
        // System.out.println("Pref: " + Arrays.toString(pref));
      }
      System.out.println("???");
      for (int i = 0; i < 4; i++) {
        System.out.println(Arrays.toString(board[i]));
      }
      // sc.nextLine();
    } catch (Exception e) {
      e.printStackTrace();
    }
    running = false;
    return KeyEvent.VK_LEFT;
  }
 protected void compute() {
   n = (int) ni[0].parseInput();
   t0 = ni[1].parseInput();
   deltat = ni[2].parseInput();
   x1 = ni[3].parseInput();
   x2 = ni[4].parseInput();
   sigma = ni[5].parseInput();
   // generate data points
   t = new DatanVector(n);
   y = new DatanVector(n);
   dy = new DatanVector(n);
   rand = DatanRandom.standardNormal(n);
   for (int i = 0; i < n; i++) {
     t.setElement(i, t0 + (double) i * deltat);
     y.setElement(i, x1 * Math.pow(t.getElement(i), x2) + sigma * rand[i]);
     dy.setElement(i, sigma);
   }
   // find 1st approximation of unknowns by method of log-log plot
   tlog = new double[n];
   ylog = new double[n];
   dellog = new double[n];
   int npos = 0;
   for (int i = 0; i < n; i++) {
     if (t.getElement(i) > 0. && y.getElement(i) > 0.) {
       tlog[npos] = Math.log(t.getElement(i));
       ylog[npos] = Math.log(y.getElement(i));
       dellog[npos] = 1.;
       npos++;
     }
   }
   DatanVector vtlog = new DatanVector(npos);
   DatanVector vylog = new DatanVector(npos);
   DatanVector vdellog = new DatanVector(npos);
   for (int j = 0; j < npos; j++) {
     vtlog.setElement(j, tlog[j]);
     vylog.setElement(j, ylog[j]);
     vdellog.setElement(j, dellog[j]);
   }
   LsqPol lp = new LsqPol(vtlog, vylog, vdellog, 2);
   x = lp.getResult();
   x.setElement(0, Math.exp(x.getElement(0)));
   df.writeLine(" x = " + x.toString());
   // perform fit
   int[] list = {1, 1};
   powerlaw = new Powerlaw();
   LsqNon ln = new LsqNon(t, y, dy, x, list, powerlaw);
   x = ln.getResult();
   x1 = x.getElement(0);
   x2 = x.getElement(1);
   cov = ln.getCovarianceMatrix();
   delx1 = Math.sqrt(cov.getElement(0, 0));
   delx2 = Math.sqrt(cov.getElement(1, 1));
   rho = cov.getElement(1, 0) / (delx1 * delx2);
   m = ln.getChiSquare();
   p = 1. - StatFunct.cumulativeChiSquared(m, n - 1);
   // curve of fitted exponential
   xpl = new double[1001];
   ypl = new double[1001];
   dpl = (double) (n - 1) * deltat / 1000.;
   for (int i = 0; i < 1001; i++) {
     xpl[i] = t0 + (double) i * dpl;
     ypl[i] = x1 * Math.pow(xpl[i], x2);
   }
   // prepare data points for plotting
   datx = new double[n];
   daty = new double[n];
   datsx = new double[n];
   datsy = new double[n];
   datrho = new double[n];
   for (int i = 0; i < n; i++) {
     datx[i] = t.getElement(i);
     daty[i] = y.getElement(i);
     datsx[i] = 0.;
     datsy[i] = dy.getElement(i);
     datrho[i] = 0.;
   }
   // display data and fitted curve
   caption =
       "x_1#="
           + String.format(Locale.US, "%5.2f", x1)
           + ", x_2#="
           + String.format(Locale.US, "%5.2f", x2)
           + ", &D@x_1#="
           + String.format(Locale.US, "%5.2f", delx1)
           + ", &D@x_2#="
           + String.format(Locale.US, "%5.2f", delx2)
           + ", &r@="
           + String.format(Locale.US, "%5.2f", rho)
           + ", M="
           + String.format(Locale.US, "%5.2f", m)
           + ", P="
           + String.format(Locale.US, "%6.4f", p);
   new GraphicsWithDataPointsAndPolyline(
       getClass().getName(),
       "",
       xpl,
       ypl,
       1,
       .3,
       datx,
       daty,
       datsx,
       datsy,
       datrho,
       "t",
       "y",
       caption);
 }
Exemple #28
0
  public void processSectionSpline(boolean shiftDown) {
    mCurrPC.setBatchModeOn();

    if (!shiftDown) mCurrPC.unselectAll();

    // loop on spline pts
    for (int s = 0; s < mSplinePoints.size() - 2; s++) {
      Point p1 = (Point) mSplinePoints.elementAt(s);
      Point p2 = (Point) mSplinePoints.elementAt(s + 1);

      int x1 = p1.x - mLeft - 5;
      int y1 = p1.y - mTop - 5;
      int x2 = p2.x - mLeft - 5;
      int y2 = p2.y - mTop - 5;

      // construct the search polygon
      double dx = x1 - x2;
      double dy = y1 - y2;
      int width1 = ComputeSectionPixelWidth(p1);
      int width2 = ComputeSectionPixelWidth(p2);

      if (dx == 0 && dy == 0) return;
      double dist = (double) Math.pow(dx * dx + dy * dy, 0.5f);

      double p1x = x1 + (double) width1 * (-dy / dist);
      double p1y = y1 + (double) width1 * (dx / dist);

      double p2x = x1 - (double) width1 * (-dy / dist);
      double p2y = y1 - (double) width1 * (dx / dist);

      double p3x = x2 + (double) width2 * (-dy / dist);
      double p3y = y2 + (double) width2 * (dx / dist);

      double p4x = x2 - (double) width2 * (-dy / dist);
      double p4y = y2 - (double) width2 * (dx / dist);

      Polygon srcArea = new Polygon();
      srcArea.addPoint((int) p2x, (int) p2y);
      srcArea.addPoint((int) p1x, (int) p1y);
      srcArea.addPoint((int) p3x, (int) p3y);
      srcArea.addPoint((int) p4x, (int) p4y);

      // search for matches
      byte[] currFilterResults = fdm.getResults();
      double[] yArray1 = getYArray1();
      double[] xArray1 = getXArray1();
      double[] yArray2 = getYArray2();
      double[] xArray2 = getXArray2();
      mCurrPC.setBatchModeOn();
      for (int i = 0; i < mCurrPC.getSize(); i++) {
        if (!mIgnoreFilter
            && (mCurrPC.isDeleted(i) || currFilterResults[i] != 4 || !mCurrPC.isSelectedLayer(i)))
          continue;
        double yi = yArray1[i];
        double xi = xArray1[i];
        double xi2 = Float.NaN;
        double yi2 = Float.NaN;
        double xx2 = Float.NaN;
        double yy2 = Float.NaN;

        // correct the X value if necessary
        xi = correctX(xi);

        double xx1 = (xi - winXOrigin) * winXScale;
        double yy1 = (yi - winYOrigin) * winYScale;

        // correct the Y coordinate if necessary
        yy1 = correctY(yy1);

        if (!isYAxisScaler()) {
          yi2 = yArray2[i];
          yy2 = (yi2 - winYOrigin) * winYScale;
          ;
          yy2 = correctY(yy2);
        } else yy2 = yy1;

        if (!isXAxisScaler()) {
          xi2 = xArray2[i];
          xi2 = correctX(xi2);
          xx2 = (xi2 - winXOrigin) * winXScale;
        } else xx2 = xx1;

        if (srcArea.contains(new Point((int) xx1, (int) yy1))
            || srcArea.contains(new Point((int) xx2, (int) yy2))) {
          mCurrPC.select(i);
        }
      }
    } // for splines

    mSplinePoints.removeAllElements();
    mViewManager.invalidateAllViews();
    mCurrPC.setBatchModeOff();
  }