private void adjustDateLineCrossingPoints() {
ArrayList<LatLon> corners = new ArrayList<LatLon>(Arrays.asList(sw, se, nw, ne));
if (!LatLon.locationsCrossDateLine(corners)) return;
double lonSign = 0;
for (LatLon corner : corners) {
if (Math.abs(corner.getLongitude().degrees) != 180)
lonSign = Math.signum(corner.getLongitude().degrees);
}
if (lonSign == 0) return;
if (Math.abs(sw.getLongitude().degrees) == 180
&& Math.signum(sw.getLongitude().degrees) != lonSign)
sw = new Position(sw.getLatitude(), sw.getLongitude().multiply(-1), sw.getElevation());
if (Math.abs(se.getLongitude().degrees) == 180
&& Math.signum(se.getLongitude().degrees) != lonSign)
se = new Position(se.getLatitude(), se.getLongitude().multiply(-1), se.getElevation());
if (Math.abs(nw.getLongitude().degrees) == 180
&& Math.signum(nw.getLongitude().degrees) != lonSign)
nw = new Position(nw.getLatitude(), nw.getLongitude().multiply(-1), nw.getElevation());
if (Math.abs(ne.getLongitude().degrees) == 180
&& Math.signum(ne.getLongitude().degrees) != lonSign)
ne = new Position(ne.getLatitude(), ne.getLongitude().multiply(-1), ne.getElevation());
}
private int wrapPositionForTabbedTextWithOptimization(
@NotNull CharSequence text,
int tabSize,
int startLineOffset,
int endLineOffset,
int targetRangeEndOffset) {
int width = 0;
int symbolWidth;
int result = Integer.MAX_VALUE;
boolean wrapLine = false;
for (int i = startLineOffset; i < Math.min(endLineOffset, targetRangeEndOffset); i++) {
char c = text.charAt(i);
switch (c) {
case '\t':
symbolWidth = tabSize - (width % tabSize);
break;
default:
symbolWidth = 1;
}
if (width + symbolWidth + FormatConstants.RESERVED_LINE_WRAP_WIDTH_IN_COLUMNS
>= mySettings.RIGHT_MARGIN
&& (Math.min(endLineOffset, targetRangeEndOffset) - i)
>= FormatConstants.RESERVED_LINE_WRAP_WIDTH_IN_COLUMNS) {
// Remember preferred position.
result = i - 1;
}
if (width + symbolWidth >= mySettings.RIGHT_MARGIN) {
wrapLine = true;
break;
}
width += symbolWidth;
}
return wrapLine ? result : -1;
}
/*
* We completed handling of a filtered block. Update false-positive estimate based
* on the total number of transactions in the original block.
*
* count includes filtered transactions, transactions that were passed in and were relevant
* and transactions that were false positives (i.e. includes all transactions in the block).
*/
protected void trackFilteredTransactions(int count) {
// Track non-false-positives in batch. Each non-false-positive counts as
// 0.0 towards the estimate.
//
// This is slightly off because we are applying false positive tracking before non-FP tracking,
// which counts FP as if they came at the beginning of the block. Assuming uniform FP
// spread in a block, this will somewhat underestimate the FP rate (5% for 1000 tx block).
double alphaDecay = Math.pow(1 - FP_ESTIMATOR_ALPHA, count);
// new_rate = alpha_decay * new_rate
falsePositiveRate = alphaDecay * falsePositiveRate;
double betaDecay = Math.pow(1 - FP_ESTIMATOR_BETA, count);
// trend = beta * (new_rate - old_rate) + beta_decay * trend
falsePositiveTrend =
FP_ESTIMATOR_BETA * count * (falsePositiveRate - previousFalsePositiveRate)
+ betaDecay * falsePositiveTrend;
// new_rate += alpha_decay * trend
falsePositiveRate += alphaDecay * falsePositiveTrend;
// Stash new_rate in old_rate
previousFalsePositiveRate = falsePositiveRate;
}
public Unit() {
trm = (Math.random() * 10) - 5;
prm = (Math.random() * 10) - 5;
wtm = (Math.random() * 10) - 5;
tkm = (Math.random() * 10) - 5;
ped = (Math.random() * 5) + 5;
}
// Returns the distance between two planets, rounded up to the next highest
// integer. This is the number of discrete time steps it takes to get
// between the two planets.
public int Distance(int sourcePlanet, int destinationPlanet) {
Planet source = planets.get(sourcePlanet);
Planet destination = planets.get(destinationPlanet);
double dx = source.X() - destination.X();
double dy = source.Y() - destination.Y();
return (int) Math.ceil(Math.sqrt(dx * dx + dy * dy));
}
public double nextDouble() {
int c = read();
while (isSpaceChar(c)) c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E') return res * Math.pow(10, nextInt());
if (c < '0' || c > '9') throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
if (c == '.') {
c = read();
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E') return res * Math.pow(10, nextInt());
if (c < '0' || c > '9') throw new InputMismatchException();
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
/**
* Given a tissue sample, move all unsatisfied agents to a vacant cell
*
* @param tissue a 2-D character array that has been initialized
* @param threshold the percentage of like agents that must surround the agent to be satisfied
*/
public static int moveAllUnsatisfied(char[][] tissue, int threshold) {
ArrayList<Integer> list2 = new ArrayList<Integer>();
int counter = 0;
ArrayList<Integer> list1 = new ArrayList<Integer>();
for (int i = 0; i < tissue.length; i++) {
for (int x = 0; x < tissue[0].length; x++) {
if (isSatisfied(tissue, i, x, threshold) == false) {
list1.add(i);
list2.add(x);
}
}
}
int num = list1.size();
char temp;
int count = 0;
do {
int rand = (int) (Math.random() * tissue.length);
int random = (int) (Math.random() * tissue.length);
if (tissue[rand][random] == ' ') {
temp = tissue[rand][random];
tissue[rand][random] = tissue[list1.get(counter)][list2.get(counter)];
tissue[list1.get(counter)][list2.get(counter)] = temp;
counter++;
count++;
}
} while (counter != num);
return count;
}
public int[] solve(String[] edgeStrings) {
ArrayList<Integer> oddPoints = new ArrayList<Integer>();
int min = Integer.MAX_VALUE;
for (String s : edgeStrings) {
StringTokenizer st = new StringTokenizer(s);
int from = Integer.parseInt(st.nextToken());
int to = Integer.parseInt(st.nextToken());
edges.add(new Edge(from, to));
min = Math.min(min, from);
min = Math.min(min, to);
oddPoint(oddPoints, from);
oddPoint(oddPoints, to);
}
assert (oddPoints.size() < 3);
if (oddPoints.size() > 0) {
dfs(min(oddPoints));
return toArray(circuit);
} else {
dfs(min);
return toArray(circuit);
}
}
public void paint(Graphics gg) {
int faceSize = Math.min(getWidth() - 4, getHeight() - 4);
if (face == null)
face =
new PADFaceMapped(
Math.max(2, (getWidth() - faceSize) / 2),
Math.max(2, (getHeight() - faceSize) / 2),
faceSize);
if (buffer == null) {
im = this.createImage(getWidth(), getHeight());
buffer = im.getGraphics();
}
super.paint(buffer);
buffer.setColor(new Color(255, 255, 255, 0));
buffer.fillRect(0, 0, im.getWidth(null), im.getHeight(null));
face.setDimensions(
Math.max(2, (getWidth() - faceSize) / 2),
Math.max(2, (getHeight() - faceSize) / 2),
faceSize);
face.paint(buffer);
// draw buffer to screen
gg.drawImage(im, 0, 0, null, null);
}
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);
}
private void renderBlackout(Graphics g, int x, int y, int radius) {
if (radius > 320) return;
int[] xp = new int[20];
int[] yp = new int[20];
for (int i = 0; i < 16; i++) {
xp[i] = x + (int) (Math.cos(i * Math.PI / 15) * radius);
yp[i] = y + (int) (Math.sin(i * Math.PI / 15) * radius);
}
xp[16] = 320;
yp[16] = y;
xp[17] = 320;
yp[17] = 240;
xp[18] = 0;
yp[18] = 240;
xp[19] = 0;
yp[19] = y;
g.fillPolygon(xp, yp, xp.length);
for (int i = 0; i < 16; i++) {
xp[i] = x - (int) (Math.cos(i * Math.PI / 15) * radius);
yp[i] = y - (int) (Math.sin(i * Math.PI / 15) * radius);
}
xp[16] = 320;
yp[16] = y;
xp[17] = 320;
yp[17] = 0;
xp[18] = 0;
yp[18] = 0;
xp[19] = 0;
yp[19] = y;
g.fillPolygon(xp, yp, xp.length);
}
public static void main(String[] args) throws IOException {
input.init(System.in);
PrintWriter out = new PrintWriter(System.out);
int depth = input.nextInt();
int n = (1 << (depth + 1));
int[] as = new int[n];
for (int i = 2; i < n; i++) as[i] = input.nextInt();
int[] paths = new int[n];
int max = 0;
ArrayList<Integer>[] under = new ArrayList[n];
for (int i = 0; i < n; i++) under[i] = new ArrayList<Integer>();
for (int i = (1 << (depth)); i < n; i++) {
int cur = i;
while (cur > 1) {
under[cur].add(i);
paths[i] += as[cur];
cur /= 2;
}
max = Math.max(max, paths[i]);
}
int res = 0;
for (int i = 2; i < n; i++) {
int cm = 0;
for (int x : under[i]) cm = Math.max(cm, paths[x]);
int diff = max - cm;
res += diff;
for (int x : under[i]) paths[x] += diff;
}
out.println(res);
out.close();
}
// evaluate Fisher score of all indexes in current ^ featIndex
private double evaluateFisher(HashSet<Integer> current, int featIndex) {
ArrayList<Integer> d = new ArrayList<Integer>(current);
d.add(featIndex);
ArrayList<ArrayList<Integer>> vectors = new ArrayList<ArrayList<Integer>>();
for (int i = 0; i < getA().get_classes().size(); i++) {
ArrayList<ArrayList<Integer>> cl = getA().features.get(getA().get_classes().get(i));
ArrayList<Integer> tmp = new ArrayList<Integer>();
for (int j = 0; j < cl.size(); j++) {
int sum = 0;
for (int k = 0; k < d.size(); k++) sum += cl.get(j).get(d.get(k));
if (sum == d.size()) tmp.add(1);
else tmp.add(0);
}
vectors.add(tmp);
}
ArrayList<double[]> stats = new ArrayList<double[]>();
int count = 0;
double sum = 0.0;
for (int i = 0; i < vectors.size(); i++) {
double[] res = computeMeanVariance(vectors.get(i));
sum += (vectors.get(i).size() * res[0]);
count += vectors.get(i).size();
stats.add(res);
}
sum = sum / count;
double num = 0.0;
double denom = 0.0;
for (int i = 0; i < stats.size(); i++) {
num += (vectors.get(i).size() * Math.pow(stats.get(i)[0] - sum, 2));
denom += (vectors.get(i).size() * Math.pow(stats.get(i)[1], 2));
}
if (denom == 0.0) return 0;
else return num / denom;
}
private String getPercentsTailHelper(BigDecimal percents) {
return ((percents.doubleValue() - Math.floor(percents.doubleValue())) > 0)
? " целых "
+ Math.round((percents.doubleValue() - Math.floor(percents.doubleValue())) * 100)
+ " сотых"
: "";
}
void go3(int x, int y, int v, int at) {
if (at == -1) return;
if (y < a[at] || x > b[at]) return;
val[at] += (Math.min(b[at], y) - Math.max(a[at], x) + 1) * v;
go3(x, y, v, left[at]);
go3(x, y, v, right[at]);
}
public static void main(String[] args) {
Locale[] locales = Locale.getAvailableLocales();
int min = Integer.MAX_VALUE;
int max = Integer.MIN_VALUE;
Map map = new HashMap(locales.length);
int conflicts = 0;
for (int i = 0; i < locales.length; i++) {
Locale loc = locales[i];
int hc = loc.hashCode();
min = Math.min(hc, min);
max = Math.max(hc, max);
Integer key = new Integer(hc);
if (map.containsKey(key)) {
conflicts++;
System.out.println("conflict: " + (Locale) map.get(key) + ", " + loc);
} else {
map.put(key, loc);
}
}
System.out.println(
locales.length
+ " locales: conflicts="
+ conflicts
+ ", min="
+ min
+ ", max="
+ max
+ ", diff="
+ (max - min));
if (conflicts >= (locales.length / 10)) {
throw new RuntimeException(
"too many conflicts: " + conflicts + " per " + locales.length + " locales");
}
}
private boolean isNotSeparatorRoom(Room separatorRoom, Room joinerRoom) {
if (separatorRoom == null) return false;
if (separatorRoom.isRotatable() && separatorRoom != joinerRoom) {
separatorRoom.rotateRightRotatedType();
rotationMap.put(
separatorRoom.getDistance() - Math.abs(separatorRoom.getRotation()), separatorRoom);
return false;
}
if (separatorRoom.isRotatable()
&& separatorRoom == joinerRoom
&& separatorRoom.getExit() != null) {
if (separatorRoom.getRotatedType() == RoomType.TYPE_7) {
separatorRoom.rotateRightRotatedType();
} else if (separatorRoom.getRotatedType() == RoomType.TYPE_8
&& separatorRoom.getEntrance() == Direction.LEFT) {
separatorRoom.rotateLeftRotatedType();
} else if (separatorRoom.getRotatedType() == RoomType.TYPE_8
&& separatorRoom.getEntrance() == Direction.RIGHT) {
separatorRoom.rotateRightRotatedType();
} else if (separatorRoom.getRotatedType() == RoomType.TYPE_9
&& separatorRoom.getEntrance() == Direction.TOP) {
separatorRoom.rotateLeftRotatedType();
} else if (separatorRoom.getRotatedType() == RoomType.TYPE_9
&& separatorRoom.getEntrance() == Direction.LEFT) {
separatorRoom.rotateRightRotatedType();
}
rotationMap.put(
separatorRoom.getDistance() - Math.abs(separatorRoom.getRotation()), separatorRoom);
return false;
}
return true;
}
/**
* The assignInstance method is used to assign the instances to the centroid which is closest to
* them (By squared Euclidean distance
*/
private static void assignInstance(double[][] centroids, double[][] instances, KMeansResult res) {
// for all instances to update centroids
for (int i = 0; i < instances.length; i++) {
// assign each instance to its closest centroid (index starts from 0)
int centerId = -1;
// initially set the distance of two points to be as big as possible
// (which in math is regarded as infinite)
double minDistance = Double.MAX_VALUE;
// loop over centroids
for (int j = 0; j < centroids.length; j++) {
double currDistance = 0;
// dimension
for (int k = 0; k < centroids[j].length; k++) {
currDistance = currDistance + Math.pow(instances[i][k] - centroids[j][k], 2);
}
currDistance = Math.sqrt(currDistance);
if (currDistance < minDistance) {
// update new distance to min distance
minDistance = currDistance;
// update new centroid
centerId = j;
}
}
res.clusterAssignment[i] = centerId;
}
}
public void mouseReleased(MouseEvent e) {
left_mouse_pressed = false;
double kvadrat = Math.sqrt(angleX * angleX + angleY * angleY);
double tempx = angleX / kvadrat;
double tempy = Math.sqrt(1 - tempx * tempx);
if (angleY < 0) tempy = -tempy;
Bullet b = new Bullet();
boolean next = false;
if (type_bullet1 == true && count_sphere > 0) {
b = new Sphere();
count_sphere--;
next = true;
}
if (type_bullet2 == true && count_fireball > 0) {
b = new FireBall();
count_fireball--;
next = true;
}
if (type_bullet3 == true && count_rocket > 0) {
b = new Rocket();
count_rocket--;
next = true;
}
if (next == true) {
b.bullet_x = player.getX() + 52 + 5 * Math.cos(angle); // + 50; //koef;
b.bullet_y = player.getY() + 49 + 5 * Math.sin(angle); // player.getY() + 35; //25;
b.current_direction_x = tempx;
b.current_direction_y = tempy;
bullet.addElement(b);
allow_shoot = false;
}
}
private void bonbakKokatu() {
int b = 0;
int alt;
int zab;
while (b < this.bonbaKop) {
alt = (int) (Math.random() * this.altuera - 1);
zab = (int) (Math.random() * this.zabalera - 1);
if (!(alt + 1 == this.hasAlt || alt - 1 == this.hasAlt)
&& !(zab + 1 == this.hasZab
|| zab - 1 == this.hasZab)) { // If honen baldintza luzea da, hasieran click
// egin dugun posizioaren alboan bonbak ez kokatzeko
if (laukiak[alt][zab] == null) {
laukiak[alt][zab] = new Bonba();
bonbenKoor.add(alt);
bonbenKoor.add(zab);
b++;
} else if (laukiak[alt][zab].banderaDu()) {
laukiak[alt][zab].eskuinClickEgin(alt, zab);
laukiak[alt][zab] = new Bonba();
laukiak[alt][zab].eskuinClickEgin(alt, zab);
bonbenKoor.add(alt);
bonbenKoor.add(zab);
b++;
}
}
}
System.out.println("Bonbak kokatu dira");
}
public void printLoop(int n, float x[], float y[]) {
// Need to swap the y component
Polygon P = new Polygon();
for (int i = 0; i < n; i++) P.addPoint(Math.round(x[i]), Math.round(height - y[i]));
poly_draw.add(P);
poly_draw_color.add(curColor);
}
/**
* Gets the maximum extent of this envelope across all three dimensions.
*
* @return the maximum extent of this envelope
*/
@Override
public double maxExtent() {
if (isNull()) {
return 0.0;
}
return Math.max(getWidth(), Math.max(getHeight(), getDepth()));
}
public static int gainKillExperience(Thing h, Thing t) {
int hlevel = h.getLevel();
int tlevel = t.getLevel();
int killcount = 0;
if (h.isHero()) {
killcount = incKillCount(t);
if (killcount == 1) {
Score.scoreFirstKill(t);
}
}
int base = t.getStat("XPValue");
double xp = base;
xp = xp * Math.pow(experienceDecay, killcount);
xp = xp * Math.pow(experienceLevelMultiplier, tlevel - 1);
// decrease xp gain for killing lower level monsters
if (hlevel > tlevel) xp = xp / (hlevel - tlevel);
int gain = (int) xp;
Hero.gainExperience(gain);
return gain;
}
/** Returns angle in degrees from specified origin to specified destination. */
public static int getAngle(Point origin, Point destination) // origin != destination
{
double distance = getDistance(origin, destination);
int add = 0;
int x = destination.getx() - origin.getx();
int y = origin.gety() - destination.gety(); // Java flips things around
double angleRad = Math.asin(Math.abs(y) / distance);
double angleDeg = Math.toDegrees(angleRad);
if ((x >= 0) && (y >= 0)) // Quadrant 1
{
angleDeg = angleDeg;
}
if ((x < 0) && (y > 0)) // Quadrant 2
{
angleDeg = 180 - angleDeg;
}
if ((x <= 0) && (y <= 0)) // Quadrant 3
{
angleDeg = 180 + angleDeg;
}
if ((x > 0) && (y < 0)) // Quadrant 4
{
angleDeg = 360 - angleDeg;
}
float angleFloat = Math.round(angleDeg);
int angleInt = Math.round(angleFloat);
return (angleInt);
}
/*12. 求二叉树中节点的最大距离
具体分析（http://blog.csdn.net/lalor/article/details/7626678）
即二叉树中相距最远的两个节点之间的距离。
递归解法：
（1）如果二叉树为空，返回0，同时记录左子树和右子树的深度，都为0
（2）如果二叉树不为空，最大距离要么是左子树中的最大距离，要么是右子树中的最大距离，
要么是左子树节点中到根节点的最大距离+右子树节点中到根节点的最大距离，
同时记录左子树和右子树节点中到根节点的最大距离。
*/
public static int getMaxDistance(TreeNode node, int maxLeft, int maxRight) {
// maxLeft, 左子树中的节点距离左子树根节点的最远距离
// maxRight, 右子树中的节点距离左子树根节点的最远距离
if (node == null) {
maxLeft = 0;
maxRight = 0;
return 0;
}
int maxLL = 0, maxLR = 0, maxRL = 0, maxRR = 0;
int maxDistLeft, maxDistRight;
if (node.left != null) {
maxDistLeft = getMaxDistance(node.left, maxLL, maxLR);
maxLeft = Math.max(maxLL, maxLR) + 1;
} else {
maxDistLeft = 0;
maxLeft = 0;
}
if (node.right != null) {
maxDistRight = getMaxDistance(node.right, maxRL, maxRR);
maxRight = Math.max(maxRL, maxRR) + 1;
} else {
maxDistRight = 0;
maxRight = 0;
}
int result = Math.max(Math.max(maxDistLeft, maxDistRight), maxLeft + maxRight + 1);
return result;
}
public static int maxProduct(int[] A) {
if (A.length == 0) {
return 0;
}
if (A.length == 1 && A[0] < 0) {
return A[0];
}
int max_product = 0;
int current_max = 0;
int current_min = 0;
int prev_max = 1;
int prev_min = 1;
for (int i = 0; i < A.length; i++) {
current_max = Math.max(Math.max(prev_max * A[i], prev_min * A[i]), A[i]);
current_min = Math.min(Math.min(prev_max * A[i], prev_max * A[i]), A[i]);
max_product = Math.max(max_product, current_max);
prev_max = current_max;
prev_min = current_min;
}
return max_product;
}
public Trap makeADeprecatedTrap(Environmental unlockThis) {
Trap theTrap = null;
int roll = (int) Math.round(Math.random() * 100.0);
if (unlockThis instanceof Exit) {
if (((Exit) unlockThis).hasADoor()) {
if (((Exit) unlockThis).hasALock()) {
if (roll < 20) theTrap = (Trap) CMClass.getAbility("Trap_Open");
else if (roll < 80) theTrap = (Trap) CMClass.getAbility("Trap_Unlock");
else theTrap = (Trap) CMClass.getAbility("Trap_Enter");
} else {
if (roll < 50) theTrap = (Trap) CMClass.getAbility("Trap_Open");
else theTrap = (Trap) CMClass.getAbility("Trap_Enter");
}
} else theTrap = (Trap) CMClass.getAbility("Trap_Enter");
} else if (unlockThis instanceof Container) {
if (((Container) unlockThis).hasALid()) {
if (((Container) unlockThis).hasALock()) {
if (roll < 20) theTrap = (Trap) CMClass.getAbility("Trap_Open");
else if (roll < 80) theTrap = (Trap) CMClass.getAbility("Trap_Unlock");
else theTrap = (Trap) CMClass.getAbility("Trap_Get");
} else {
if (roll < 50) theTrap = (Trap) CMClass.getAbility("Trap_Open");
else theTrap = (Trap) CMClass.getAbility("Trap_Get");
}
} else theTrap = (Trap) CMClass.getAbility("Trap_Get");
} else if (unlockThis instanceof Item) theTrap = (Trap) CMClass.getAbility("Trap_Get");
return theTrap;
}
public static int distanceLevel(String geohash1, String geohash2, int treeDepth) {
long[] bits1 = decomposeLatLng(geohash1, treeDepth);
long[] bits2 = decomposeLatLng(geohash2, treeDepth);
long latDelta = Math.abs(bits1[1] - bits2[1]);
long lngDelta = Math.abs(bits1[0] - bits2[0]);
return (int) Math.max(latDelta, lngDelta);
}
public static void testTargetFeaturesAgainstImages(
Vector<HaarFeature> features, Vector<IntegralImage> images) {
int numberOfTrue = 0;
int numberOfFalse = 0;
for (IntegralImage ii : images) {
float weightSum = 0.0f;
float sum = 0.0f;
for (HaarFeature hf : features) {
// HaarFeature hf = allFeatures.get(slimFeature.featureNumber);
// hf.threshold = slimFeature.threshold;
float v = hf.weight * ii.evaluateAsClassifier(hf);
sum += v;
weightSum += hf.weight;
}
boolean success = (sum >= weightSum * 0.5f);
// System.out.println("image " + ii.name + " is a " + success + " : " + sum + " > " +
// weightSum*0.5f);
if (success) {
numberOfTrue++;
} else {
numberOfFalse++;
}
}
System.out.println("*************");
System.out.println("true: " + numberOfTrue);
System.out.println("false: " + numberOfFalse);
int min = Math.min(numberOfFalse, numberOfTrue);
int max = Math.max(numberOfFalse, numberOfTrue);
float percentError = min * 100.0f / max;
System.out.println("percentError = " + percentError);
}
public InvisibleStalker() {
super();
Random randomizer = new Random(System.currentTimeMillis());
username = "******";
setDescription("A shimmering blob of energy.");
setDisplayText("An invisible stalker hunts here.");
CMLib.factions().setAlignment(this, Faction.ALIGN_NEUTRAL);
setMoney(0);
basePhyStats.setWeight(10 + Math.abs(randomizer.nextInt() % 10));
baseCharStats().setStat(CharStats.STAT_INTELLIGENCE, 12 + Math.abs(randomizer.nextInt() % 3));
baseCharStats().setStat(CharStats.STAT_STRENGTH, 20);
baseCharStats().setStat(CharStats.STAT_DEXTERITY, 13);
basePhyStats().setDamage(16);
basePhyStats().setSpeed(1.0);
basePhyStats().setAbility(0);
basePhyStats().setLevel(4);
basePhyStats().setArmor(0);
basePhyStats().setDisposition(basePhyStats().disposition() | PhyStats.IS_INVISIBLE);
baseState.setHitPoints(CMLib.dice().roll(basePhyStats().level(), 20, basePhyStats().level()));
addBehavior(CMClass.getBehavior("Aggressive"));
addBehavior(CMClass.getBehavior("Mobile"));
recoverMaxState();
resetToMaxState();
recoverPhyStats();
recoverCharStats();
}