Exemple #1
0
  private void pickSmart() {
    this.buildingFound = false;
    synchronized (ContextManager.randomLock) {
      Collections.shuffle(GlobalVars.burgleMap); // Shuffle the map
      for (Building b : GlobalVars.burgleMap) {
        // TODO: Tune this logic for Objective #2 of the project. Consider game theory or some other
        // type
        //      of SoS decision making process to decide if it is best to travel to burgle location
        // or
        //      prevent other burgles by traveling to less-burgled parts of the map (e.g. replace
        // the 25%
        //      value with "game theory" idea where the cost/benefits are adjusted (trade study) to
        //      analyze behavior on crime
        Uniform uniform = RandomHelper.createUniform(0, 1);
        if (uniform.nextDouble()
            < GlobalVars.probTraveltoRecentCrime) { // 25% chance of traveling near recent crime
          if ((b.jurisdiction == this.jurisdiction) && !(this.burgleMapSave.contains(b))) {
            this.b_pick = b;
            this.route = new Route(this, b.getCoords(), b_pick); // Initialize route to target;
            this.buildingFound = true;
            this.burgleMapSave.add(b);
            break; // stop searching
          }
        }
      }

      if (this.buildingFound == false) {
        pickRandom(); // no previously burgled building exists in memory map for given jurisdiction
      }
    }
  }
  @Override
  public void eventOccurred(final AuctionEvent event) {
    super.eventOccurred(event);

    if (event instanceof SimulationStartedEvent) {
      minValueDist =
          new Uniform(
              generator.getMinValueMin(),
              generator.getMinValueMax(),
              Galaxy.getInstance().getDefaultTyped(GlobalPRNG.class).getEngine());
      rangeDist =
          new Uniform(
              generator.getRangeMin(),
              generator.getRangeMax(),
              Galaxy.getInstance().getDefaultTyped(GlobalPRNG.class).getEngine());
    } else if (event instanceof GameStartingEvent) {

      final double minValue = minValueDist.nextDouble();
      final double maxValue = minValue + rangeDist.nextDouble();

      setDistribution(
          new Uniform(
              minValue,
              maxValue,
              Galaxy.getInstance().getDefaultTyped(GlobalPRNG.class).getEngine()));
      drawRandomValue();
    }
  }
Exemple #3
0
  @Override
  public Double mutate(Uniform uniform, Object previousValue) {
    double y = (Double) previousValue;
    double yl = min;
    double yu = max;
    double delta1 = (y - yl) / (yu - yl);
    double delta2 = (yu - y) / (yu - yl);
    double rnd = uniform.nextDoubleFromTo(0.0, 1.0);
    double mut_pow = 1 / (eta_m + 1);
    double deltaq;
    if (rnd <= 0.5) {
      double xy = 1 - delta1;
      double val = 2 * rnd + (1 - 2 * rnd) * (Math.pow(xy, (eta_m + 1)));
      deltaq = Math.pow(val, mut_pow) - 1;
    } else {
      double xy = 1 - delta2;
      double val = 2 * (1 - rnd) + 2 * (rnd - 0.5) * (Math.pow(xy, (eta_m + 1)));
      deltaq = 1 - (Math.pow(val, mut_pow));
    }

    y = y + deltaq * (yu - yl);

    if (y < yl) y = yl;
    if (y > yu) y = yu;

    return y;
  }
