@Override public void mul( final float c ) { t.mul( c ); }
@Override public void mul( final double c ) { t.mul( c ); }
@Override public void mul( final T c ) { t.mul( c.t ); valid &= c.valid; }
@Override public void mul( final T c ) { t.mul( c.t ); valid &= c.valid; }
@Override public void mul( final float c ) { t.mul( c ); }
@Override public void mul( final double c ) { t.mul( c ); }
public final O eval() { this.scrap.set( this.a.eval() ); this.scrap.mul( this.b.eval() ); return this.scrap; }
public final O eval( final Localizable loc ) { this.scrap.set( this.a.eval( loc ) ); this.scrap.mul( this.b.eval( loc ) ); return this.scrap; } }
@Override public void compute(final Histogram<T> histogram, final T median, final T output) { sum.setZero(); for (int i = histogram.nBins() -1; i> -1; --i) { e.setReal(histogram.binValue(i).getRealDouble() - median.getRealDouble()); ecopy.set(e); e.mul(ecopy); // pow(x, 2) e.mul(histogram.bins[i]); sum.add(e); } output.setReal(Math.sqrt(sum.getRealDouble() / histogram.nPixels)); } }
private < T extends RealType< T > > T minValue( final T one ) { final T minValue = one.copy(); minValue.mul( one.getMinValue() ); return minValue; }
/** @see Histogram */ public LinearHistogram( final int nBins, final int numDimensions, final T min, final T max) { super(nBins, numDimensions, min, max); // Compute values of each bin this.K = nBins -1; int i = -1; for (final T bin : binValues) { bin.set(range); bin.mul(++i / this.K); bin.add(min); } dmin = min.getRealDouble(); dmax = max.getRealDouble(); drange = range.getRealDouble(); }
private < T extends RealType< T > > T maxValue( final T one ) { if ( one instanceof Unsigned128BitType ) // NB: Max value for Unsigned128BitType, is not returned with required precision by one.getMaxValue(). return ( T ) new Unsigned128BitType( 0xffffffffffffffffL, 0xffffffffffffffffL ); final T maxValue = one.copy(); maxValue.mul( one.getMaxValue() ); return maxValue; }
/** * performs update step of the Richardson Lucy with Total Variation Algorithm */ @Override public void compute(I correction, I estimate) { if (variation == null) { Type<T> type = Util.getTypeFromInterval(correction); variation = ops().create().img(correction, type.createVariable()); } divUnitGradFastThread(estimate); final Cursor<T> cursorCorrection = Views.iterable(correction).cursor(); final Cursor<T> cursorVariation = Views.iterable(variation).cursor(); final Cursor<T> cursorEstimate = Views.iterable(estimate).cursor(); while (cursorEstimate.hasNext()) { cursorCorrection.fwd(); cursorVariation.fwd(); cursorEstimate.fwd(); cursorEstimate.get().mul(cursorCorrection.get()); cursorEstimate.get().mul(1f / (1f - regularizationFactor * cursorVariation .get().getRealFloat())); } }