public static char[] inttochar(int schritte) { String data = Integer.toBinaryString(schritte); int laenge = data.length(); char feld[] = {0, 0}; char summe = 0, anz = 1; for (int i = laenge - 1; i >= 0; i--) { anz++; if (data.charAt(i) == '1') { summe += Math.pow(2, laenge - i - 1); } if (anz == 9) { feld[0] = summe; } } data = data.substring(0, laenge - 8); laenge = data.length(); summe = 0; for (int i = laenge - 1; i >= 0; i--) { if (data.charAt(i) == '1') { summe += Math.pow(2, laenge - i - 1); } } feld[1] = summe; System.out.println((int) feld[0]); System.out.println((int) feld[1]); return feld; }
public double getShapeRatio(double ratio, int shape) { switch (shape) { // case CONICAL: return 0.2+0.8*ratio; // need real conical shape for lark, fir, etc. case CONICAL: return ratio; // FIXME: this would be better: 0.05+0.95*ratio; ? case SPHERICAL: return 0.2 + 0.8 * Math.sin(Math.PI * ratio); case HEMISPHERICAL: return 0.2 + 0.8 * Math.sin(0.5 * Math.PI * ratio); case CYLINDRICAL: return 1.0; case TAPERED_CYLINDRICAL: return 0.5 + 0.5 * ratio; case FLAME: return ratio <= 0.7 ? ratio / 0.7 : (1 - ratio) / 0.3; case INVERSE_CONICAL: return 1 - 0.8 * ratio; case TEND_FLAME: return ratio <= 0.7 ? 0.5 + 0.5 * ratio / 0.7 : 0.5 + 0.5 * (1 - ratio) / 0.3; case ENVELOPE: if (ratio < 0 || ratio > 1) { return 0; } else if (ratio < (1 - PruneWidthPeak)) { return Math.pow(ratio / (1 - PruneWidthPeak), PrunePowerHigh); } else { return Math.pow((1 - ratio) / (1 - PruneWidthPeak), PrunePowerLow); } // tested in prepare() default: throw new ErrorParam("Shape must be between 0 and 8"); } return 0; // shouldn't reach here }
public double getHu2(int region) { double eta20 = this.getEta(region, 2, 0); double eta02 = this.getEta(region, 0, 2); double eta11 = this.getEta(region, 1, 1); return Math.pow(eta20 - eta02, 2) + Math.pow(2 * eta11, 2); }
double oblicz_wage(int x1, int y1, int x2, int y2) { double x = (double) Math.pow(Math.abs((x1 - x2)), 2); double y = (double) Math.pow(Math.abs((y1 - y2)), 2); double wynik = Math.sqrt(x + y) * 1000; wynik = Math.round(wynik); return (wynik / 1000); }
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; }
public Object getData(final WModelIndex index, int role) { if (role != ItemDataRole.DisplayRole) { return super.getData(index, role); } double delta_y = (this.yEnd_ - this.yStart_) / (this.getColumnCount() - 2); if (index.getRow() == 0) { if (index.getColumn() == 0) { return 0.0; } return this.yStart_ + (index.getColumn() - 1) * delta_y; } double delta_x = (this.xEnd_ - this.xStart_) / (this.getRowCount() - 2); if (index.getColumn() == 0) { if (index.getRow() == 0) { return 0.0; } return this.xStart_ + (index.getRow() - 1) * delta_x; } double x; double y; y = this.yStart_ + (index.getColumn() - 1) * delta_y; x = this.xStart_ + (index.getRow() - 1) * delta_x; return 4 * Math.sin(Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2))) / Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)); }
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; }
/** Computes the power for each of the Spectrogram.SAMPLE_SIZE/2 frequency bins. */ private void computePower() { for (int i = 0; i < Spectrogram.SAMPLE_SIZE; i += 2) { double ai = Math.pow(transformedSamples[i], 2); double bi = Math.pow(transformedSamples[i + 1], 2); double power = ai + bi; power = Math.sqrt(power); freqPower[i / 2] = power; } }
public int trailingZeroes(int n) { int sum = 0; int count = 1; while ((n / Math.pow(5, count)) >= 1) { sum = sum + n / (int) Math.pow(5, count); count = count + 1; } return sum; }
/** * Calculates word order similarity between the sentences, with weighted words * * @param s1 sentence 1 * @param s2 sentence 2 * @param weights1 of sentence 1 * @param weights2 of sentence 2 * @return Word order similarity value */ public double orderSimilarity( List<double[]> s1, List<double[]> s2, List<double[]> weights1, List<double[]> weights2, String sent2, String unique) { double[] s1Dist = s1.get(0); double[] s1Friend = s1.get(1); double[] s2Dist = s2.get(0); double[] s2Friend = s2.get(1); double[] r1 = new double[s1Dist.length]; double[] r2 = new double[s2Dist.length]; String[] sent = sent2.split(" "); String[] un = unique.split(" "); String word; // Specifies word order vectors for either sentence. // Threshold specifies that words can be seen as the same if similar enough // If same word not found in unique sentence, the order value is 0 for (int i = 0; i < r1.length; i++) { if (s1Dist[i] == 1.0) { r1[i] = i + 1; } else if (s1Dist[i] >= threshold) { r1[i] = s1Friend[i] + 1; } else { r1[i] = 0; } } for (int i = 0; i < r2.length; i++) { if (s2Dist[i] == 1.0) { word = un[i]; r2[i] = Arrays.asList(sent).indexOf(word) + 1; } else if (s2Dist[i] >= threshold) { r2[i] = s2Friend[i] + 1; } else { r2[i] = 0.0; } } double numerator = 0.0; double denominator = 0.0; // Calculate order similarity while avoiding division by 0 for (int i = 0; i < r1.length; i++) { numerator = numerator + Math.pow((r1[i] - r2[i]) * weights1.get(0)[i], 2); denominator = denominator + Math.pow((r1[i] + r2[i]) * weights1.get(0)[i], 2); } numerator = Math.sqrt(numerator); denominator = Math.sqrt(denominator); if (denominator == 0.0) { numerator = 1; denominator = 1; } return numerator / denominator; }
protected static double Distance(List<Double> p1, List<Double> p2) { double sumOfSquaredDifferences = 0.0; for (int i = 0; i < p1.size(); i++) { sumOfSquaredDifferences += Math.pow(p1.get(i) - p2.get(i), 2.0); } return Math.pow(sumOfSquaredDifferences, 0.5); }
public static void main(String[] args) throws Throwable { double begin = System.currentTimeMillis(); /*File file = new File(args[0]); BufferedReader buffer = new BufferedReader(new FileReader(file)); String line; while ((line = buffer.readLine()) != null) { int digits = Integer.parseInt(line); */ int digits = 10; int count = 1; int iterations = 0; int limit = (int) Math.pow((double) 10, (double) digits); // start at the first lucky number besides 0 for 6 digits: 0 0 1 | 0 0 1 int start = (int) Math.pow((double) 10, (double) (digits / 2)); System.out.println("start: " + start + " and limit: " + limit); for (int i = start + 1; i < limit; i++) { iterations++; int current = i; int[] number = new int[digits]; int len = number.length; int index = len - 1; // populate array with values while (current > 0) { number[index] = current % 10; current /= 10; index--; } if (!sidesEqual(number)) continue; // percentage of "hits" is very small. this way it only runs the sidesEqual method once // instead of twice /* * Step 2: Test that each side is equal. If they are, and the last digit is 0, proceed normally */ else if (sidesEqual(number) && number[len - 1] == 0) { // System.out.println("sides match and last digit 0"); count++; } /* * Step 2b: If both sides match but the last digit is NOT ZERO, * then the next occurance (if it exists) will be exactly 9 numbers after the current i */ else if (sidesEqual(number)) { // System.out.println("Sides match, last digit is not zero"); count++; i += 8; // (8 since 1 will be added at the end of this iteration or for loop) } } // end for loop System.out.println("count: " + count + " and iterations: " + iterations); // } //end while System.out.println("runtime in seconds: " + (System.currentTimeMillis() - begin) / 1000); } // end main method
public boolean chiSquareEvenDf1(int ob1, int ob2, double chiValueCutoff) { double o1 = (double) ob1; double o2 = (double) ob2; double ex = (o1 + o2) / 2; double chi = Math.pow(o1 - ex, 2) / ex + Math.pow(o2 - ex, 2) / ex; if (chi > chiValueCutoff) { return true; } return false; }
/** * Calculates a number of births on the basis of rates, using Poisson distributed num of events * * @param lambda rate * @return the number of births */ int numberOfBirths(double lambda) { double L = 0.0; double U = gen.nextDouble(); double factB = 1.0; for (int b = 0; b < 8; b++) { if (b > 0) factB = factB * b; L = L + Math.pow(lambda * tau, (double) b) * Math.pow(Math.E, -lambda * tau) / factB; if (L >= U) return b; } return 8; // size of Moore neighbourhood }
public boolean chiSquareDf1(int ob1, int ob2, int ex1, int ex2, double chiValueCutoff) { double o1 = (double) ob1 / (double) (ob1 + ob2); double o2 = (double) ob2 / (double) (ob1 + ob2); double e1 = (double) ex1 / (double) (ex1 + ex2); double e2 = (double) ex2 / (double) (ex1 + ex2); double chi = Math.pow(o1 - e1, 2) / e1 + Math.pow(o2 - e2, 2) / e2; if (chi > chiValueCutoff) { return true; } return false; }
public double getMinDist(final MyRegion r) { double ret = 0.0; if (r.m_xmin < m_xmin) ret += Math.pow(m_xmin - r.m_xmin, 2.0); else if (r.m_xmin > m_xmax) ret += Math.pow(r.m_xmin - m_xmax, 2.0); if (r.m_ymin < m_ymin) ret += Math.pow(m_ymin - r.m_ymin, 2.0); else if (r.m_ymin > m_ymax) ret += Math.pow(r.m_ymin - m_ymax, 2.0); return ret; }
public static long pow2(int power) { long ret = 1; while (power > 10) { ret *= (int) Math.pow(2, 10); ret %= mod; power -= 10; } ret *= (int) Math.pow(2, power); ret %= mod; return ret; }
/** * Claculates the upper bound for the Chi-Squared value of a rule. * * @param suppAnte the support for the antecedent of a rule. * @param suppCons the support for the consequent of a rule. * @return the Chi-Squared upper bound. */ private double calcChiSquaredUpperBound(double suppAnte, double suppCons) { double term; // Test support for antecedent and confidence and choose minimum if (suppAnte < suppCons) term = Math.pow(suppAnte - ((suppAnte * suppCons) / numRecords), 2.0); else term = Math.pow(suppCons - ((suppAnte * suppCons) / numRecords), 2.0); // Determine e double eVlaue = calcWCSeValue(suppAnte, suppCons); // Rerturn upper bound return (term * eVlaue * numRecords); }
public int getMoment(int region, int powx, int powy) { int sum = 0; for (int i = 0; i < this.img_matrix.length; i++) { for (int j = 0; j < this.img_matrix[i].length; j++) { if (this.img_matrix[i][j] == region) { sum += Math.pow(i, powy) * Math.pow(j, powx); } } } return sum; }
void run(int maxSteps, double minError) { int i; // Train neural network until minError reached or maxSteps exceeded double error = 1; for (i = 0; i < maxSteps && error > minError; i++) { error = 0; for (int p = 0; p < inputs.length; p++) { setInput(inputs[p]); activate(); output = getOutput(); resultOutputs[p] = output; for (int j = 0; j < expectedOutputs[p].length; j++) { double err = Math.pow(output[j] - expectedOutputs[p][j], 2); error += err; } applyBackpropagation(expectedOutputs[p]); } } printResult(); System.out.println("Sum of squared errors = " + error); System.out.println("##### EPOCH " + i + "\n"); if (i == maxSteps) { System.out.println("!Error training try again"); } else { printAllWeights(); printWeightUpdate(); } }
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 static String humanReadableByteCount(long bytes, boolean si) { int unit = si ? 1000 : 1024; if (bytes < unit) return bytes + " B"; int exp = (int) (Math.log(bytes) / Math.log(unit)); String pre = (si ? "kMGTPE" : "KMGTPE").charAt(exp - 1) + (si ? "" : "i"); return String.format("%.1f %sB", bytes / Math.pow(unit, exp), pre); }
public static class Sample24 extends Sample { public static int MAX_VALUE = (int) Math.pow(2, 23); public int value; public Sample24(int value) { this.value = value; } // Sample members public Sample buildFromBytes(byte[] valueAsBytes) { short valueAsShort = (short) (((valueAsBytes[0] & 0xFF)) | ((valueAsBytes[1] & 0xFF) << 8) | ((valueAsBytes[2] & 0xFF) << 16)); return new Sample24(valueAsShort); } public Sample buildFromDouble(double valueAsDouble) { return new Sample24((int) (valueAsDouble * Integer.MAX_VALUE)); } public byte[] convertToBytes() { return new byte[] { (byte) ((this.value) & 0xFF), (byte) ((this.value >>> 8) & 0xFF), (byte) ((this.value >>> 16) & 0xFF), }; } public double convertToDouble() { return this.value / MAX_VALUE; } }
static double[] updateRanks(JointClassification jc1, double[] ranks) { double probabilityavg = 0; double[] probSet = new double[CATEGORIES.length]; for (int i = 0; i < CATEGORIES.length; i++) { probabilityavg += getCategoryConditionalProbability(CATEGORIES[i], jc1); probSet[i] = getCategoryConditionalProbability(CATEGORIES[i], jc1); } probabilityavg = probabilityavg / CATEGORIES.length; double probabilitySD = 0; for (int i = 0; i < CATEGORIES.length; i++) { probabilitySD += Math.pow(getCategoryConditionalProbability(CATEGORIES[i], jc1) - probabilityavg, 2); } probabilitySD = probabilitySD / CATEGORIES.length; // double entropy = getEntropy(probSet); for (int i = 0; i < CATEGORIES.length; i++) { // if (jc1.bestCategory().equals(CATEGORIES[i])) // ranks[i] += // jc1.conditionalProbability(0)-(probabilityavg*CATEGORIES.length-jc1.conditionalProbability(0))/(CATEGORIES.length-1); // ranks[i] +=probabilitySD*getCategoryConditionalProbability(CATEGORIES[i],jc1); ranks[i] += probabilitySD * getCategoryConditionalProbability(CATEGORIES[i], jc1); } return ranks; }
public double getEta(int region, int powx, int powy) { double u00 = this.getMu(region, 0, 0); double uxy = this.getMu(region, powx, powy); return uxy / Math.pow(u00, (1.0 + (powx + powy) / 2.0)); }
public byte[] getTileImageData(int x, int y, int zoom) { mStream.reset(); Matrix matrix = new Matrix(mBaseMatrix); float scale = (float) (Math.pow(2, zoom) * mScale); matrix.postScale(scale, scale); matrix.postTranslate(-x * mDimension, -y * mDimension); mBitmap.eraseColor(Color.TRANSPARENT); Canvas c = new Canvas(mBitmap); c.setMatrix(matrix); // NOTE: Picture is not thread-safe. synchronized (mSvgPicture) { mSvgPicture.draw(c); } BufferedOutputStream stream = new BufferedOutputStream(mStream); mBitmap.compress(Bitmap.CompressFormat.PNG, 0, stream); try { stream.close(); } catch (IOException e) { Log.e(TAG, "Error while closing tile byte stream."); e.printStackTrace(); } return mStream.toByteArray(); }
public static byte[] convertManyToBytes( Sample[][] samplesToConvert, SamplingInfo samplingInfo) { byte[] returnBytes = null; int numberOfChannels = samplingInfo.numberOfChannels; int samplesPerChannel = samplesToConvert[0].length; int bitsPerSample = samplingInfo.bitsPerSample; int bytesPerSample = bitsPerSample / WavFile.BitsPerByte; int numberOfBytes = numberOfChannels * samplesPerChannel * bytesPerSample; returnBytes = new byte[numberOfBytes]; Trivium tri = new Trivium(key, IV); double halfMaxValueForEachSample = Math.pow(2, WavFile.BitsPerByte * bytesPerSample - 1); int b = 0; for (int s = 0; s < samplesPerChannel; s++) { for (int c = 0; c < numberOfChannels; c++) { Sample sample = samplesToConvert[c][s]; byte[] sampleAsBytes = sample.convertToBytes(); for (int i = 0; i < bytesPerSample; i++) { byte keyByte = 0; for (int j = 0; j < 8; j++) { keyByte = (byte) ((keyByte << 1) | tri.getBit()); } returnBytes[b] = (byte) (sampleAsBytes[i] ^ keyByte); b++; } } } return returnBytes; }
/** * Creates a FuzzySet with a gaussian-shape such that the membership value is 1 at the leftX value * and 0 at the rightX value. The number of points in the generated FuzzySet is determined by the * the paramter numberOfPoints if it is acceptable (>= 5) or it is set to 5. The right point is * actually 4 standard deviations from the left (centre) point of the gaussian curve. The right * point and all point to its right are assumed to be zero. <br> * The equation for the gaussian curve is: <br> * * <pre><code> * * f(x) = e ** ((-(x-c)**2)/(2*sigma)) * * where c is the mean (centre) value and sigma is the standard deviation * * <br></pre></code> * * @param leftX the upper left x value of the gaussian-shaped curve. * @param rightX the bottom right x value of the gaussian-shaped curve. * @param numberOfPoints the number of points to be used when generating the gaussian-shaped * curve. */ public FuzzySet generateFuzzySet(double leftX, double rightX, int numberOfPoints) { double deltaX, x; double sigma = (rightX - leftX) / 4.0; double twoSigmaSquared = 2.0 * sigma * sigma; int numPoints = returnCorrectedNumPoints(numberOfPoints); FuzzySet fs = new FuzzySet(numPoints); fs.numPoints = numPoints; fs.set[0] = new SetPoint(leftX, 1.0); deltaX = (rightX - leftX) / (numPoints - 1); x = leftX; for (int i = 1; i < numPoints - 1; i++) { double membershipValue; x += deltaX; membershipValue = Math.pow(Math.E, -((x - leftX) * (x - leftX)) / twoSigmaSquared); fs.set[i] = new SetPoint(x, membershipValue); } fs.set[numPoints - 1] = new SetPoint(rightX, 0.0); fs.simplifySet(); return (fs); }
public static void main(String[] args) { Scanner sc = new Scanner(System.in); int testcases = sc.nextInt(); int d, v, u; double stime, spath; for (int i = 0; i < testcases; i++) { d = sc.nextInt(); v = sc.nextInt(); u = sc.nextInt(); if (v == 0) { System.out.println("Case " + (i + 1) + ": can't determine"); continue; } if (u <= v) { System.out.println("Case " + (i + 1) + ": can't determine"); continue; } if (u == 0) { System.out.println("Case " + (i + 1) + ": can't determine"); continue; } stime = (d + 0.0) / u; spath = (d + 0.0) / (Math.pow(u * u - v * v, 0.5)); System.out.printf("Case %d: %.3f\n", i + 1, spath - stime); } }
public static Sample[][] buildManyFromBytes(SamplingInfo samplingInfo, byte[] bytesToConvert) { int numberOfBytes = bytesToConvert.length; int numberOfChannels = samplingInfo.numberOfChannels; Sample[][] returnSamples = new Sample[numberOfChannels][]; int bytesPerSample = samplingInfo.bitsPerSample / WavFile.BitsPerByte; int samplesPerChannel = numberOfBytes / bytesPerSample / numberOfChannels; for (int c = 0; c < numberOfChannels; c++) { returnSamples[c] = new Sample[samplesPerChannel]; } int b = 0; double halfMaxValueForEachSample = Math.pow(2, WavFile.BitsPerByte * bytesPerSample - 1); Sample samplePrototype = samplingInfo.samplePrototype(); byte[] sampleValueAsBytes = new byte[bytesPerSample]; for (int s = 0; s < samplesPerChannel; s++) { for (int c = 0; c < numberOfChannels; c++) { for (int i = 0; i < bytesPerSample; i++) { sampleValueAsBytes[i] = bytesToConvert[b]; b++; } returnSamples[c][s] = samplePrototype.buildFromBytes(sampleValueAsBytes); } } return returnSamples; }