Exemple #4
0
  /**
   * Generic bootstrap resampling. Quite optimized - Don't be afraid to try it. Executes
   * <tt>resamples</tt> resampling steps. In each resampling step does the following:
   *
   * <ul>
   *   <li>Uniformly samples (chooses) <tt>size()</tt> random elements <i>with replacement</i> from
   *       <tt>this</tt> and fills them into an auxiliary bin <tt>b1</tt>.
   *   <li>Uniformly samples (chooses) <tt>other.size()</tt> random elements <i>with replacement</i>
   *       from <tt>other</tt> and fills them into another auxiliary bin <tt>b2</tt>.
   *   <li>Executes the comparison function <tt>function</tt> on both auxiliary bins
   *       (<tt>function.apply(b1,b2)</tt>) and adds the result of the function to an auxiliary
   *       bootstrap bin <tt>b3</tt>.
   * </ul>
   *
   * <p>Finally returns the auxiliary bootstrap bin <tt>b3</tt> from which the measure of interest
   * can be read off.
   *
   * <p><b>Background:</b>
   *
   * <p>Also see a more <A HREF="http://garnet.acns.fsu.edu/~pkelly/bootstrap.html"> in-depth
   * discussion</A> on bootstrapping and related randomization methods. The classical statistical
   * test for comparing the means of two samples is the <i>t-test</i>. Unfortunately, this test
   * assumes that the two samples each come from a normal distribution and that these distributions
   * have the same standard deviation. Quite often, however, data has a distribution that is
   * non-normal in many ways. In particular, distributions are often unsymmetric. For such data, the
   * t-test may produce misleading results and should thus not be used. Sometimes asymmetric data
   * can be transformed into normally distributed data by taking e.g. the logarithm and the t-test
   * will then produce valid results, but this still requires postulation of a certain distribution
   * underlying the data, which is often not warranted, because too little is known about the data
   * composition.
   *
   * <p><i>Bootstrap resampling of means differences</i> (and other differences) is a robust
   * replacement for the t-test and does not require assumptions about the actual distribution of
   * the data. The idea of bootstrapping is quite simple: simulation. The only assumption required
   * is that the two samples <tt>a</tt> and <tt>b</tt> are representative for the underlying
   * distribution with respect to the statistic that is being tested - this assumption is of course
   * implicit in all statistical tests. We can now generate lots of further samples that correspond
   * to the two given ones, by sampling <i>with replacement</i>. This process is called
   * <i>resampling</i>. A resample can (and usually will) have a different mean than the original
   * one and by drawing hundreds or thousands of such resamples <tt>a<sub>r</sub></tt> from
   * <tt>a</tt> and <tt>b<sub>r</sub></tt> from <tt>b</tt> we can compute the so-called bootstrap
   * distribution of all the differences &quot;mean of <tt>a<sub>r</sub></tt> minus mean of
   * <tt>b<sub>r</sub></tt>&quot;. That is, a bootstrap bin filled with the differences. Now we can
   * compute, what fraction of these differences is, say, greater than zero. Let's assume we have
   * computed 1000 resamples of both <tt>a</tt> and <tt>b</tt> and found that only <tt>8</tt> of the
   * differences were greater than zero. Then <tt>8/1000</tt> or <tt>0.008</tt> is the p-value
   * (probability) for the hypothesis that the mean of the distribution underlying <tt>a</tt> is
   * actually larger than the mean of the distribution underlying <tt>b</tt>. From this bootstrap
   * test, we can clearly reject the hypothesis.
   *
   * <p>Instead of using means differences, we can also use other differences, for example, the
   * median differences.
   *
   * <p>Instead of p-values we can also read arbitrary confidence intervals from the bootstrap bin.
   * For example, <tt>90%</tt> of all bootstrap differences are left of the value <tt>-3.5</tt>,
   * hence a left <tt>90%</tt> confidence interval for the difference would be
   * <tt>(3.5,infinity)</tt>; in other words: the difference is <tt>3.5</tt> or larger with
   * probability <tt>0.9</tt>.
   *
   * <p>Sometimes we would like to compare not only means and medians, but also the variability
   * (spread) of two samples. The conventional method of doing this is the <i>F-test</i>, which
   * compares the standard deviations. It is related to the t-test and, like the latter, assumes the
   * two samples to come from a normal distribution. The F-test is very sensitive to data with
   * deviations from normality. Instead we can again resort to more robust bootstrap resampling and
   * compare a measure of spread, for example the inter-quartile range. This way we compute a
   * <i>bootstrap resampling of inter-quartile range differences</i> in order to arrive at a test
   * for inequality or variability.
   *
   * <p><b>Example:</b>
   *
   * <table>
   * <td class="PRE">
   * <pre>
   * // v1,v2 - the two samples to compare against each other
   * double[] v1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9,10,  21,  22,23,24,25,26,27,28,29,30,31};
   * double[] v2 = {10,11,12,13,14,15,16,17,18,19,  20,  30,31,32,33,34,35,36,37,38,39};
   * hep.aida.bin.DynamicBin1D X = new hep.aida.bin.DynamicBin1D();
   * hep.aida.bin.DynamicBin1D Y = new hep.aida.bin.DynamicBin1D();
   * X.addAllOf(new cern.colt.list.DoubleArrayList(v1));
   * Y.addAllOf(new cern.colt.list.DoubleArrayList(v2));
   * cern.jet.random.engine.RandomEngine random = new cern.jet.random.engine.MersenneTwister();
   *
   * // bootstrap resampling of differences of means:
   * BinBinFunction1D diff = new BinBinFunction1D() {
   * &nbsp;&nbsp;&nbsp;public double apply(DynamicBin1D x, DynamicBin1D y) {return x.mean() - y.mean();}
   * };
   *
   * // bootstrap resampling of differences of medians:
   * BinBinFunction1D diff = new BinBinFunction1D() {
   * &nbsp;&nbsp;&nbsp;public double apply(DynamicBin1D x, DynamicBin1D y) {return x.median() - y.median();}
   * };
   *
   * // bootstrap resampling of differences of inter-quartile ranges:
   * BinBinFunction1D diff = new BinBinFunction1D() {
   * &nbsp;&nbsp;&nbsp;public double apply(DynamicBin1D x, DynamicBin1D y) {return (x.quantile(0.75)-x.quantile(0.25)) - (y.quantile(0.75)-y.quantile(0.25)); }
   * };
   *
   * DynamicBin1D boot = X.sampleBootstrap(Y,1000,random,diff);
   *
   * cern.jet.math.Functions F = cern.jet.math.Functions.functions;
   * System.out.println("p-value="+ (boot.aggregate(F.plus, F.greater(0)) / boot.size()));
   * System.out.println("left 90% confidence interval = ("+boot.quantile(0.9) + ",infinity)");
   *
   * -->
   * // bootstrap resampling of differences of means:
   * p-value=0.0080
   * left 90% confidence interval = (-3.571428571428573,infinity)
   *
   * // bootstrap resampling of differences of medians:
   * p-value=0.36
   * left 90% confidence interval = (5.0,infinity)
   *
   * // bootstrap resampling of differences of inter-quartile ranges:
   * p-value=0.5699
   * left 90% confidence interval = (5.0,infinity)
   * </pre>
   * </td>
   * </table>
   *
   * @param other the other bin to compare the receiver against.
   * @param resamples the number of times resampling shall be done.
   * @param randomGenerator a random number generator. Set this parameter to <tt>null</tt> to use a
   *     default random number generator seeded with the current time.
   * @param function a difference function comparing two samples; takes as first argument a sample
   *     of <tt>this</tt> and as second argument a sample of <tt>other</tt>.
   * @return a bootstrap bin holding the results of <tt>function</tt> of each resampling step.
   * @see cern.colt.GenericPermuting#permutation(long,int)
   */
  public synchronized DynamicBin1D sampleBootstrap(
      DynamicBin1D other,
      int resamples,
      cern.jet.random.engine.RandomEngine randomGenerator,
      BinBinFunction1D function) {
    if (randomGenerator == null) randomGenerator = cern.jet.random.Uniform.makeDefaultGenerator();

    // since "resamples" can be quite large, we care about performance and memory
    int maxCapacity = 1000;
    int s1 = size();
    int s2 = other.size();

    // prepare auxiliary bins and buffers
    DynamicBin1D sample1 = new DynamicBin1D();
    cern.colt.buffer.DoubleBuffer buffer1 = sample1.buffered(Math.min(maxCapacity, s1));

    DynamicBin1D sample2 = new DynamicBin1D();
    cern.colt.buffer.DoubleBuffer buffer2 = sample2.buffered(Math.min(maxCapacity, s2));

    DynamicBin1D bootstrap = new DynamicBin1D();
    cern.colt.buffer.DoubleBuffer bootBuffer = bootstrap.buffered(Math.min(maxCapacity, resamples));

    // resampling steps
    for (int i = resamples; --i >= 0; ) {
      sample1.clear();
      sample2.clear();

      this.sample(s1, true, randomGenerator, buffer1);
      other.sample(s2, true, randomGenerator, buffer2);

      bootBuffer.add(function.apply(sample1, sample2));
    }
    bootBuffer.flush();
    return bootstrap;
  }
  /**
   * Randomly permutes the part of the receiver between <code>from</code> (inclusive) and <code>to
   * </code> (inclusive).
   *
   * @param from the index of the first element (inclusive) to be permuted.
   * @param to the index of the last element (inclusive) to be permuted.
   * @exception IndexOutOfBoundsException index is out of range ( <tt>size()&gt;0 && (from&lt;0 ||
   *     from&gt;to || to&gt;=size())</tt> ).
   */
  public void shuffleFromTo(int from, int to) {
    // overridden for performance only.
    if (size == 0) {
      return;
    }
    checkRangeFromTo(from, to, size);

    cern.jet.random.Uniform gen =
        new cern.jet.random.Uniform(new cern.jet.random.engine.DRand(new java.util.Date()));
    short tmpElement;
    short[] theElements = elements;
    int random;
    for (int i = from; i < to; i++) {
      random = gen.nextIntFromTo(i, to);

      // swap(i, random)
      tmpElement = theElements[random];
      theElements[random] = theElements[i];
      theElements[i] = tmpElement;
    }
  }
