void optimizeForGPIsoScaleLOOMSE() { MultivariateFunction negaLLfunc = generateGPIsoScaleLOOMSE(this); double lambda0 = Math.pow(sigmaN / stdev, 2); double[] pointInit = {Math.log10(lengthes[0]), Math.log10(lambda0)}; double[] dPointInit = {0.01, 0.01}; minimize(negaLLfunc, pointInit, dPointInit); }

public void updateScore() throws Exception { Connection connection = MysqlInfo.getMysqlConnection(); String sql = "select * from repotest"; PreparedStatement stmt = connection.prepareStatement(sql); ResultSet resultSet = stmt.executeQuery(); connection.setAutoCommit(false); while (resultSet.next()) { int repo_id = resultSet.getInt("id"); int hot = resultSet.getInt("hot"); int mature = resultSet.getInt("mature"); int popular = resultSet.getInt("popular"); int nb = resultSet.getInt("nb"); int contributor = (int) Math.min(10, Math.log10(resultSet.getInt("contributor")) * 2.5); int size = (int) Math.min(10, Math.log10(resultSet.getInt("size")) * 2.5); int update = 10; int release = 10; int total = (hot + mature + popular + nb + contributor + size + update + release) / 8; String insertSql = "replace into reposcore values(?,?,?,?,?,?,?,?,?,?)"; stmt = connection.prepareStatement(insertSql); stmt.setInt(1, repo_id); stmt.setInt(2, hot); stmt.setInt(3, mature); stmt.setInt(4, popular); stmt.setInt(5, nb); stmt.setInt(6, contributor); stmt.setInt(7, size); stmt.setInt(8, update); stmt.setInt(9, release); stmt.setInt(10, total); stmt.execute(); } connection.commit(); connection.close(); }

public static Point2D latLongToPixel( final Dimension2D MAP_DIMENSION, final Point2D UPPER_LEFT, final Point2D LOWER_RIGHT, final Point2D LOCATION) { final double LATITUDE = LOCATION.getX(); final double LONGITUDE = LOCATION.getY(); final double MAP_WIDTH = MAP_DIMENSION.getWidth(); final double MAP_HEIGHT = MAP_DIMENSION.getHeight(); final double WORLD_MAP_WIDTH = ((MAP_WIDTH / (LOWER_RIGHT.getY() - UPPER_LEFT.getY())) * 360) / (2 * Math.PI); final double MAP_OFFSET_Y = (WORLD_MAP_WIDTH / 2 * Math.log10( (1 + Math.sin(Math.toRadians(LOWER_RIGHT.getX()))) / (1 - Math.sin(Math.toRadians(LOWER_RIGHT.getX()))))); final double X = (LONGITUDE - UPPER_LEFT.getY()) * (MAP_WIDTH / (LOWER_RIGHT.getY() - UPPER_LEFT.getY())); final double Y = MAP_HEIGHT - ((WORLD_MAP_WIDTH / 2 * Math.log10( (1 + Math.sin(Math.toRadians(LATITUDE))) / (1 - Math.sin(Math.toRadians(LATITUDE))))) - MAP_OFFSET_Y); return new Point2D(X, Y); }

static double matchOrdersOfMagnitude( FrequencyTermBased fFeatureWords, FrequencyTermBased fFeatureRef) { double totalScore = 0, totalWords = 0; for (String t : fFeatureRef.getMapTerm2TTF().keySet()) { totalWords++; totalScore += fFeatureRef.getTTFNorm(t); } double meanRef = totalScore / totalWords; totalScore = 0; totalWords = 0; for (String t : fFeatureWords.getMapTerm2TTF().keySet()) { totalWords++; totalScore += fFeatureWords.getTTFNorm(t); } double mean = totalScore / totalWords; if (Double.isFinite(meanRef)) { int oomRef = (int) Math.log10(meanRef); int oom = (int) Math.log10(mean); double s = Math.pow(10, (oom - oomRef)); return s; } else return 1.0; }

