/* * #%L * ImageJ software for multidimensional image processing and analysis. * %% * Copyright (C) 2014 - 2020 ImageJ developers. * %% * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * #L% */ package net.imagej.ops.math; import net.imagej.ops.AbstractNamespace; import net.imagej.ops.Namespace; import net.imagej.ops.OpMethod; import net.imagej.ops.Ops; import net.imglib2.IterableInterval; import net.imglib2.RandomAccessibleInterval; import net.imglib2.img.array.ArrayImg; import net.imglib2.img.basictypeaccess.array.ArrayDataAccess; import net.imglib2.img.basictypeaccess.array.ByteArray; import net.imglib2.img.basictypeaccess.array.DoubleArray; import net.imglib2.img.basictypeaccess.array.FloatArray; import net.imglib2.img.basictypeaccess.array.IntArray; import net.imglib2.img.basictypeaccess.array.LongArray; import net.imglib2.img.basictypeaccess.array.ShortArray; import net.imglib2.img.planar.PlanarImg; import net.imglib2.type.NativeType; import net.imglib2.type.Type; import net.imglib2.type.numeric.ComplexType; import net.imglib2.type.numeric.NumericType; import net.imglib2.type.numeric.RealType; import net.imglib2.type.numeric.integer.GenericByteType; import net.imglib2.type.numeric.integer.GenericIntType; import net.imglib2.type.numeric.integer.GenericShortType; import net.imglib2.type.numeric.integer.LongType; import net.imglib2.type.numeric.real.DoubleType; import net.imglib2.type.numeric.real.FloatType; import org.scijava.plugin.Plugin; /** * The math namespace contains arithmetic operations. * * @author Curtis Rueden */ @Plugin(type = Namespace.class) public class MathNamespace extends AbstractNamespace { // -- Math namespace ops -- @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleAbs.class) public double abs(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleAbs.class, a); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.FloatAbs.class) public float abs(final float a) { final float result = (Float) ops().run( net.imagej.ops.math.PrimitiveMath.FloatAbs.class, a); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerAbs.class) public int abs(final int a) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerAbs.class, a); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongAbs.class) public long abs(final long a) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongAbs.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Abs.class) public <I extends RealType<I>, O extends RealType<O>> O abs(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Abs.class, out, in); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.MultiplyByte.class, net.imagej.ops.math.ConstantToArrayImage.MultiplyByte.class, net.imagej.ops.math.ConstantToArrayImageP.MultiplyUnsignedByte.class, net.imagej.ops.math.ConstantToArrayImage.MultiplyUnsignedByte.class }) public <B extends GenericByteType<B>> ArrayImg<B, ByteArray> multiply( final ArrayImg<B, ByteArray> image, final byte value) { @SuppressWarnings("unchecked") final ArrayImg<B, ByteArray> result = (ArrayImg<B, ByteArray>) ops().run( Ops.Math.Multiply.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.MultiplyDouble.class, net.imagej.ops.math.ConstantToArrayImage.MultiplyDouble.class }) public ArrayImg<DoubleType, DoubleArray> multiply( final ArrayImg<DoubleType, DoubleArray> image, final double value) { @SuppressWarnings("unchecked") final ArrayImg<DoubleType, DoubleArray> result = (ArrayImg<DoubleType, DoubleArray>) ops().run(Ops.Math.Multiply.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.MultiplyFloat.class, net.imagej.ops.math.ConstantToArrayImage.MultiplyFloat.class }) public ArrayImg<FloatType, FloatArray> multiply( final ArrayImg<FloatType, FloatArray> image, final float value) { @SuppressWarnings("unchecked") final ArrayImg<FloatType, FloatArray> result = (ArrayImg<FloatType, FloatArray>) ops().run(Ops.Math.Multiply.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.MultiplyInt.class, net.imagej.ops.math.ConstantToArrayImage.MultiplyInt.class, net.imagej.ops.math.ConstantToArrayImageP.MultiplyUnsignedInt.class, net.imagej.ops.math.ConstantToArrayImage.MultiplyUnsignedInt.class }) public <I extends GenericIntType<I>> ArrayImg<I, IntArray> multiply( final ArrayImg<I, IntArray> image, final int value) { @SuppressWarnings("unchecked") final ArrayImg<I, IntArray> result = (ArrayImg<I, IntArray>) ops().run( Ops.Math.Multiply.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.MultiplyLong.class, net.imagej.ops.math.ConstantToArrayImage.MultiplyLong.class, net.imagej.ops.math.ConstantToArrayImageP.MultiplyUnsignedLong.class, net.imagej.ops.math.ConstantToArrayImage.MultiplyUnsignedLong.class }) public <N extends NativeType<N>> ArrayImg<N, LongArray> multiply( final ArrayImg<N, LongArray> image, final long value) { @SuppressWarnings("unchecked") final ArrayImg<N, LongArray> result = (ArrayImg<N, LongArray>) ops().run( Ops.Math.Multiply.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.MultiplyShort.class, net.imagej.ops.math.ConstantToArrayImage.MultiplyShort.class, net.imagej.ops.math.ConstantToArrayImageP.MultiplyUnsignedShort.class, net.imagej.ops.math.ConstantToArrayImage.MultiplyUnsignedShort.class }) public <S extends GenericShortType<S>> ArrayImg<S, ShortArray> multiply( final ArrayImg<S, ShortArray> image, final short value) { @SuppressWarnings("unchecked") final ArrayImg<S, ShortArray> result = (ArrayImg<S, ShortArray>) ops().run( Ops.Math.Multiply.NAME, image, value); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleAdd.class) public double add(final double a, final double b) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleAdd.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.FloatAdd.class) public float add(final float a, final float b) { final float result = (Float) ops().run( net.imagej.ops.math.PrimitiveMath.FloatAdd.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.IIToIIOutputII.Add.class) public <T extends NumericType<T>> IterableInterval<T> add( final IterableInterval<T> out, final IterableInterval<T> in1, final IterableInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Add.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.IIToIIOutputII.Add.class) public <T extends NumericType<T>> IterableInterval<T> add( final IterableInterval<T> in1, final IterableInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Add.class, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerAdd.class) public int add(final int a, final int b) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerAdd.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.IIToRAIOutputII.Add.class) public <T extends NumericType<T>> IterableInterval<T> add( final IterableInterval<T> in1, final RandomAccessibleInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Add.class, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.IIToRAIOutputII.Add.class) public <T extends NumericType<T>> IterableInterval<T> add( final IterableInterval<T> out, final IterableInterval<T> in1, final RandomAccessibleInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Add.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToIIOutputII.Add.class) public <T extends NumericType<T>> IterableInterval<T> add( final IterableInterval<T> in, final T value) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Add.class, in, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToIIOutputII.Add.class) public <T extends NumericType<T>> IterableInterval<T> add( final IterableInterval<T> out, final IterableInterval<T> in, final T value) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Add.class, out, in, value); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongAdd.class) public long add(final long a, final long b) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongAdd.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.BinaryRealTypeMath.Add.class) public < I1 extends RealType<I1>, I2 extends RealType<I2>, O extends RealType<O>> O add(final O out, final I1 in1, final I2 in2) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Add.class, out, in1, in2); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.AddByte.class, net.imagej.ops.math.ConstantToPlanarImage.AddUnsignedByte.class }) public <B extends GenericByteType<B>> PlanarImg<B, ByteArray> add( final PlanarImg<B, ByteArray> image, final byte value) { @SuppressWarnings("unchecked") final PlanarImg<B, ByteArray> result = (PlanarImg<B, ByteArray>) ops().run( Ops.Math.Add.NAME, image, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToPlanarImage.AddDouble.class) public PlanarImg<DoubleType, DoubleArray> add( final PlanarImg<DoubleType, DoubleArray> image, final double value) { @SuppressWarnings("unchecked") final PlanarImg<DoubleType, DoubleArray> result = (PlanarImg<DoubleType, DoubleArray>) ops().run( net.imagej.ops.Ops.Math.Add.class, image, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToPlanarImage.AddFloat.class) public PlanarImg<FloatType, FloatArray> add( final PlanarImg<FloatType, FloatArray> image, final float value) { @SuppressWarnings("unchecked") final PlanarImg<FloatType, FloatArray> result = (PlanarImg<FloatType, FloatArray>) ops().run( net.imagej.ops.Ops.Math.Add.class, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.AddInt.class, net.imagej.ops.math.ConstantToPlanarImage.AddUnsignedInt.class }) public <I extends GenericIntType<I>> PlanarImg<I, IntArray> add( final PlanarImg<I, IntArray> image, final int value) { @SuppressWarnings("unchecked") final PlanarImg<I, IntArray> result = (PlanarImg<I, IntArray>) ops().run( Ops.Math.Add.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.AddLong.class, net.imagej.ops.math.ConstantToPlanarImage.AddUnsignedLong.class }) public <N extends NativeType<N>> PlanarImg<N, LongArray> add( final PlanarImg<N, LongArray> image, final long value) { @SuppressWarnings("unchecked") final PlanarImg<N, LongArray> result = (PlanarImg<N, LongArray>) ops().run( Ops.Math.Add.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.AddShort.class, net.imagej.ops.math.ConstantToPlanarImage.AddUnsignedShort.class }) public <S extends GenericShortType<S>> PlanarImg<S, ShortArray> add( final PlanarImg<S, ShortArray> arg, final short value) { @SuppressWarnings("unchecked") final PlanarImg<S, ShortArray> result = (PlanarImg<S, ShortArray>) ops() .run(Ops.Math.Add.NAME, arg, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToIIOutputRAI.Add.class) public <T extends NumericType<T>> RandomAccessibleInterval<T> add( final RandomAccessibleInterval<T> out, final IterableInterval<T> in, final T value) { @SuppressWarnings("unchecked") final RandomAccessibleInterval<T> result = (RandomAccessibleInterval<T>) ops().run(net.imagej.ops.Ops.Math.Add.class, out, in, value); return result; } @OpMethod(op = net.imagej.ops.math.NumericTypeBinaryMath.Add.class) public <T extends NumericType<T>> T add(final T in, final T b) { @SuppressWarnings("unchecked") final T result = (T) ops().run(net.imagej.ops.Ops.Math.Add.class, in, b); return result; } @OpMethod(op = net.imagej.ops.math.NumericTypeBinaryMath.Add.class) public <T extends NumericType<T>> T add(final T out, final T in1, final T in2) { @SuppressWarnings("unchecked") final T result = (T) ops().run(net.imagej.ops.Ops.Math.Add.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerAnd.class) public int and(final int a, final int b) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerAnd.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongAnd.class) public long and(final long a, final long b) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongAnd.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.BinaryRealTypeMath.And.class) public < I1 extends RealType<I1>, I2 extends RealType<I2>, O extends RealType<O>> O and(final O out, final I1 in1, final I2 in2) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.And.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleArccos.class) public double arccos(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleArccos.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Arccos.class) public <I extends RealType<I>, O extends RealType<O>> O arccos(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Arccos.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Arccosh.class) public <I extends RealType<I>, O extends RealType<O>> O arccosh(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Arccosh.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Arccot.class) public <I extends RealType<I>, O extends RealType<O>> O arccot(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Arccot.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Arccoth.class) public <I extends RealType<I>, O extends RealType<O>> O arccoth(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Arccoth.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Arccsc.class) public <I extends RealType<I>, O extends RealType<O>> O arccsc(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Arccsc.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Arccsch.class) public <I extends RealType<I>, O extends RealType<O>> O arccsch(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Arccsch.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Arcsec.class) public <I extends RealType<I>, O extends RealType<O>> O arcsec(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Arcsec.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Arcsech.class) public <I extends RealType<I>, O extends RealType<O>> O arcsech(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Arcsech.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleArcsin.class) public double arcsin(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleArcsin.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Arcsin.class) public <I extends RealType<I>, O extends RealType<O>> O arcsin(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Arcsin.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Arcsinh.class) public <I extends RealType<I>, O extends RealType<O>> O arcsinh(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Arcsinh.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleArctan.class) public double arctan(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleArctan.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Arctan.class) public <I extends RealType<I>, O extends RealType<O>> O arctan(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Arctan.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Arctanh.class) public <I extends RealType<I>, O extends RealType<O>> O arctanh(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Arctanh.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.NullaryNumericTypeMath.Assign.class) public <T extends Type<T>> T assign(final T out, final T constant) { @SuppressWarnings("unchecked") final T result = (T) ops().run( net.imagej.ops.math.NullaryNumericTypeMath.Assign.class, out, constant); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleCeil.class) public double ceil(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleCeil.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Ceil.class) public <I extends RealType<I>, O extends RealType<O>> O ceil(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Ceil.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerComplement.class) public int complement(final int a) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerComplement.class, a); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongComplement.class) public long complement(final long a) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongComplement.class, a); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleCos.class) public double cos(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleCos.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Cos.class) public <I extends RealType<I>, O extends RealType<O>> O cos(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Cos.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleCosh.class) public double cosh(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleCosh.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Cosh.class) public <I extends RealType<I>, O extends RealType<O>> O cosh(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Cosh.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Cot.class) public <I extends RealType<I>, O extends RealType<O>> O cot(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Cot.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Coth.class) public <I extends RealType<I>, O extends RealType<O>> O coth(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Coth.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Csc.class) public <I extends RealType<I>, O extends RealType<O>> O csc(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Csc.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Csch.class) public <I extends RealType<I>, O extends RealType<O>> O csch(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Csch.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleCubeRoot.class) public double cubeRoot(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleCubeRoot.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.CubeRoot.class) public <I extends RealType<I>, O extends RealType<O>> O cubeRoot(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.CubeRoot.class, out, in); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.DivideByte.class, net.imagej.ops.math.ConstantToArrayImage.DivideByte.class, net.imagej.ops.math.ConstantToArrayImageP.DivideUnsignedByte.class, net.imagej.ops.math.ConstantToArrayImage.DivideUnsignedByte.class }) public <B extends GenericByteType<B>> ArrayImg<B, ByteArray> divide( final ArrayImg<B, ByteArray> image, final byte value) { @SuppressWarnings("unchecked") final ArrayImg<B, ByteArray> result = (ArrayImg<B, ByteArray>) ops().run( Ops.Math.Divide.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.DivideDouble.class, net.imagej.ops.math.ConstantToArrayImage.DivideDouble.class }) public ArrayImg<DoubleType, DoubleArray> divide( final ArrayImg<DoubleType, DoubleArray> image, final double value) { @SuppressWarnings("unchecked") final ArrayImg<DoubleType, DoubleArray> result = (ArrayImg<DoubleType, DoubleArray>) ops().run(Ops.Math.Divide.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.DivideFloat.class, net.imagej.ops.math.ConstantToArrayImage.DivideFloat.class }) public ArrayImg<FloatType, FloatArray> divide( final ArrayImg<FloatType, FloatArray> image, final float value) { @SuppressWarnings("unchecked") final ArrayImg<FloatType, FloatArray> result = (ArrayImg<FloatType, FloatArray>) ops().run(Ops.Math.Divide.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.DivideInt.class, net.imagej.ops.math.ConstantToArrayImage.DivideInt.class, net.imagej.ops.math.ConstantToArrayImageP.DivideUnsignedInt.class, net.imagej.ops.math.ConstantToArrayImage.DivideUnsignedInt.class }) public <I extends GenericIntType<I>> ArrayImg<I, IntArray> divide( final ArrayImg<I, IntArray> image, final int value) { @SuppressWarnings("unchecked") final ArrayImg<I, IntArray> result = (ArrayImg<I, IntArray>) ops().run( Ops.Math.Divide.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.DivideLong.class, net.imagej.ops.math.ConstantToArrayImage.DivideLong.class, net.imagej.ops.math.ConstantToArrayImageP.DivideUnsignedLong.class, net.imagej.ops.math.ConstantToArrayImage.DivideUnsignedLong.class }) public <N extends NativeType<N>> ArrayImg<N, LongArray> divide( final ArrayImg<N, LongArray> image, final long value) { @SuppressWarnings("unchecked") final ArrayImg<N, LongArray> result = (ArrayImg<N, LongArray>) ops().run( Ops.Math.Divide.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.DivideShort.class, net.imagej.ops.math.ConstantToArrayImage.DivideShort.class, net.imagej.ops.math.ConstantToArrayImageP.DivideUnsignedShort.class, net.imagej.ops.math.ConstantToArrayImage.DivideUnsignedShort.class }) public <S extends GenericShortType<S>> ArrayImg<S, ShortArray> divide( final ArrayImg<S, ShortArray> image, final short value) { @SuppressWarnings("unchecked") final ArrayImg<S, ShortArray> result = (ArrayImg<S, ShortArray>) ops().run( Ops.Math.Divide.NAME, image, value); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleDivide.class) public double divide(final double a, final double b) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleDivide.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.FloatDivide.class) public float divide(final float a, final float b) { final float result = (Float) ops().run( net.imagej.ops.math.PrimitiveMath.FloatDivide.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.IIToIIOutputII.Divide.class) public <T extends NumericType<T>> IterableInterval<T> divide( final IterableInterval<T> out, final IterableInterval<T> in1, final IterableInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Divide.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.IIToIIOutputII.Divide.class) public <T extends NumericType<T>> IterableInterval<T> divide( final IterableInterval<T> in1, final IterableInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Divide.class, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerDivide.class) public int divide(final int a, final int b) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerDivide.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.IIToRAIOutputII.Divide.class) public <T extends NumericType<T>> IterableInterval<T> divide( final IterableInterval<T> in1, final RandomAccessibleInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Divide.class, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.IIToRAIOutputII.Divide.class) public <T extends NumericType<T>> IterableInterval<T> divide( final IterableInterval<T> out, final IterableInterval<T> in1, final RandomAccessibleInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Divide.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToIIOutputII.Divide.class) public <T extends NumericType<T>> IterableInterval<T> divide( final IterableInterval<T> in, final T value) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Divide.class, in, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToIIOutputII.Divide.class) public <T extends NumericType<T>> IterableInterval<T> divide( final IterableInterval<T> out, final IterableInterval<T> in, final T value) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Divide.class, out, in, value); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongDivide.class) public long divide(final long a, final long b) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongDivide.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.BinaryRealTypeMath.Divide.class) public < I1 extends RealType<I1>, I2 extends RealType<I2>, O extends RealType<O>> O divide(final O out, final I1 in1, final I2 in2, final double dbzVal) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Divide.class, out, in1, in2, dbzVal); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.DivideByte.class, net.imagej.ops.math.ConstantToPlanarImage.DivideUnsignedByte.class }) public <B extends GenericByteType<B>> PlanarImg<B, ByteArray> divide( final PlanarImg<B, ByteArray> image, final byte value) { @SuppressWarnings("unchecked") final PlanarImg<B, ByteArray> result = (PlanarImg<B, ByteArray>) ops().run( Ops.Math.Divide.NAME, image, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToPlanarImage.DivideDouble.class) public PlanarImg<DoubleType, DoubleArray> divide( final PlanarImg<DoubleType, DoubleArray> image, final double value) { @SuppressWarnings("unchecked") final PlanarImg<DoubleType, DoubleArray> result = (PlanarImg<DoubleType, DoubleArray>) ops().run( net.imagej.ops.Ops.Math.Divide.class, image, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToPlanarImage.DivideFloat.class) public PlanarImg<FloatType, FloatArray> divide( final PlanarImg<FloatType, FloatArray> image, final float value) { @SuppressWarnings("unchecked") final PlanarImg<FloatType, FloatArray> result = (PlanarImg<FloatType, FloatArray>) ops().run( net.imagej.ops.Ops.Math.Divide.class, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.DivideInt.class, net.imagej.ops.math.ConstantToPlanarImage.DivideUnsignedInt.class }) public <I extends GenericIntType<I>> PlanarImg<I, IntArray> divide( final PlanarImg<I, IntArray> image, final int value) { @SuppressWarnings("unchecked") final PlanarImg<I, IntArray> result = (PlanarImg<I, IntArray>) ops().run( Ops.Math.Divide.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.DivideLong.class, net.imagej.ops.math.ConstantToPlanarImage.DivideUnsignedLong.class }) public <N extends NativeType<N>> PlanarImg<N, LongArray> divide( final PlanarImg<N, LongArray> image, final long value) { @SuppressWarnings("unchecked") final PlanarImg<N, LongArray> result = (PlanarImg<N, LongArray>) ops().run( Ops.Math.Divide.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.DivideShort.class, net.imagej.ops.math.ConstantToPlanarImage.DivideUnsignedShort.class }) public <S extends GenericShortType<S>> PlanarImg<S, ShortArray> divide( final PlanarImg<S, ShortArray> arg, final short value) { @SuppressWarnings("unchecked") final PlanarImg<S, ShortArray> result = (PlanarImg<S, ShortArray>) ops() .run(Ops.Math.Divide.NAME, arg, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToIIOutputRAI.Divide.class) public <T extends NumericType<T>> RandomAccessibleInterval<T> divide( final RandomAccessibleInterval<T> out, final IterableInterval<T> in, final T value) { @SuppressWarnings("unchecked") final RandomAccessibleInterval<T> result = (RandomAccessibleInterval<T>) ops().run( net.imagej.ops.Ops.Math.Divide.class, out, in, value); return result; } @OpMethod(ops = net.imagej.ops.math.NumericTypeBinaryMath.Divide.class) public <T extends NumericType<T>> T divide(final T in, final T b) { @SuppressWarnings("unchecked") final T result = (T) ops().run(net.imagej.ops.Ops.Math.Divide.class, in, b); return result; } @OpMethod(op = net.imagej.ops.math.NumericTypeBinaryMath.Divide.class) public <T extends NumericType<T>> T divide(final T out, final T in, final T b) { @SuppressWarnings("unchecked") final T result = (T) ops().run(net.imagej.ops.Ops.Math.Divide.class, out, in, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleExp.class) public double exp(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleExp.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Exp.class) public <I extends RealType<I>, O extends RealType<O>> O exp(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Exp.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.ExpMinusOne.class) public <I extends RealType<I>, O extends RealType<O>> O expMinusOne( final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.ExpMinusOne.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleFloor.class) public double floor(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleFloor.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Floor.class) public <I extends RealType<I>, O extends RealType<O>> O floor(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Floor.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.GammaConstant.class) public <I extends RealType<I>, O extends RealType<O>> O gamma(final O out, final I in, final double constant) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Gamma.class, out, in, constant); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Invert.class) public <I extends RealType<I>, O extends RealType<O>> O invert(final O out, final I in, final double specifiedMin, final double specifiedMax) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Invert.class, out, in, specifiedMin, specifiedMax); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerLeftShift.class) public int leftShift(final int a, final int b) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerLeftShift.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongLeftShift.class) public long leftShift(final long a, final long b) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongLeftShift.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleLog.class) public double log(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleLog.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Log.class) public <I extends RealType<I>, O extends RealType<O>> O log(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Log.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleLog10.class) public double log10(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleLog10.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Log10.class) public <I extends RealType<I>, O extends RealType<O>> O log10(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Log10.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Log2.class) public <I extends RealType<I>, O extends RealType<O>> O log2(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Log2.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleLogOnePlusX.class) public double logOnePlusX(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleLogOnePlusX.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.LogOnePlusX.class) public <I extends RealType<I>, O extends RealType<O>> O logOnePlusX( final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.LogOnePlusX.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleMax.class) public double max(final double a, final double b) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleMax.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.FloatMax.class) public float max(final float a, final float b) { final float result = (Float) ops().run( net.imagej.ops.math.PrimitiveMath.FloatMax.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerMax.class) public int max(final int a, final int b) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerMax.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongMax.class) public long max(final long a, final long b) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongMax.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.MaxConstant.class) public <I extends RealType<I>, O extends RealType<O>> O max(final O out, final I in, final double constant) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Max.class, out, in, constant); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleMin.class) public double min(final double a, final double b) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleMin.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.FloatMin.class) public float min(final float a, final float b) { final float result = (Float) ops().run( net.imagej.ops.math.PrimitiveMath.FloatMin.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerMin.class) public int min(final int a, final int b) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerMin.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongMin.class) public long min(final long a, final long b) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongMin.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.MinConstant.class) public <I extends RealType<I>, O extends RealType<O>> O min(final O out, final I in, final double constant) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Min.class, out, in, constant); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.AddByte.class, net.imagej.ops.math.ConstantToArrayImage.AddByte.class, net.imagej.ops.math.ConstantToArrayImageP.AddUnsignedByte.class, net.imagej.ops.math.ConstantToArrayImage.AddUnsignedByte.class }) public <B extends GenericByteType<B>> ArrayImg<B, ByteArray> add( final ArrayImg<B, ByteArray> image, final byte value) { @SuppressWarnings("unchecked") final ArrayImg<B, ByteArray> result = (ArrayImg<B, ByteArray>) ops().run( Ops.Math.Add.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.AddDouble.class, net.imagej.ops.math.ConstantToArrayImage.AddDouble.class }) public ArrayImg<DoubleType, DoubleArray> add( final ArrayImg<DoubleType, DoubleArray> image, final double value) { @SuppressWarnings("unchecked") final ArrayImg<DoubleType, DoubleArray> result = (ArrayImg<DoubleType, DoubleArray>) ops().run(Ops.Math.Add.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.AddFloat.class, net.imagej.ops.math.ConstantToArrayImage.AddFloat.class }) public ArrayImg<FloatType, FloatArray> add( final ArrayImg<FloatType, FloatArray> image, final float value) { @SuppressWarnings("unchecked") final ArrayImg<FloatType, FloatArray> result = (ArrayImg<FloatType, FloatArray>) ops().run(Ops.Math.Add.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.AddInt.class, net.imagej.ops.math.ConstantToArrayImage.AddInt.class, net.imagej.ops.math.ConstantToArrayImageP.AddUnsignedInt.class, net.imagej.ops.math.ConstantToArrayImage.AddUnsignedInt.class }) public <I extends GenericIntType<I>> ArrayImg<I, IntArray> add( final ArrayImg<I, IntArray> image, final int value) { @SuppressWarnings("unchecked") final ArrayImg<I, IntArray> result = (ArrayImg<I, IntArray>) ops().run( Ops.Math.Add.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.AddLong.class, net.imagej.ops.math.ConstantToArrayImage.AddLong.class, net.imagej.ops.math.ConstantToArrayImageP.AddUnsignedLong.class, net.imagej.ops.math.ConstantToArrayImage.AddUnsignedLong.class }) public <N extends NativeType<N>> ArrayImg<N, LongArray> add( final ArrayImg<LongType, LongArray> image, final long value) { @SuppressWarnings("unchecked") final ArrayImg<N, LongArray> result = (ArrayImg<N, LongArray>) ops().run( Ops.Math.Add.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.AddShort.class, net.imagej.ops.math.ConstantToArrayImage.AddShort.class, net.imagej.ops.math.ConstantToArrayImageP.AddUnsignedShort.class, net.imagej.ops.math.ConstantToArrayImage.AddUnsignedShort.class }) public <S extends GenericShortType<S>> ArrayImg<S, ShortArray> add( final ArrayImg<S, ShortArray> image, final short value) { @SuppressWarnings("unchecked") final ArrayImg<S, ShortArray> result = (ArrayImg<S, ShortArray>) ops().run( Ops.Math.Add.NAME, image, value); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleMultiply.class) public double multiply(final double a, final double b) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleMultiply.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.FloatMultiply.class) public float multiply(final float a, final float b) { final float result = (Float) ops().run( net.imagej.ops.math.PrimitiveMath.FloatMultiply.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.IIToIIOutputII.Multiply.class) public <T extends NumericType<T>> IterableInterval<T> multiply( final IterableInterval<T> out, final IterableInterval<T> in1, final IterableInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Multiply.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.IIToIIOutputII.Multiply.class) public <T extends NumericType<T>> IterableInterval<T> multiply( final IterableInterval<T> in1, final IterableInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Multiply.class, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerMultiply.class) public int multiply(final int a, final int b) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerMultiply.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.IIToRAIOutputII.Multiply.class) public <T extends NumericType<T>> IterableInterval<T> multiply( final IterableInterval<T> in1, final RandomAccessibleInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Multiply.class, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.IIToRAIOutputII.Multiply.class) public <T extends NumericType<T>> IterableInterval<T> multiply( final IterableInterval<T> out, final IterableInterval<T> in1, final RandomAccessibleInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Multiply.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToIIOutputII.Multiply.class) public <T extends NumericType<T>> IterableInterval<T> multiply( final IterableInterval<T> in, final T value) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Multiply.class, in, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToIIOutputII.Multiply.class) public <T extends NumericType<T>> IterableInterval<T> multiply( final IterableInterval<T> out, final IterableInterval<T> in, final T value) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Multiply.class, out, in, value); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongMultiply.class) public long multiply(final long a, final long b) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongMultiply.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.BinaryRealTypeMath.Multiply.class) public < I1 extends RealType<I1>, I2 extends RealType<I2>, O extends RealType<O>> O multiply(final O out, final I1 in1, final I2 in2) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Multiply.class, out, in1, in2); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.MultiplyByte.class, net.imagej.ops.math.ConstantToPlanarImage.MultiplyUnsignedByte.class }) public <B extends GenericByteType<B>> PlanarImg<B, ByteArray> multiply( final PlanarImg<B, ByteArray> image, final byte value) { @SuppressWarnings("unchecked") final PlanarImg<B, ByteArray> result = (PlanarImg<B, ByteArray>) ops().run( Ops.Math.Divide.NAME, image, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToPlanarImage.MultiplyDouble.class) public PlanarImg<DoubleType, DoubleArray> multiply( final PlanarImg<DoubleType, DoubleArray> image, final double value) { @SuppressWarnings("unchecked") final PlanarImg<DoubleType, DoubleArray> result = (PlanarImg<DoubleType, DoubleArray>) ops().run( net.imagej.ops.Ops.Math.Multiply.class, image, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToPlanarImage.MultiplyFloat.class) public PlanarImg<FloatType, FloatArray> multiply( final PlanarImg<FloatType, FloatArray> image, final float value) { @SuppressWarnings("unchecked") final PlanarImg<FloatType, FloatArray> result = (PlanarImg<FloatType, FloatArray>) ops().run( net.imagej.ops.Ops.Math.Multiply.class, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.MultiplyInt.class, net.imagej.ops.math.ConstantToPlanarImage.MultiplyUnsignedInt.class }) public <I extends GenericIntType<I>> PlanarImg<I, IntArray> multiply( final PlanarImg<I, IntArray> image, final int value) { @SuppressWarnings("unchecked") final PlanarImg<I, IntArray> result = (PlanarImg<I, IntArray>) ops().run( Ops.Math.Multiply.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.MultiplyLong.class, net.imagej.ops.math.ConstantToPlanarImage.MultiplyUnsignedLong.class }) public <N extends NativeType<N>> PlanarImg<N, LongArray> multiply( final PlanarImg<N, LongArray> image, final long value) { @SuppressWarnings("unchecked") final PlanarImg<N, LongArray> result = (PlanarImg<N, LongArray>) ops().run( Ops.Math.Multiply.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.MultiplyShort.class, net.imagej.ops.math.ConstantToPlanarImage.MultiplyUnsignedShort.class }) public <S extends GenericShortType<S>> PlanarImg<S, ShortArray> multiply( final PlanarImg<S, ShortArray> arg, final short value) { @SuppressWarnings("unchecked") final PlanarImg<S, ShortArray> result = (PlanarImg<S, ShortArray>) ops() .run(Ops.Math.Multiply.NAME, arg, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToIIOutputRAI.Multiply.class) public <T extends NumericType<T>> RandomAccessibleInterval<T> multiply( final RandomAccessibleInterval<T> out, final IterableInterval<T> in, final T value) { @SuppressWarnings("unchecked") final RandomAccessibleInterval<T> result = (RandomAccessibleInterval<T>) ops().run( net.imagej.ops.Ops.Math.Multiply.class, out, in, value); return result; } @OpMethod(op = net.imagej.ops.math.NumericTypeBinaryMath.Multiply.class) public <T extends NumericType<T>> T multiply(final T in, final T b) { @SuppressWarnings("unchecked") final T result = (T) ops().run(net.imagej.ops.Ops.Math.Multiply.class, in, b); return result; } @OpMethod(op = net.imagej.ops.math.NumericTypeBinaryMath.Multiply.class) public <T extends NumericType<T>> T multiply(final T out, final T in1, final T in2) { @SuppressWarnings("unchecked") final T result = (T) ops().run(net.imagej.ops.Ops.Math.Multiply.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.NearestInt.class) public <I extends RealType<I>, O extends RealType<O>> O nearestInt( final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.NearestInt.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleNegate.class) public double negate(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleNegate.class, a); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.FloatNegate.class) public float negate(final float a) { final float result = (Float) ops().run( net.imagej.ops.math.PrimitiveMath.FloatNegate.class, a); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerNegate.class) public int negate(final int a) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerNegate.class, a); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongNegate.class) public long negate(final long a) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongNegate.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Negate.class) public <I extends RealType<I>, O extends RealType<O>> O negate(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Negate.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerOr.class) public int or(final int a, final int b) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerOr.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongOr.class) public long or(final long a, final long b) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongOr.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.BinaryRealTypeMath.Or.class) public < I1 extends RealType<I1>, I2 extends RealType<I2>, O extends RealType<O>> O or(final O out, final I1 in1, final I2 in2) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Or.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoublePower.class) public double power(final double a, final double b) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoublePower.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.PowerConstant.class) public <I extends RealType<I>, O extends RealType<O>> O power(final O out, final I in, final double constant) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Power.class, out, in, constant); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.RandomGaussian.class) public <I extends RealType<I>, O extends RealType<O>> O randomGaussian( final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.RandomGaussian.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.RandomGaussian.class) public <I extends RealType<I>, O extends RealType<O>> O randomGaussian( final O out, final I in, final long seed) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.RandomGaussian.class, out, in, seed); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.RandomUniform.class) public <I extends RealType<I>, O extends RealType<O>> O randomUniform( final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.RandomUniform.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.RandomUniform.class) public <I extends RealType<I>, O extends RealType<O>> O randomUniform( final O out, final I in, final long seed) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.RandomUniform.class, out, in, seed); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Reciprocal.class) public <I extends RealType<I>, O extends RealType<O>> O reciprocal( final O out, final I in, final double dbzVal) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Reciprocal.class, out, in, dbzVal); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleRemainder.class) public double remainder(final double a, final double b) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleRemainder.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.FloatRemainder.class) public float remainder(final float a, final float b) { final float result = (Float) ops().run( net.imagej.ops.math.PrimitiveMath.FloatRemainder.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerRemainder.class) public int remainder(final int a, final int b) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerRemainder.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongRemainder.class) public long remainder(final long a, final long b) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongRemainder.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerRightShift.class) public int rightShift(final int a, final int b) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerRightShift.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongRightShift.class) public long rightShift(final long a, final long b) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongRightShift.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleRound.class) public double round(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleRound.class, a); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.FloatRound.class) public float round(final float a) { final float result = (Float) ops().run( net.imagej.ops.math.PrimitiveMath.FloatRound.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Round.class) public <I extends RealType<I>, O extends RealType<O>> O round(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Round.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Sec.class) public <I extends RealType<I>, O extends RealType<O>> O sec(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Sec.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Sech.class) public <I extends RealType<I>, O extends RealType<O>> O sech(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Sech.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleSignum.class) public double signum(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleSignum.class, a); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.FloatSignum.class) public float signum(final float a) { final float result = (Float) ops().run( net.imagej.ops.math.PrimitiveMath.FloatSignum.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Signum.class) public <I extends RealType<I>, O extends RealType<O>> O signum(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Signum.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleSin.class) public double sin(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleSin.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Sin.class) public <I extends RealType<I>, O extends RealType<O>> O sin(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Sin.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Sinc.class) public <I extends RealType<I>, O extends RealType<O>> O sinc(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Sinc.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.SincPi.class) public <I extends RealType<I>, O extends RealType<O>> O sincPi(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.SincPi.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleSinh.class) public double sinh(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleSinh.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Sinh.class) public <I extends RealType<I>, O extends RealType<O>> O sinh(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Sinh.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Sqr.class) public <I extends RealType<I>, O extends RealType<O>> O sqr(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Sqr.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleSqrt.class) public double sqrt(final double a) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleSqrt.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Sqrt.class) public <I extends RealType<I>, O extends RealType<O>> O sqrt(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Sqrt.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Step.class) public <I extends RealType<I>, O extends RealType<O>> O step(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Step.class, out, in); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.SubtractByte.class, net.imagej.ops.math.ConstantToArrayImage.SubtractByte.class, net.imagej.ops.math.ConstantToArrayImageP.SubtractUnsignedByte.class, net.imagej.ops.math.ConstantToArrayImage.SubtractUnsignedByte.class }) public <B extends GenericByteType<B>> ArrayImg<B, ByteArray> subtract( final ArrayImg<B, ByteArray> image, final byte value) { @SuppressWarnings("unchecked") final ArrayImg<B, ByteArray> result = (ArrayImg<B, ByteArray>) ops().run( Ops.Math.Subtract.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.SubtractDouble.class, net.imagej.ops.math.ConstantToArrayImage.SubtractDouble.class }) public ArrayImg<DoubleType, DoubleArray> subtract( final ArrayImg<DoubleType, DoubleArray> image, final double value) { @SuppressWarnings("unchecked") final ArrayImg<DoubleType, DoubleArray> result = (ArrayImg<DoubleType, DoubleArray>) ops().run(Ops.Math.Subtract.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.SubtractFloat.class, net.imagej.ops.math.ConstantToArrayImage.SubtractFloat.class }) public ArrayImg<FloatType, FloatArray> subtract( final ArrayImg<FloatType, FloatArray> image, final float value) { @SuppressWarnings("unchecked") final ArrayImg<FloatType, FloatArray> result = (ArrayImg<FloatType, FloatArray>) ops().run(Ops.Math.Subtract.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.SubtractInt.class, net.imagej.ops.math.ConstantToArrayImage.SubtractInt.class, net.imagej.ops.math.ConstantToArrayImageP.SubtractUnsignedInt.class, net.imagej.ops.math.ConstantToArrayImage.SubtractUnsignedInt.class }) public <I extends GenericIntType<I>> ArrayImg<I, IntArray> subtract( final ArrayImg<I, IntArray> image, final int value) { @SuppressWarnings("unchecked") final ArrayImg<I, IntArray> result = (ArrayImg<I, IntArray>) ops().run( Ops.Math.Subtract.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.SubtractLong.class, net.imagej.ops.math.ConstantToArrayImage.SubtractLong.class, net.imagej.ops.math.ConstantToArrayImageP.SubtractUnsignedLong.class, net.imagej.ops.math.ConstantToArrayImage.SubtractUnsignedLong.class }) public <N extends NativeType<N>> ArrayImg<N, LongArray> subtract( final ArrayImg<N, LongArray> image, final long value) { @SuppressWarnings("unchecked") final ArrayImg<N, LongArray> result = (ArrayImg<N, LongArray>) ops().run( Ops.Math.Subtract.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToArrayImageP.SubtractShort.class, net.imagej.ops.math.ConstantToArrayImage.SubtractShort.class, net.imagej.ops.math.ConstantToArrayImageP.SubtractUnsignedShort.class, net.imagej.ops.math.ConstantToArrayImage.SubtractUnsignedShort.class }) public <S extends GenericShortType<S>> ArrayImg<S, ShortArray> subtract( final ArrayImg<S, ShortArray> image, final short value) { @SuppressWarnings("unchecked") final ArrayImg<S, ShortArray> result = (ArrayImg<S, ShortArray>) ops().run( Ops.Math.Subtract.NAME, image, value); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleSubtract.class) public double subtract(final double a, final double b) { final double result = (Double) ops().run( net.imagej.ops.math.PrimitiveMath.DoubleSubtract.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.FloatSubtract.class) public float subtract(final float a, final float b) { final float result = (Float) ops().run( net.imagej.ops.math.PrimitiveMath.FloatSubtract.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.IIToIIOutputII.Subtract.class) public <T extends NumericType<T>> IterableInterval<T> subtract( final IterableInterval<T> out, final IterableInterval<T> in1, final IterableInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Subtract.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.IIToIIOutputII.Subtract.class) public <T extends NumericType<T>> IterableInterval<T> subtract( final IterableInterval<T> in1, final IterableInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Subtract.class, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerSubtract.class) public int subtract(final int a, final int b) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerSubtract.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.IIToRAIOutputII.Subtract.class) public <T extends NumericType<T>> IterableInterval<T> subtract( final IterableInterval<T> in1, final RandomAccessibleInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Subtract.class, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.IIToRAIOutputII.Subtract.class) public <T extends NumericType<T>> IterableInterval<T> subtract( final IterableInterval<T> out, final IterableInterval<T> in1, final RandomAccessibleInterval<T> in2) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Subtract.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToIIOutputII.Subtract.class) public <T extends NumericType<T>> IterableInterval<T> subtract( final IterableInterval<T> in, final T value) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Subtract.class, in, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToIIOutputII.Subtract.class) public <T extends NumericType<T>> IterableInterval<T> subtract( final IterableInterval<T> out, final IterableInterval<T> in, final T value) { @SuppressWarnings("unchecked") final IterableInterval<T> result = (IterableInterval<T>) ops().run( net.imagej.ops.Ops.Math.Subtract.class, out, in, value); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongSubtract.class) public long subtract(final long a, final long b) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongSubtract.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.BinaryRealTypeMath.Subtract.class) public < I1 extends RealType<I1>, I2 extends RealType<I2>, O extends RealType<O>> O subtract(final O out, final I1 in1, final I2 in2) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Subtract.class, out, in1, in2); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.SubtractByte.class, net.imagej.ops.math.ConstantToPlanarImage.SubtractUnsignedByte.class }) public <B extends GenericByteType<B>> PlanarImg<B, ByteArray> subtract( final PlanarImg<B, ByteArray> image, final byte value) { @SuppressWarnings("unchecked") final PlanarImg<B, ByteArray> result = (PlanarImg<B, ByteArray>) ops().run( Ops.Math.Subtract.NAME, image, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToPlanarImage.SubtractDouble.class) public PlanarImg<DoubleType, DoubleArray> subtract( final PlanarImg<DoubleType, DoubleArray> image, final double value) { @SuppressWarnings("unchecked") final PlanarImg<DoubleType, DoubleArray> result = (PlanarImg<DoubleType, DoubleArray>) ops().run( net.imagej.ops.Ops.Math.Subtract.class, image, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToPlanarImage.SubtractFloat.class) public PlanarImg<FloatType, FloatArray> subtract( final PlanarImg<FloatType, FloatArray> image, final float value) { @SuppressWarnings("unchecked") final PlanarImg<FloatType, FloatArray> result = (PlanarImg<FloatType, FloatArray>) ops().run( net.imagej.ops.Ops.Math.Subtract.class, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.SubtractInt.class, net.imagej.ops.math.ConstantToPlanarImage.SubtractUnsignedInt.class }) public <I extends GenericIntType<I>> PlanarImg<I, IntArray> subtract( final PlanarImg<I, IntArray> image, final int value) { @SuppressWarnings("unchecked") final PlanarImg<I, IntArray> result = (PlanarImg<I, IntArray>) ops().run( Ops.Math.Subtract.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.SubtractLong.class, net.imagej.ops.math.ConstantToPlanarImage.SubtractUnsignedLong.class }) public <N extends NativeType<N>, A extends ArrayDataAccess<A>> PlanarImg<N, A> subtract(final PlanarImg<N, A> image, final long value) { @SuppressWarnings("unchecked") final PlanarImg<N, A> result = (PlanarImg<N, A>) ops().run( Ops.Math.Subtract.NAME, image, value); return result; } @OpMethod(ops = { net.imagej.ops.math.ConstantToPlanarImage.SubtractShort.class, net.imagej.ops.math.ConstantToPlanarImage.SubtractUnsignedShort.class }) public <S extends GenericShortType<S>> PlanarImg<S, ShortArray> subtract( final PlanarImg<S, ShortArray> image, final short value) { @SuppressWarnings("unchecked") final PlanarImg<S, ShortArray> result = (PlanarImg<S, ShortArray>) ops() .run(Ops.Math.Subtract.NAME, image, value); return result; } @OpMethod(op = net.imagej.ops.math.ConstantToIIOutputRAI.Subtract.class) public <T extends NumericType<T>> RandomAccessibleInterval<T> subtract( final RandomAccessibleInterval<T> out, final IterableInterval<T> in, final T value) { @SuppressWarnings("unchecked") final RandomAccessibleInterval<T> result = (RandomAccessibleInterval<T>) ops().run( net.imagej.ops.Ops.Math.Subtract.class, out, in, value); return result; } @OpMethod(op = net.imagej.ops.math.NumericTypeBinaryMath.Subtract.class) public <T extends NumericType<T>> T subtract(final T in, final T b) { @SuppressWarnings("unchecked") final T result = (T) ops().run(net.imagej.ops.Ops.Math.Subtract.class, in, b); return result; } @OpMethod(op = net.imagej.ops.math.NumericTypeBinaryMath.Subtract.class) public <T extends NumericType<T>> T subtract(final T out, final T in1, final T in2) { @SuppressWarnings("unchecked") final T result = (T) ops().run(net.imagej.ops.Ops.Math.Subtract.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleTan.class) public double tan(final double a) { final double result = (Double) ops().run(net.imagej.ops.Ops.Math.Tan.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Tan.class) public <I extends RealType<I>, O extends RealType<O>> O tan(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Tan.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.DoubleTanh.class) public double tanh(final double a) { final double result = (Double) ops().run(net.imagej.ops.Ops.Math.Tanh.class, a); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Tanh.class) public <I extends RealType<I>, O extends RealType<O>> O tanh(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Tanh.class, out, in); return result; } @OpMethod(op = net.imagej.ops.math.UnaryRealTypeMath.Ulp.class) public <I extends RealType<I>, O extends RealType<O>> O ulp(final O out, final I in) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Ulp.class, out, in); return result; } @OpMethod( op = net.imagej.ops.math.PrimitiveMath.IntegerUnsignedRightShift.class) public int unsignedRightShift(final int a, final int b) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerUnsignedRightShift.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongUnsignedRightShift.class) public long unsignedRightShift(final long a, final long b) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongUnsignedRightShift.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.IntegerXor.class) public int xor(final int a, final int b) { final int result = (Integer) ops().run( net.imagej.ops.math.PrimitiveMath.IntegerXor.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.PrimitiveMath.LongXor.class) public long xor(final long a, final long b) { final long result = (Long) ops().run( net.imagej.ops.math.PrimitiveMath.LongXor.class, a, b); return result; } @OpMethod(op = net.imagej.ops.math.BinaryRealTypeMath.Xor.class) public < I1 extends RealType<I1>, I2 extends RealType<I2>, O extends RealType<O>> O xor(final O out, final I1 in1, final I2 in2) { @SuppressWarnings("unchecked") final O result = (O) ops().run(net.imagej.ops.Ops.Math.Xor.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.NullaryNumericTypeMath.Zero.class) public <T extends NumericType<T>> T zero(final T out) { @SuppressWarnings("unchecked") final T result = (T) ops().run(net.imagej.ops.Ops.Math.Zero.class, out); return result; } @OpMethod(ops = { net.imagej.ops.math.multiply.ComplexConjugateMultiplyMap.class }) public <I extends RealType<I>, O extends RealType<O>> IterableInterval<O> complexConjugateMultiply(final IterableInterval<O> out, final IterableInterval<I> in1, final IterableInterval<I> in2) { @SuppressWarnings("unchecked") final IterableInterval<O> result = (IterableInterval<O>) ops().run( net.imagej.ops.Ops.Math.ComplexConjugateMultiply.class, out, in1, in2); return result; } @OpMethod(op = net.imagej.ops.math.multiply.ComplexConjugateMultiplyOp.class) public <C extends ComplexType<C>> C complexConjugateMultiply(final C in1, final C in2, final C out) { @SuppressWarnings("unchecked") final C result = (C) ops().run( net.imagej.ops.math.multiply.ComplexConjugateMultiplyOp.class, out, in1, in2); return result; } // -- Named methods -- @Override public String getName() { return "math"; } }