List of usage examples for java.lang Math rint
public static double rint(double a)
From source file:com.opengamma.financial.analytics.volatility.surface.EquityOptionVolatilitySurfaceDataFunctionDeprecated.java
/** * Dynamically return an array of strikes given an underlying spot level of the index or price. * @param spot Spot value of the underlying ( e.g. index, stock ) * @param relativeWidth Strike bounds are specified simply: [ spot * ( 1 - width), spot * ( 1 + width) ] * @param stepSize Difference between each strike in the resulting set. // TODO Extend beyond integer * @return Long array. The format of this is limiting as these values will be used to create identifiers for the data provider */// ww w .j a v a 2 s . c o m public static Double[] getStrikes(final Double spot, Double relativeWidth, Integer stepSize) { Validate.notNull(spot, "Vol Surface Function attempting to build strikes dynamically but spotUnderlying was null"); // I've decided to put in default values // TODO Review if (relativeWidth == null) { relativeWidth = 0.6; } if (stepSize == null) { stepSize = 10; } // Estimate bounds double kMin = spot * (1 - relativeWidth); double kMax = spot * (1 + relativeWidth); // Round to nearest integer stepSize kMin = Math.rint(kMin - kMin % stepSize); kMax = Math.rint(kMax + (stepSize - kMax % stepSize)); // Fill in int nStrikes = (int) Math.round(1 + (kMax - kMin) / stepSize); Double[] strikes = new Double[nStrikes]; for (int i = 0; i < nStrikes; i++) { strikes[i] = kMin + i * stepSize; } return strikes; }
From source file:com.bc.jexp.impl.DefaultNamespace.java
private void registerDefaultFunctions() { registerFunction(new AbstractFunction.D("sin", 1) { public double evalD(final EvalEnv env, final Term[] args) { return FastMath.sin(args[0].evalD(env)); }//ww w . j a va2 s . co m }); registerFunction(new AbstractFunction.D("cos", 1) { public double evalD(final EvalEnv env, final Term[] args) { return FastMath.cos(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("tan", 1) { public double evalD(final EvalEnv env, final Term[] args) { return FastMath.tan(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("asin", 1) { public double evalD(final EvalEnv env, final Term[] args) { return FastMath.asin(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("acos", 1) { public double evalD(final EvalEnv env, final Term[] args) { return FastMath.acos(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("atan", 1) { public double evalD(final EvalEnv env, final Term[] args) { return FastMath.atan(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("atan2", 2) { public double evalD(final EvalEnv env, final Term[] args) { return Math.atan2(args[0].evalD(env), args[1].evalD(env)); } }); registerFunction(new AbstractFunction.D("log", 1) { public double evalD(final EvalEnv env, final Term[] args) { return Math.log(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("log10", 1) { public double evalD(EvalEnv env, Term[] args) throws EvalException { return Math.log10(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("exp", 1) { public double evalD(final EvalEnv env, final Term[] args) { return FastMath.exp(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("exp10", 1) { public double evalD(EvalEnv env, Term[] args) throws EvalException { return FastMath.pow(10.0, args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("sqr", 1) { public double evalD(final EvalEnv env, final Term[] args) { double v = args[0].evalD(env); return v * v; } }); registerFunction(new AbstractFunction.D("sqrt", 1) { public double evalD(final EvalEnv env, final Term[] args) { return Math.sqrt(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("pow", 2) { public double evalD(final EvalEnv env, final Term[] args) { return FastMath.pow(args[0].evalD(env), args[1].evalD(env)); } }); registerFunction(new AbstractFunction.I("min", 2) { public int evalI(final EvalEnv env, final Term[] args) { return Math.min(args[0].evalI(env), args[1].evalI(env)); } }); registerFunction(new AbstractFunction.D("min", 2) { public double evalD(final EvalEnv env, final Term[] args) { return Math.min(args[0].evalD(env), args[1].evalD(env)); } }); registerFunction(new AbstractFunction.I("max", 2) { public int evalI(final EvalEnv env, final Term[] args) { return Math.max(args[0].evalI(env), args[1].evalI(env)); } }); registerFunction(new AbstractFunction.D("max", 2) { public double evalD(final EvalEnv env, final Term[] args) { return Math.max(args[0].evalD(env), args[1].evalD(env)); } }); registerFunction(new AbstractFunction.D("floor", 1) { public double evalD(EvalEnv env, Term[] args) throws EvalException { return Math.floor(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("round", 1) { public double evalD(EvalEnv env, Term[] args) throws EvalException { return Math.round(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("ceil", 1) { public double evalD(EvalEnv env, Term[] args) throws EvalException { return Math.ceil(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("rint", 1) { public double evalD(EvalEnv env, Term[] args) throws EvalException { return Math.rint(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.I("sign", 1) { public int evalI(final EvalEnv env, final Term[] args) { return ExtMath.sign(args[0].evalI(env)); } }); registerFunction(new AbstractFunction.D("sign", 1) { public double evalD(final EvalEnv env, final Term[] args) { return ExtMath.sign(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.I("abs", 1) { public int evalI(final EvalEnv env, final Term[] args) { return Math.abs(args[0].evalI(env)); } }); registerFunction(new AbstractFunction.D("abs", 1) { public double evalD(final EvalEnv env, final Term[] args) { return Math.abs(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("deg", 1) { public double evalD(final EvalEnv env, final Term[] args) { return Math.toDegrees(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("rad", 1) { public double evalD(final EvalEnv env, final Term[] args) { return Math.toRadians(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("ampl", 2) { public double evalD(final EvalEnv env, final Term[] args) { final double a = args[0].evalD(env); final double b = args[1].evalD(env); return Math.sqrt(a * a + b * b); } }); registerFunction(new AbstractFunction.D("phase", 2) { public double evalD(final EvalEnv env, final Term[] args) { final double a = args[0].evalD(env); final double b = args[1].evalD(env); return Math.atan2(b, a); } }); registerFunction(new AbstractFunction.B("feq", 2) { public boolean evalB(EvalEnv env, Term[] args) throws EvalException { final double x1 = args[0].evalD(env); final double x2 = args[1].evalD(env); return ExtMath.feq(x1, x2, EPS); } }); registerFunction(new AbstractFunction.B("feq", 3) { public boolean evalB(EvalEnv env, Term[] args) throws EvalException { final double x1 = args[0].evalD(env); final double x2 = args[1].evalD(env); final double eps = args[2].evalD(env); return ExtMath.feq(x1, x2, eps); } }); registerFunction(new AbstractFunction.B("fneq", 2) { public boolean evalB(EvalEnv env, Term[] args) throws EvalException { final double x1 = args[0].evalD(env); final double x2 = args[1].evalD(env); return ExtMath.fneq(x1, x2, EPS); } }); registerFunction(new AbstractFunction.B("fneq", 3) { public boolean evalB(EvalEnv env, Term[] args) throws EvalException { final double x1 = args[0].evalD(env); final double x2 = args[1].evalD(env); final double eps = args[2].evalD(env); return ExtMath.fneq(x1, x2, eps); } }); registerFunction(new AbstractFunction.B("inf", 1) { public boolean evalB(EvalEnv env, Term[] args) throws EvalException { return Double.isInfinite(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.B("nan", 1) { public boolean evalB(EvalEnv env, Term[] args) throws EvalException { return Double.isNaN(args[0].evalD(env)); } }); registerFunction(new AbstractFunction.D("distance", -1) { public double evalD(final EvalEnv env, final Term[] args) { double sqrSum = 0.0; final int n = args.length / 2; for (int i = 0; i < n; i++) { final double v = args[i + n].evalD(env) - args[i].evalD(env); sqrSum += v * v; } return Math.sqrt(sqrSum); } }); registerFunction(new AbstractFunction.D("distance_deriv", -1) { public double evalD(final EvalEnv env, final Term[] args) { double sqrSum = 0.0; final int n = args.length / 2; for (int i = 0; i < n - 1; i++) { final double v1 = args[i + 1].evalD(env) - args[i].evalD(env); final double v2 = args[i + n + 1].evalD(env) - args[i + n].evalD(env); sqrSum += (v1 - v2) * (v1 - v2); } return Math.sqrt(sqrSum); } }); registerFunction(new AbstractFunction.D("distance_integ", -1) { public double evalD(final EvalEnv env, final Term[] args) { double sqrSum = 0.0; double v1Sum = 0.0; double v2Sum = 0.0; final int n = args.length / 2; for (int i = 0; i < n; i++) { v1Sum += args[i].evalD(env); v2Sum += args[i + n].evalD(env); sqrSum += (v2Sum - v1Sum) * (v2Sum - v1Sum); } return Math.sqrt(sqrSum); } }); registerFunction(new AbstractFunction.B("inrange", -1) { public boolean evalB(final EvalEnv env, final Term[] args) { final int n1 = args.length / 3; final int n2 = n1 + args.length / 3; for (int i = 0; i < n1; i++) { final double v = args[i].evalD(env); final double v1 = args[i + n1].evalD(env); final double v2 = args[i + n2].evalD(env); if (v < v1 || v > v2) { return false; } } return true; } }); registerFunction(new AbstractFunction.B("inrange_deriv", -1) { public boolean evalB(final EvalEnv env, final Term[] args) { final int n1 = args.length / 3; final int n2 = 2 * n1; for (int i = 0; i < n1 - 1; i++) { final double v = args[i + 1].evalD(env) - args[i].evalD(env); final double v1 = args[i + n1 + 1].evalD(env) - args[i + n1].evalD(env); final double v2 = args[i + n2 + 1].evalD(env) - args[i + n2].evalD(env); if (v < v1 || v > v2) { return false; } } return true; } }); registerFunction(new AbstractFunction.B("inrange_integ", -1) { public boolean evalB(final EvalEnv env, final Term[] args) { final int n1 = args.length / 3; final int n2 = 2 * n1; double vSum = 0.0; double v1Sum = 0.0; double v2Sum = 0.0; for (int i = 0; i < n1; i++) { vSum += args[i].evalD(env); v1Sum += args[i + n1].evalD(env); v2Sum += args[i + n2].evalD(env); if (vSum < v1Sum || vSum > v2Sum) { return false; } } return true; } }); }
From source file:com.piketec.jenkins.plugins.tpt.publisher.PieChart.java
/** * Render the pie chart with the given height * //from w ww .j a v a2 s. c om * @param height * The height of the resulting image * @return The pie chart rendered as an image */ public BufferedImage render(int height) { BufferedImage image = new BufferedImage(totalWidth, totalHeight, BufferedImage.TYPE_INT_RGB); Graphics2D g2 = image.createGraphics(); g2.scale(zoom, zoom); // fill background to white g2.setColor(Color.WHITE); g2.fill(new Rectangle(totalWidth, totalHeight)); // prepare render hints g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY); g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC); g2.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON); g2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY); g2.setStroke(new BasicStroke(4, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); // draw shadow image g2.drawImage(pieShadow.getImage(), 0, 0, pieShadow.getImageObserver()); double start = 0; List<Arc2D> pies = new ArrayList<>(); // pie segmente erzeugen und fuellen if (total == 0) { g2.setColor(BRIGHT_GRAY); g2.fillOval(centerX - radius, centerY - radius, 2 * radius, 2 * radius); g2.setColor(Color.WHITE); g2.drawOval(centerX - radius, centerY - radius, 2 * radius, 2 * radius); } else { for (Segment s : segments) { double portionDegrees = s.getPortion() / total; Arc2D pie = paintPieSegment(g2, start, portionDegrees, s.getColor()); if (withSubSegments) { double smallRadius = radius * s.getSubSegmentRatio(); paintPieSegment(g2, start, portionDegrees, smallRadius, s.getColor().darker()); } start += portionDegrees; // portion degree jetzt noch als String (z.B. "17.3%" oder "20%" zusammenbauen) String p = String.format(Locale.ENGLISH, "%.1f", Math.rint(portionDegrees * 1000) / 10.0); p = removeSuffix(p, ".0"); // evtl. ".0" bei z.B. "25.0" abschneiden (-> "25") s.setPercent(p + "%"); pies.add(pie); } // weissen Rahmen um die pie segmente zeichen g2.setColor(Color.WHITE); for (Arc2D pie : pies) { g2.draw(pie); } } // Legende zeichnen renderLegend(g2); // "xx%" Label direkt auf die pie segmente zeichen g2.setColor(Color.WHITE); float fontSize = 32f; g2.setFont(NORMALFONT.deriveFont(fontSize).deriveFont(Font.BOLD)); start = 0; for (Segment s : segments) { if (s.getPortion() < 1E-6) { continue; // ignore segments with portions that are extremely small } double portionDegrees = s.getPortion() / total; double angle = start + portionDegrees / 2; // genau in der Mitte des Segments double xOffsetForCenteredTxt = 8 * s.getPercent().length(); // assume roughly 8px per char int x = (int) (centerX + 0.6 * radius * Math.sin(2 * Math.PI * angle) - xOffsetForCenteredTxt); int y = (int) (centerY - 0.6 * radius * Math.cos(2 * Math.PI * angle) + fontSize / 2); g2.drawString(s.getPercent(), x, y); start += portionDegrees; } return image; }
From source file:org.renjin.primitives.MathGroup.java
@Builtin @Deferrable//from ww w.j a v a 2s . c o m @DataParallel(value = PreserveAttributeStyle.ALL, passNA = true) public static double round(double x) { return Math.rint(x); }
From source file:loci.formats.in.MetamorphTiffReader.java
@Override protected void initFile(String id) throws FormatException, IOException { super.initFile(id); List<String> uniqueChannels = new ArrayList<String>(); final List<Double> uniqueZs = new ArrayList<Double>(); final List<Length> stageX = new ArrayList<Length>(); final List<Length> stageY = new ArrayList<Length>(); CoreMetadata m = core.get(0);// ww w. ja va 2s . c o m String filename = id.substring(id.lastIndexOf(File.separator) + 1); filename = filename.substring(0, filename.indexOf('.')); boolean integerFilename = true; try { Integer.parseInt(filename); } catch (NumberFormatException e) { integerFilename = false; } if (integerFilename && ifds.size() == 1 && ifds.get(0).getIFDIntValue(IFD.NEW_SUBFILE_TYPE) == 2) { // look for other files in the dataset findTIFFs(); String stageLabel = null; for (String tiff : files) { MetamorphHandler handler = new MetamorphHandler(); parseFile(tiff, handler); String label = handler.getStageLabel(); if (stageLabel == null) { stageLabel = label; } else if (!label.equals(stageLabel)) { break; } if (!uniqueChannels.contains(handler.getChannelName())) { uniqueChannels.add(handler.getChannelName()); } final List<Double> zPositions = handler.getZPositions(); Double pos = Math.rint(zPositions.get(0)); if (!uniqueZs.contains(pos)) { uniqueZs.add(pos); } } MetamorphHandler handler = new MetamorphHandler(); parseFile(files[files.length - 1], handler); String lastStageLabel = handler.getStageLabel(); if (lastStageLabel != null && stageLabel != null) { int lastField = getField(lastStageLabel); int lastWellRow = getWellRow(lastStageLabel); int lastWellColumn = getWellColumn(lastStageLabel); int field = getField(stageLabel); int fieldRow = getWellRow(stageLabel); int fieldColumn = getWellColumn(stageLabel); wellCount = lastField - field + 1; fieldRowCount = lastWellRow - fieldRow + 1; fieldColumnCount = lastWellColumn - fieldColumn + 1; } m.sizeC = uniqueChannels.size(); m.sizeZ = uniqueZs.size(); } else { files = new String[] { id }; wellCount = 1; fieldRowCount = 1; fieldColumnCount = 1; m.sizeC = 0; } // parse XML comment MetamorphHandler handler = new MetamorphHandler(getGlobalMetadata()); final List<Length> xPositions = new ArrayList<Length>(); final List<Length> yPositions = new ArrayList<Length>(); for (IFD ifd : ifds) { String xml = XMLTools.sanitizeXML(ifd.getComment()); XMLTools.parseXML(xml, handler); final Length x = handler.getStagePositionX(); final Length y = handler.getStagePositionY(); if (xPositions.isEmpty()) { xPositions.add(x); yPositions.add(y); } else { final Length previousX = xPositions.get(xPositions.size() - 1); final Length previousY = yPositions.get(yPositions.size() - 1); final double x1 = x.value(UNITS.REFERENCEFRAME).doubleValue(); final double x2 = previousX.value(UNITS.REFERENCEFRAME).doubleValue(); final double y1 = y.value(UNITS.REFERENCEFRAME).doubleValue(); final double y2 = previousY.value(UNITS.REFERENCEFRAME).doubleValue(); if (Math.abs(x1 - x2) > 0.21 || Math.abs(y1 - y2) > 0.21) { xPositions.add(x); yPositions.add(y); } } } if (xPositions.size() > 1) { fieldRowCount = xPositions.size(); } final List<Integer> wavelengths = handler.getWavelengths(); final List<Double> zPositions = handler.getZPositions(); dualCamera = handler.hasDualCamera(); // calculate axis sizes final List<Integer> uniqueC = new ArrayList<Integer>(); for (Integer c : wavelengths) { if (!uniqueC.contains(c)) { uniqueC.add(c); } } int effectiveC = uniqueC.size(); if (effectiveC == 0) effectiveC = 1; if (getSizeC() == 0) m.sizeC = 1; int samples = ifds.get(0).getSamplesPerPixel(); m.sizeC *= effectiveC * samples; final List<Double> uniqueZ = new ArrayList<Double>(); for (Double z : zPositions) { if (!uniqueZ.contains(z)) uniqueZ.add(z); } if (getSizeZ() == 0) m.sizeZ = 1; if (uniqueZ.size() > 1) m.sizeZ *= uniqueZ.size(); Double physicalSizeZ = null; if (m.sizeZ > 1) { Double zRange = zPositions.get(zPositions.size() - 1) - zPositions.get(0); physicalSizeZ = Math.abs(zRange); physicalSizeZ /= (m.sizeZ - 1); } int totalPlanes = files.length * ifds.size(); effectiveC = getSizeC() / samples; // if the channel name and Z position are unique // for each plane, then prefer unique channels over unique Zs // the division by uniqueC.size is not a typo - it's meant to // account for the multiple actual Z sections if (effectiveC * getSizeZ() > totalPlanes && (effectiveC * (getSizeZ() / uniqueC.size()) == totalPlanes || effectiveC == totalPlanes)) { if (getSizeZ() >= uniqueC.size()) { m.sizeZ /= uniqueC.size(); } else { m.sizeZ = 1; } } m.sizeT = totalPlanes / (wellCount * fieldRowCount * fieldColumnCount * getSizeZ() * effectiveC); if (getSizeT() == 0) m.sizeT = 1; int seriesCount = wellCount * fieldRowCount * fieldColumnCount; if (seriesCount > 1 && getSizeZ() > totalPlanes / seriesCount || totalPlanes > getSizeZ() * getSizeT() * effectiveC) { m.sizeZ = 1; m.sizeT = totalPlanes / (seriesCount * effectiveC); } m.imageCount = getSizeZ() * getSizeT() * effectiveC; if (dualCamera) { m.sizeX /= 2; m.sizeC *= 2; m.imageCount *= 2; } if (seriesCount > 1) { core.clear(); for (int i = 0; i < seriesCount; i++) { core.add(m); } } for (int s = 0; s < wellCount * fieldRowCount * fieldColumnCount; s++) { if (files.length > 1) { int[] lengths = new int[] { getSizeZ(), getEffectiveSizeC(), fieldColumnCount, fieldRowCount, wellCount, getSizeT() }; Well well = getWell(s); int[] position = new int[] { 0, 0, well.fieldCol, well.fieldRow, well.well, 0 }; int fileIndex = FormatTools.positionToRaster(lengths, position); parseFile(files[fileIndex], handler); stageX.add(handler.getStagePositionX()); stageY.add(handler.getStagePositionY()); } else { stageX.add(xPositions.get(s)); stageY.add(yPositions.get(s)); } } MetadataStore store = makeFilterMetadata(); MetadataTools.populatePixels(store, this); // Only populate Plate/Well metadata if there are multiple wells. // The presence of just one well suggests that we don't actually have // an HCS dataset (and even if we did, the Plate/Well metadata would be // effectively useless). if (wellCount > 1) { store.setPlateID(MetadataTools.createLSID("Plate", 0), 0); store.setPlateRows(new PositiveInteger(1), 0); store.setPlateColumns(new PositiveInteger(wellCount), 0); store.setPlateRowNamingConvention(NamingConvention.LETTER, 0); store.setPlateColumnNamingConvention(NamingConvention.NUMBER, 0); store.setPlateAcquisitionID(MetadataTools.createLSID("PlateAcquisition", 0, 0), 0, 0); for (int well = 0; well < wellCount; well++) { store.setWellID(MetadataTools.createLSID("Well", 0, well), 0, well); store.setWellRow(new NonNegativeInteger(0), 0, well); store.setWellColumn(new NonNegativeInteger(well), 0, well); for (int row = 0; row < fieldRowCount; row++) { for (int col = 0; col < fieldColumnCount; col++) { int field = row * fieldColumnCount + col; String wellSampleID = MetadataTools.createLSID("WellSample", 0, well, field); store.setWellSampleID(wellSampleID, 0, well, field); int seriesIndex = getSeriesIndex(row, col, well); String imageID = MetadataTools.createLSID("Image", seriesIndex); store.setImageID(imageID, seriesIndex); store.setWellSampleImageRef(imageID, 0, well, field); store.setWellSampleIndex(new NonNegativeInteger(seriesIndex), 0, well, field); store.setPlateAcquisitionWellSampleRef(wellSampleID, 0, 0, seriesIndex); } } } } final List<String> timestamps = handler.getTimestamps(); final List<Double> exposures = handler.getExposures(); if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) { for (int i = 0; i < timestamps.size(); i++) { long timestamp = DateTools.getTime(timestamps.get(i), DATE_FORMAT, "."); addGlobalMetaList("timestamp", timestamp); } for (int i = 0; i < exposures.size(); i++) { addGlobalMetaList("exposure time (ms)", exposures.get(i).floatValue() * 1000); } } for (int s = 0; s < seriesCount; s++) { setSeries(s); Well well = getWell(s); String name = handler.getImageName(); if (seriesCount > 1) { name = "Field " + (char) (well.fieldRow + 'A') + (well.fieldCol + 1) + ", Well " + (well.well + 1) + ": " + name; } store.setImageName(name, s); String date = DateTools.formatDate(handler.getDate(), DateTools.ISO8601_FORMAT, "."); if (date != null) { store.setImageAcquisitionDate(new Timestamp(date), s); } if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) { long startDate = 0; if (timestamps.size() > 0) { startDate = DateTools.getTime(timestamps.get(0), DATE_FORMAT, "."); } store.setImageDescription("", s); int image = 0; for (int c = 0; c < getEffectiveSizeC(); c++) { for (int t = 0; t < getSizeT(); t++) { store.setPlaneTheZ(new NonNegativeInteger(0), s, image); store.setPlaneTheC(new NonNegativeInteger(c), s, image); store.setPlaneTheT(new NonNegativeInteger(t), s, image); if (t < timestamps.size()) { String stamp = timestamps.get(t); long ms = DateTools.getTime(stamp, DATE_FORMAT, "."); store.setPlaneDeltaT(new Time((ms - startDate) / 1000.0, UNITS.SECOND), s, image); } int exposureIndex = image; if (dualCamera) { exposureIndex /= getEffectiveSizeC(); } if (exposures.size() == 1) { exposureIndex = 0; } if (exposureIndex < exposures.size() && exposures.get(exposureIndex) != null) { store.setPlaneExposureTime(new Time(exposures.get(exposureIndex), UNITS.SECOND), s, image); } if (s < stageX.size()) { store.setPlanePositionX(stageX.get(s), s, image); } if (s < stageY.size()) { store.setPlanePositionY(stageY.get(s), s, image); } image++; } } store.setImagingEnvironmentTemperature(new Temperature(handler.getTemperature(), UNITS.CELSIUS), s); Length sizeX = FormatTools.getPhysicalSizeX(handler.getPixelSizeX()); Length sizeY = FormatTools.getPhysicalSizeY(handler.getPixelSizeY()); Length sizeZ = physicalSizeZ == null ? null : FormatTools.getPhysicalSizeZ(physicalSizeZ); if (sizeX != null) { store.setPixelsPhysicalSizeX(sizeX, s); } if (sizeY != null) { store.setPixelsPhysicalSizeY(sizeY, s); } if (sizeZ != null) { store.setPixelsPhysicalSizeZ(sizeZ, s); } if (uniqueChannels.size() == 0) { uniqueChannels = handler.getChannelNames(); } for (int c = 0; c < getEffectiveSizeC(); c++) { if (uniqueChannels.size() > c) { store.setChannelName(uniqueChannels.get(c), s, c); } else store.setChannelName(handler.getChannelName(), s, c); if (c < wavelengths.size()) { store.setChannelEmissionWavelength( FormatTools.getEmissionWavelength(Double.valueOf(wavelengths.get(c))), s, c); } } } } }
From source file:op.tools.SYSTools.java
public static double roundScale2(double d) { return Math.rint(d * 100) / 100.; }
From source file:org.jahia.modules.sociallib.SocialService.java
public JCRNodeWrapper addActivity(final JCRUserNode userNode, final JCRNodeWrapper targetNode, String activityType, JCRSessionWrapper session, Object... args) throws RepositoryException { JCRNodeWrapper activitiesNode = getActivitiesNode(session, userNode); if (activityRecorderRegistry.getActivityRecorderMap().containsKey(activityType)) { ActivityRecorder activityRecorder = activityRecorderRegistry.getActivityRecorderMap().get(activityType); String nodeType = activityRecorder.getNodeTypeForActivity(activityType); String nodeName = jcrContentUtils.generateNodeName(activitiesNode, nodeType) + "_" + ((int) Math.rint(Math.random() * 100000)); JCRNodeWrapper activityNode = activitiesNode.addNode(nodeName, nodeType); if (targetNode != null) { activityNode.setProperty("j:targetNode", targetNode.getPath()); }/*from w w w . j av a 2 s. co m*/ activityNode.setProperty("j:activityType", activityType); activityRecorder.recordActivity(activityNode, activityType, userNode.getPath(), targetNode, session, args); return activityNode; } throw new NoSuchNodeTypeException(); }
From source file:com.bytelightning.opensource.pokerface.ScriptHelperImpl.java
/** * Courtesy of 'Peter' at http://stackoverflow.com/questions/6824157/parse-accept-language-header-in-java *///from www.j a va 2 s . c o m private void parseLocalesHeader(String value, TreeMap<Double, ArrayList<Locale>> locales) { for (String str : value.split(",")) { String[] arr = str.trim().replace("-", "_").split(";"); // Parse the q-value Double q = 1.0d; for (String s : arr) { s = s.trim(); if (s.startsWith("q=")) { try { String ds = s.substring(2).trim(); if (ds.length() > 0 && ds.length() <= 5) q = Math.rint(Double.parseDouble(ds) * 10000d) / 10000d; else q = 0d; } catch (NumberFormatException e) { q = 0.0; } break; } } if (q >= 0.00005) { // Parse the locale Locale locale; String[] l = arr[0].split("_"); switch (l.length) { case 2: locale = new Locale(l[0], l[1]); break; case 3: locale = new Locale(l[0], l[1], l[2]); break; default: locale = new Locale(l[0]); break; } ArrayList<Locale> list = locales.get(q); if (list == null) { list = new ArrayList<Locale>(); locales.put(q, list); } list.add(locale); } } }
From source file:us.mn.state.health.lims.testreflex.action.util.RetroCIReflexActions.java
public Result getCD4CalculationResult(Sample sample) { Result calculatedResult = null; List<Analysis> analysisList = ANALYSIS_DAO.getAnalysisBySampleAndTestIds(sample.getId(), CD4_RESULT_TEST_DEPENDANCIES); List<Integer> analysisIDList = new ArrayList<Integer>(); for (Analysis analysis : analysisList) { analysisIDList.add(Integer.parseInt(analysis.getId())); }/*from ww w. ja v a 2 s . c om*/ ResultDAO resultDAO = new ResultDAOImpl(); Result CD4Result = resultDAO.getResultForAnalyteInAnalysisSet(ANALYTE_CD4_PER_RESULT.getId(), analysisIDList); Result GBResult = resultDAO.getResultForAnalyteInAnalysisSet(ANALYTE_GB_RESULT.getId(), analysisIDList); Result LymphResult = resultDAO.getResultForAnalyteInAnalysisSet(ANALYTE_LYMPH_PER_RESULT.getId(), analysisIDList); if (CD4Result != null && GBResult != null && LymphResult != null) { try { double result = Double.parseDouble(CD4Result.getValue()) * Double.parseDouble(GBResult.getValue()) * Double.parseDouble(LymphResult.getValue()) * 0.1; result = Math.rint(result); calculatedResult = resultDAO.getResultForAnalyteInAnalysisSet(ANALYTE_CD4_CT_GENERATED.getId(), analysisIDList); if (calculatedResult == null) { calculatedResult = new Result(); calculatedResult.setResultType("N"); calculatedResult.setIsReportable("T"); calculatedResult.setTestResult(TEST_RESULT_CD4_CALCULATED); calculatedResult.setAnalyte(ANALYTE_CD4_CT_GENERATED); calculatedResult.setAnalysis(CD4Result.getAnalysis()); } calculatedResult.setValue(String.valueOf(result)); } catch (NumberFormatException e) { //no op final result should be null. Handles the case of "XXXX" } } return calculatedResult; }
From source file:it.cnr.istc.utils.gui.ReverseGradientXYBarPainter.java
/** * Splits a bar into subregions (elsewhere, these subregions will have * different gradients applied to them). * * @param bar the bar shape./* w ww . j a va 2s.c om*/ * @param a the first division. * @param b the second division. * @param c the third division. * * @return An array containing four subregions. */ private Rectangle2D[] splitVerticalBar(RectangularShape bar, double a, double b, double c) { Rectangle2D[] result = new Rectangle2D[4]; double x0 = bar.getMinX(); double x1 = Math.rint(x0 + (bar.getWidth() * a)); double x2 = Math.rint(x0 + (bar.getWidth() * b)); double x3 = Math.rint(x0 + (bar.getWidth() * c)); result[0] = new Rectangle2D.Double(bar.getMinX(), bar.getMinY(), x1 - x0, bar.getHeight()); result[1] = new Rectangle2D.Double(x1, bar.getMinY(), x2 - x1, bar.getHeight()); result[2] = new Rectangle2D.Double(x2, bar.getMinY(), x3 - x2, bar.getHeight()); result[3] = new Rectangle2D.Double(x3, bar.getMinY(), bar.getMaxX() - x3, bar.getHeight()); return result; }