/** * Sets boost of termClaimsDescriptionAbstractTitles. boost = weight = factor(tf*idf) * * @param vecsTerms * @param currentField * @param factor - adjustment factor ( ex. alpha or beta ) * @param decayFactor * @return * @throws java.io.IOException */ public Map<String, TermQuery> setBoost( Map<TermFreqVector, String> vecsTerms, String currentField, float factor, float decayFactor) throws IOException { Map<String, TermQuery> terms = new HashMap<>(); // setBoost for each of the terms of each of the docs int i = 0; float norm = (float) 1 / vecsTerms.size(); // System.out.println("--------------------------"); for (Map.Entry<TermFreqVector, String> e : vecsTerms.entrySet()) { // Increase decay String field = e.getValue(); TermFreqVector docTerms = e.getKey(); float decay = decayFactor * i; // Populate terms: with TermQuries and set boost for (String termTxt : docTerms.getTerms()) { // Create Term Term term = new Term(currentField, termTxt); // Calculate weight float tf = docTerms.getFreq(termTxt); // float idf = ir.docFreq(termTitle); int docs; float idf; if (sourceField.equals(PatentQuery.all)) { docs = ir.getDocCount(field); idf = (float) Math.log10((double) docs / (ir.docFreq(new Term(field, termTxt)) + 1)); } else { docs = ir.getDocCount(sourceField); idf = (float) Math.log10((double) docs / (ir.docFreq(new Term(sourceField, termTxt)) + 1)); } float weight = tf * idf; // System.out.println(term.text() + " -> tf= " + tf + " idf= " + idf + " // tfidf= " + weight); // Adjust weight by decay factor weight = weight - (weight * decay); // Create TermQuery and add it to the collection TermQuery termQuery = new TermQuery(term); // Calculate and set boost float boost; if (vecsTerms.size() == 1) { boost = factor * tf; } else { boost = factor; } if (boost != 0) { termQuery.setBoost(boost * norm); if (terms.containsKey(termTxt)) { TermQuery tq = terms.get(termTxt); tq.setBoost(tq.getBoost() + termQuery.getBoost()); } else { terms.put(termTxt, termQuery); } } } i++; } return terms; }

@Override public Shaking getIntensityFromVelocity(Shaking PGV) { // returns the macroseimic intensity I estimate as double // PGV is the peak ground velocity (median, 84th, 16th percentile) // Minimum intensity possible double Imin = 1; // Conversion equation assumes PGV in cm/s Shaking IfromPGV = new Shaking(); double IfromPGVmedian = 5.11 + 2.35 * Math.log10(100 * PGV.expectedSI); double IfromPGV84 = 5.11 + 2.35 * Math.log10(100 * PGV.percentile84); double IfromPGV16 = 5.11 + 2.35 * Math.log10(100 * PGV.percentile16); // Impose minimum intensity if necessary if (IfromPGVmedian < 1) { IfromPGVmedian = 1; } if (IfromPGV84 < 1) { IfromPGV84 = 1; } if (IfromPGV16 < 1) { IfromPGV16 = 1; } IfromPGV.expectedSI = IfromPGVmedian; IfromPGV.percentile84 = IfromPGV84; IfromPGV.percentile16 = IfromPGV16; return IfromPGV; }

private synchronized void createModel() { if (initialized) return; long st = System.currentTimeMillis(); // create a unique list of keywords Set<String> unique = new HashSet<String>(); for (Document d : docs) unique.addAll(d.keys()); words = new ArrayList<String>(unique); Collections.sort(words); // raw values termdoc = new float[words.size()][docs.size()]; for (int i = 0, I = words.size(); i < I; i++) { for (int j = 0, J = docs.size(); j < J; j++) { termdoc[i][j] = docs.get(j).count(words.get(i)); } } // calc average number of terms per doc int c = 0; for (int j = 0, J = docs.size(); j < J; j++) { for (int i = 0, I = words.size(); i < I; i++) { c += termdoc[i][j]; } } float avt = c / docs.size(); System.out.println("avt: " + avt); // adjust by log(n)/log(fd) for (int i = 0, I = words.size(); i < I; i++) { for (int j = 0, J = docs.size(); j < J; j++) { if (termdoc[i][j] != 0) termdoc[i][j] = (float) (Math.log10(termdoc[i][j]) / Math.log10(avt)); } } // calculate the euclidean distance (frobenius norms): (a^2+b^2)^1/2 edst = new float[docs.size()]; for (int j = 0, J = termdoc[0].length; j < J; j++) { for (int i = 0, I = termdoc.length; i < I; i++) { edst[j] += Math.pow(termdoc[i][j], 2); } } for (int i = 0, I = edst.length; i < I; i++) edst[i] = (float) Math.sqrt(edst[i]); // we are ready for searches initialized = true; System.out.println( "created Term Model of (" + words.size() + " x " + docs.size() + ") in " + (System.currentTimeMillis() - st) + " msec"); }

public static int firstNineDigitsOfNthFibonacci(int n) { double phi = (1.0 + Math.sqrt(5.0)) / 2.0; double log_phi = Math.log10(phi); double log_sqrt_5 = Math.log10(Math.sqrt(5.0)); double log_f = (double) n * log_phi - log_sqrt_5; return (int) Math.pow(10.0, 8.0 + log_f % 1.0); }

/** * DOCUMENT ME! * * @param u DOCUMENT ME! * @param v DOCUMENT ME! * @return DOCUMENT ME! */ @Override public final int rgbColor(final double u, final double v) { Complex z = Complex.valueOf(u, v); for (int i = 1; i < palette.getSize(); i++) { z = formula.calculate(z); double magn = z.magnitude(); // if ( magn > radius) { // return palette[i]; // } if (magn > radius) { float position = i - (float) (Math.log10(Math.log10(magn)) / Math.log(((IPolynomialFormula) formula).getOrder())); position /= (palette.getSize() - 1); return palette.getRGB(position); } } return RGB_BLACK; }

public void TestNBModel( Map<Integer, FilewithClassInfo> filesToTest, double[] priors, Map<Integer, Map<String, Double>> condProb) { // TODO Auto-generated method stub int percentageAccuracyCounter = 0; int percentageErrorCounter = 0; Helper h = new Helper(); for (int i = 0; i < filesToTest.size(); i++) { List<Double> vals = new ArrayList<Double>(); for (int j = 0; j < 2; j++) { Map<String, Double> probMap = condProb.get(j); double prob = Math.log10(priors[j]); for (String token : filesToTest.get(i).WordMap.keySet()) { if (probMap.containsKey(token)) prob += Math.log10(probMap.get(token)); } vals.add(prob); } if (filesToTest.get(i).ClassInfo == h.getMaxValIndex(vals)) percentageAccuracyCounter++; else percentageErrorCounter++; } System.out.println( "percentageAccuracyCounter" + percentageAccuracyCounter + "percentageErrorCounter" + percentageErrorCounter); System.out.println( "Percentage : " + (double) (percentageAccuracyCounter * 100) / filesToTest.size()); }

public static void main(String[] args) { double BILLION = 1000000000d; // nanoseconds to seconds double start = 0; // start time of the current run double elapsedTime = 0; // elapsed time of current run double prevTime = 0; // elapsed time of previous run double ratio = 1; // currentTime / prevTime double lgratio = 0; // log base 2 of ratio int N = 1; // problem size parameter int key = 23; // selects internal method of RunningTime // TimingLab four = new TimingLab(24); for (int x = 71; x >= 0; x--) { TimingLab tl = new TimingLab(x); System.out.println("Time complexity for Key: " + x); System.out.println(""); for (int i = N; i <= 1024; i = i * 2) { start = System.nanoTime(); tl.timeTrial(i); elapsedTime = (System.nanoTime() - start) / BILLION; System.out.print("This call to method TimingLab.timeTrial(" + i + ") took "); System.out.printf("%4.3f", elapsedTime); System.out.println(" seconds."); if (prevTime != 0) { ratio = elapsedTime / prevTime; System.out.println("R = " + ratio); System.out.println("K = " + (Math.log10(ratio) / Math.log10(2))); } prevTime = elapsedTime; } prevTime = 0; System.out.println(""); } }

public NGDItem( long term1count, long term2count, String term1, String term2, List<String[]> term1Array, List<String[]> term2Array, long combocount, boolean useAlias, long totalDocCount) { this.term1count = term1count; this.term2count = term2count; this.term1 = term1; this.term2 = term2; this.combocount = combocount; this.term1Array = term1Array; this.term2Array = term2Array; this.useAlias = useAlias; this.totalDocCount = totalDocCount; if (this.combocount == 0) { this.ngd = -1; } else { double term1_log = Math.log10(this.term1count); double term2_log = Math.log10(this.term2count); double combo_log = Math.log10(this.combocount); this.ngd = (Math.max(term1_log, term2_log) - combo_log) / (Math.log10(this.totalDocCount) - Math.min(term1_log, term2_log)); } }

private void buildSegmentTree() { if (nums.length == 0) return; final int height = (int) Math.ceil(Math.log10(nums.length) / Math.log10(2)); final int nodes = (int) (2 * Math.pow(2, height) - 1); segTree = new int[nodes]; buildSegmentTree(0, nums.length - 1, 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]; }

/** * method to calculate the enrichment score of the gene given the total number of genes * * @param numberOfGenes total number of genes that are considered during the scoring process * @return the enrichment score of the gene indicating if the score is better than expected by * random */ public double getEnrichmentScore(int numberOfGenes) { double enrichment = Math.log10(this.score) + Math.log10((double) numberOfGenes); if (Double.isInfinite(enrichment)) { return enrichment; } else { return (double) Math.round(enrichment * 1E3) / 1E3; } }

/** * @param filesize * @return B/KB/MB/GB format */ public static String formattedFileSize(long filesize) { if (filesize <= 0) return "0"; int digGroup = (int) (Math.log10(filesize) / Math.log10(1024)); return new DecimalFormat("#,##0.00").format(filesize / Math.pow(1024, digGroup)) + " " + sizeUnits[digGroup]; }

private String buildZarmonierName(int number) { StringBuilder builder = new StringBuilder(); int doubleWordCount = Math.round((float) (Math.log10(number) / Math.log10(2))) - 2; for (int i = 0; i < doubleWordCount; i++) builder.append("doppel"); builder.append("vier"); builder.setCharAt(0, Character.toUpperCase(builder.charAt(0))); return builder.toString(); }

public boolean isPowerOfTwo(int n) { double res = Math.log10(n) / Math.log10(2); if (res == (int) res) { return true; } else { return false; } }

/** * Converts a number of bytes to a human readable file size (eg 3.5 GiB). * * <p>Based on http://stackoverflow.com/a/5599842 */ public static String readableFileSize(Context context, long bytes) { final String[] units = context.getResources().getStringArray(R.array.file_size_units); if (bytes <= 0) return "0 " + units[0]; int digitGroups = (int) (Math.log10(bytes) / Math.log10(1024)); return new DecimalFormat("#,##0.#").format(bytes / Math.pow(1024, digitGroups)) + " " + units[digitGroups]; }

public void setVolume(int vol) { synchronized (this.lock) { if (this.player != null && this.started) { player.setVolume((float) Math.log10(vol), (float) Math.log10(vol)); lock.notifyAll(); } } }

/** gate score = smallest noise margin (distance in log(REU) of input REU to margin REU) */ public static void evaluateGateNoiseMargin(Gate g, Args options) { if (options.is_noise_margin() == false) { g.get_scores().set_noise_margin_contract(true); return; } if (g.Type == GateType.INPUT || g.Type == GateType.OUTPUT || g.Type == GateType.OUTPUT_OR) { return; } // "x" to value HashMap<String, Double> lowest_on_reu = GateUtil.getIncomingONlow(g); HashMap<String, Double> highest_off_reu = GateUtil.getIncomingOFFhigh(g); ArrayList<Double> all_margins = new ArrayList<Double>(); for (String var : highest_off_reu.keySet()) { if (g.get_variable_thresholds().get(var) != null) { // IL is the input-low threshold Double IL = g.get_variable_thresholds().get(var)[0]; // actual REU Double log_input_reu = Math.log10(highest_off_reu.get(var)); // NML is the margin/width between the actual REU and the threshold REU Double NML = Math.log10(IL) - log_input_reu; all_margins.add(NML); } } for (String var : lowest_on_reu.keySet()) { if (g.get_variable_thresholds().get(var) != null) { Double IH = g.get_variable_thresholds().get(var)[1]; Double NMH = Math.log10(lowest_on_reu.get(var)) - Math.log10(IH); all_margins.add(NMH); } } if (all_margins.isEmpty()) { g.get_scores().set_noise_margin(0.0); g.get_scores().set_noise_margin_contract(true); } else { Collections.sort(all_margins); g.get_scores().set_noise_margin(all_margins.get(0)); if (all_margins.get(0) < 0) { g.get_scores().set_noise_margin_contract(false); } else { g.get_scores().set_noise_margin_contract(true); } } }

private void solve() { int n = sc.nextInt(); long result = 0; for (int i = 0; i <= Math.log10(n) - 1; i++) { result += 9 * Math.pow(10, i) * (i + 1); } result += ((int) Math.log10(n) + 1) * (n - Math.pow(10, (int) Math.log10(n)) + 1); System.out.println(result); }

public static String format(long bytes) { if (bytes <= 0) { return "0"; //$NON-NLS-1$ } int digitGroups = (int) (Math.log10(bytes) / Math.log10(1024)); return new DecimalFormat("#,##0.#").format(bytes / Math.pow(1024, digitGroups)) + " " + UNITS[digitGroups]; // $NON-NLS-1$ //$NON-NLS-2$ }

public double get_logP_additive() { double logp = 0; if (A_t < 0) { logp = -1 * Math.log10(A_t_p_value_cu * 2); } else { logp = -1 * Math.log10((1 - A_t_p_value_cu) * 2); } return logp; }

public double get_logP_dominance() { double logp = 0; if (D_t < 0) { logp = -1 * Math.log10(D_t_p_value_cu * 2); } else { logp = -1 * Math.log10((1 - D_t_p_value_cu) * 2); } return logp; }

/** * Initializes this tree by splitting it until hashdepth is reached, or until an additional level * of splits would violate maxsize. * * <p>NB: Replaces all nodes in the tree. */ public void init() { // determine the depth to which we can safely split the tree byte sizedepth = (byte) (Math.log10(maxsize) / Math.log10(2)); byte depth = (byte) Math.min(sizedepth, hashdepth); Token mintoken = partitioner.getMinimumToken(); root = initHelper(mintoken, mintoken, (byte) 0, depth); size = (long) Math.pow(2, depth); }

private String getTweetPadding(int tweetIdx) { // copiado do Utils.java int MaxNTweets = 10000; StringBuilder strBuild = new StringBuilder(); int current = (int) Math.floor(Math.log10(tweetIdx)) + 1; int expected = (int) Math.floor(Math.log10(MaxNTweets)); if (tweetIdx == 0) current = 1; for (int i = 0; i < (expected - current); i++) strBuild.append(0); strBuild.append(tweetIdx); return strBuild.toString(); }

public boolean isPowerOfTwo(int n) { // math sol if (n <= 0) return false; if (n == 1) return true; double x = Math.log10(n) / Math.log10(2); int _x = (int) x; return x - _x == 0; }

private void finalizeLpgn(Score score, Score count, int N) { if (count == null || count.getValue() == 0) { double p = Math.pow(10.0, -score.getValue()); score.setValue(getLp(1.0 - Math.pow(1.0 - p, N))); return; } int n = (int) count.getValue(); double lpgn = -Math.log10(gamma(score.getValue(), n)); for (int i = n + 1; i <= N; i++) lpgn += -Math.log10(i); for (int i = 2; i <= N - n; i++) lpgn -= -Math.log10(i); score.setValue(lpgn > 300 ? 300 : lpgn); }

/** * Calculate fire load index: rating of the maximum effort required to contain all probable fires. * * @param timberSpreadIndex * @param buildupIndex * @return double */ private double calculateFireLoadIndex(double timberSpreadIndex, double buildupIndex) { double logFireLoadIndex = 0; double fireLoadIndex = -1; if ((timberSpreadIndex > 0.) && (buildupIndex > 0.)) { logFireLoadIndex = 1.75 * Math.log10(timberSpreadIndex) + .32 * Math.log10(buildupIndex) - 1.64; fireLoadIndex = Math.pow(10., logFireLoadIndex); } return fireLoadIndex; }