Exemple #6
0
  /**
   * Uniformly samples (chooses) <tt>n</tt> random elements <i>with or without replacement</i> from
   * the contained elements and adds them to the given buffer. If the buffer is connected to a bin,
   * the effect is that the chosen elements are added to the bin connected to the buffer. Also see
   * {@link #buffered(int) buffered}.
   *
   * @param n the number of elements to choose.
   * @param withReplacement <tt>true</tt> samples with replacement, otherwise samples without
   *     replacement.
   * @param randomGenerator a random number generator. Set this parameter to <tt>null</tt> to use a
   *     default random number generator seeded with the current time.
   * @param buffer the buffer to which chosen elements will be added.
   * @throws IllegalArgumentException if <tt>!withReplacement && n > size()</tt>.
   * @see cern.jet.random.sampling
   */
  public synchronized void sample(
      int n,
      boolean withReplacement,
      RandomEngine randomGenerator,
      cern.colt.buffer.DoubleBuffer buffer) {
    if (randomGenerator == null) randomGenerator = cern.jet.random.Uniform.makeDefaultGenerator();
    buffer.clear();

    if (!withReplacement) { // without
      if (n > size()) throw new IllegalArgumentException("n must be less than or equal to size()");
      cern.jet.random.sampling.RandomSamplingAssistant sampler =
          new cern.jet.random.sampling.RandomSamplingAssistant(n, size(), randomGenerator);
      for (int i = n; --i >= 0; ) {
        if (sampler.sampleNextElement()) buffer.add(this.elements.getQuick(i));
      }
    } else { // with
      cern.jet.random.Uniform uniform = new cern.jet.random.Uniform(randomGenerator);
      int s = size();
      for (int i = n; --i >= 0; ) {
        buffer.add(this.elements.getQuick(uniform.nextIntFromTo(0, s - 1)));
      }
      buffer.flush();
    }
  }
Exemple #7
0
 public static void main(String[] arguments) throws Exception {
   int rng_seed = cern.jet.random.Uniform.staticNextIntFromTo(0, Integer.MAX_VALUE); // 3;
   // analyze_accuracy_NHBS(rng.nextInt());
   List<DrugUser> synthPop = make_from_NEP(40000, rng_seed);
   System.out.println("\nLeaving APK-SynthPop");
 }
 @Override
 public double nextDoubleUniform(double min, double max) {
   return uniform.nextDoubleFromTo(min, max);
 }
 @Override
 public int nextIntBetween(int min, int max) {
   return uniform.nextIntFromTo(min, max);
 }
 @Override
 public double nextDoubleUniform() {
   return uniform.nextDouble();
 }
  /**
   * Rain clouds appear with a certain chance, influenced by the weather For every rain cloud in the
   * grid the velocity of every rain object is updated Rain clouds are removed if they have passed a
   * certain time
   */
  @ScheduledMethod(start = 1, interval = 1, priority = 0)
  public void rain() {
    // Let new raingroups appear with a certain chance
    double chance = SimulationParameters.rainProb;
    // The probability of rain appearing decreases if there is already rain in the grid
    if (noRainGroups == 1) chance = (chance / (noRainGroups)) * 0.5;
    if (noRainGroups == 2) chance = (chance / (noRainGroups)) * 0.1;
    if (noRainGroups > 2) chance = (chance / (noRainGroups)) * 0.01;
    double f = urng.nextDouble();
    if (f < chance) {
      // Let rain appear
      int x = rand.nextInt((SimulationParameters.gridSize - 0) + 1);
      int y = rand.nextInt((SimulationParameters.gridSize - 0) + 1);
      int[] newLoc = {x, y};
      // Let new raingroup appear in random location
      RainGroup rg = new RainGroup(ContextUtils.getContext(this), grid, newLoc);
      noRainGroups++;
      rainGroups.add(rg);
    }

    ArrayList<RainGroup> toRemove = new ArrayList<RainGroup>();
    for (RainGroup rg : rainGroups) {
      // Get velocity vector of the rain
      float x = Wind.getWindVelocity().x;
      float y = Wind.getWindVelocity().y;
      Vector2 velRain = new Vector2(x, y);
      velRain.setLength(
          Wind.getWindVelocity().len() * 0.9f); // Rain speed is a bit lower than that of the wind

      List<Rain> toRemove1 = new ArrayList<Rain>();
      // Let rain be carried by the wind
      if (urng.nextDouble() < velRain.len()) {
        for (Rain rain : rg.getRainObjects()) {
          Directions dir = Directions.fromVectorToDir(velRain);
          GridPoint pt = grid.getLocation(rain);
          int cX = pt.getX() + dir.xDiff;
          int cY = pt.getY() + dir.yDiff;

          // If new rain-location is out of borders, delete this rain object
          // In this way the cloud "travels" out of the grid
          if (cX < 0
              || cX >= SimulationParameters.gridSize
              || cY < 0
              || cY >= SimulationParameters.gridSize) {
            toRemove1.add(rain);
          } else grid.moveTo(rain, cX, cY);
        }
      }

      for (Rain r : toRemove1) {
        rg.removeRain(r);
        TreeBuilder.performance.decreaseRainCount();
      }
    }

    // Remove the raingroups from our list which were removed from the context
    for (RainGroup rg : toRemove) {
      rainGroups.remove(rg);
      noRainGroups--;
    }
  }
Exemple #12
0
  @Override
  public Double[] crossoverSBX(Uniform U, Object genesA, Object genesB) {

    Double gA = (Double) genesA;
    Double gB = (Double) genesB;

    if (U.nextDoubleFromTo(0, 1) < 0.5) {
      double rand;
      double y1, y2, yl, yu;
      double c1, c2;
      double alpha, beta, betaq;

      if (StrictMath.abs(gA - gB) > EPS) {
        if (gA < gB) {
          y1 = gA;
          y2 = gB;
        } else {
          y1 = gB;
          y2 = gA;
        }

        yl = min;
        yu = max;
        rand = U.nextDoubleFromTo(0, 1);
        beta = 1.0 + (2.0 * (y1 - yl) / (y2 - y1));
        alpha = 2.0 - StrictMath.pow(beta, -(eta_c + 1.0));

        if (rand <= (1.0 / alpha)) {
          betaq = StrictMath.pow((rand * alpha), (1.0 / (eta_c + 1.0)));
        } else {
          betaq = StrictMath.pow((1.0 / (2.0 - rand * alpha)), (1.0 / (eta_c + 1.0)));
        }

        c1 = 0.5 * ((y1 + y2) - betaq * (y2 - y1));
        beta = 1.0 + (2.0 * (yu - y2) / (y2 - y1));
        alpha = 2.0 - StrictMath.pow(beta, -(eta_c + 1.0));

        if (rand <= (1.0 / alpha)) {
          betaq = StrictMath.pow((rand * alpha), (1.0 / (eta_c + 1.0)));
        } else {
          betaq = StrictMath.pow((1.0 / (2.0 - rand * alpha)), (1.0 / (eta_c + 1.0)));
        }

        c2 = 0.5 * ((y1 + y2) + betaq * (y2 - y1));

        if (c1 < yl) c1 = yl;
        if (c2 < yl) c2 = yl;
        if (c1 > yu) c1 = yu;
        if (c2 > yu) c2 = yu;

        if (U.nextDoubleFromTo(0, 1) <= 0.5) {
          return new Double[] {c2, c1};
        } else {
          return new Double[] {c1, c2};
        }
      } else {
        if (U.nextDoubleFromTo(0, 1) <= 0.5) {
          return new Double[] {gA, gB};
        } else {
          return new Double[] {gB, gA};
        }
      }
    } else {
      return new Double[] {gA, gB};
    }
  }
Exemple #13
0
 @Override
 public Double generateRandomnly(Uniform uniform) {
   return uniform.nextDoubleFromTo(min, max);
 }