gt: 	T mul(long other);
context: /*
   * This file is part of the Raster Storage Archive (RSA).
   *
   * The RSA is free software: you can redistribute it and/or modify it under the
   * terms of the GNU General Public License as published by the Free Software
   * Foundation, either version 3 of the License, or (at your option) any later
   * version.
   *
   * The RSA is distributed in the hope that it will be useful, but WITHOUT ANY
   * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   * A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License along with
   * the RSA.  If not, see <http://www.gnu.org/licenses/>.
   *
   * Copyright 2013 CRCSI - Cooperative Research Centre for Spatial Information
   * http://www.crcsi.com.au/
   */
  
  // THIS IS GENERATED CODE. Do not modify this file. See Element_gen.py
  
  package org.vpac.ndg.query.math;
  
  /**
   * A numeric value.
   *
   * <p><img src="doc-files/Element_class.png" /></p>
   *
   * @author Alex Fraser
   */
  public interface Element<T extends Element<?>> {
  	/**
  	 * @return A new copy of this element.
  	 */
  	T copy();
  
  	/**
  	 * @return true if this element contains valid data. Data may be marked as
  	 * invalid if it is read from a <em>nodata</em> pixel, or as the result of
  	 * failed arithmetic e.g. divide by zero.
  	 */
  	boolean isValid();
  	void setValid(boolean valid);
  	void setValid(Element<?> mask);
  	void setValidIfValid(Element<?> mask);
  
  	ScalarElement[] getComponents();
  	/**
  	 * @return The number of components in this vector.
  	 */
  	public int size();
  
  	// CASTING
  
  	/**
  	 * Set this element to the given value. This also marks the element as
  	 * valid.
  	 * @param value The value to assign to this element. It will be cast to the
  	 * same type as this element.
  	 * @return A reference to this element (does not create a new instance).
  	 */
  	T set(byte value);
  	/**
  	 * Set this element to the given value. This also marks the element as
  	 * valid.
  	 * @param value The value to assign to this element. It will be cast to the
  	 * same type as this element.
  	 * @return A reference to this element (does not create a new instance).
  	 */
  	T set(short value);
  	/**
  	 * Set this element to the given value. This also marks the element as
  	 * valid.
  	 * @param value The value to assign to this element. It will be cast to the
  	 * same type as this element.
  	 * @return A reference to this element (does not create a new instance).
  	 */
  	T set(int value);
  	/**
  	 * Set this element to the given value. This also marks the element as
  	 * valid.
  	 * @param value The value to assign to this element. It will be cast to the
  	 * same type as this element.
  	 * @return A reference to this element (does not create a new instance).
  	 */
  	T set(long value);
  	/**
  	 * Set this element to the given value. This also marks the element as
  	 * valid.
  	 * @param value The value to assign to this element. It will be cast to the
  	 * same type as this element.
  	 * @return A reference to this element (does not create a new instance).
  	 */
  	T set(float value);
  	/**
  	 * Set this element to the given value. This also marks the element as
  	 * valid.
  	 * @param value The value to assign to this element. It will be cast to the
  	 * same type as this element.
  	 * @return A reference to this element (does not create a new instance).
  	 */
  	T set(double value);
  	/**
  	 * Set this element to the given value. Validity will be inherited from the
  	 * supplied element.
  	 * @param value The value to assign to this element. It will be cast to the
  	 * same type as this element.
  	 * @return A reference to this element (does not create a new instance).
  	 */
  	T set(Element<?> value);
  	/**
  	 * Set this element to the given value. This also marks the element as
  	 * valid.
  	 * @param value The value to assign to this element. It will be cast to the
  	 * same type as this element.
  	 * @return A reference to this element (does not create a new instance).
  	 */
  	T set(Number value);
  
  	/**
  	 * Reinterpret this element as byte data. Note: this creates a new
  	 * instance. It is faster to assign a value to an existing instance; see
  	 * {@link #set(Element)}.
  	 * @return A new element with the same rank as this one.
  	 */
  	Element<?> asByte();
  	/**
  	 * Reinterpret this element as short data. Note: this creates a new
  	 * instance. It is faster to assign a value to an existing instance; see
  	 * {@link #set(Element)}.
  	 * @return A new element with the same rank as this one.
  	 */
  	Element<?> asShort();
  	/**
  	 * Reinterpret this element as int data. Note: this creates a new
  	 * instance. It is faster to assign a value to an existing instance; see
  	 * {@link #set(Element)}.
  	 * @return A new element with the same rank as this one.
  	 */
  	Element<?> asInt();
  	/**
  	 * Reinterpret this element as long data. Note: this creates a new
  	 * instance. It is faster to assign a value to an existing instance; see
  	 * {@link #set(Element)}.
  	 * @return A new element with the same rank as this one.
  	 */
  	Element<?> asLong();
  	/**
  	 * Reinterpret this element as float data. Note: this creates a new
  	 * instance. It is faster to assign a value to an existing instance; see
  	 * {@link #set(Element)}.
  	 * @return A new element with the same rank as this one.
  	 */
  	Element<?> asFloat();
  	/**
  	 * Reinterpret this element as double data. Note: this creates a new
  	 * instance. It is faster to assign a value to an existing instance; see
  	 * {@link #set(Element)}.
  	 * @return A new element with the same rank as this one.
  	 */
  	Element<?> asDouble();
  
  	/**
  	 * Set this element's value(s) to the minimum possible value for its storage
  	 * type (e.g. -128 if the storage type is byte).
  	 * @return A reference to this element (does not create a new instance).
  	 */
  	T minimise();
  	/**
  	 * Set this element's value(s) to the maximum possible value for its storage
  	 * type (e.g. 127 if the storage type is byte).
  	 * @return A reference to this element (does not create a new instance).
  	 */
  	T maximise();
  
  	// ARITHMETIC
  
  	/**
  	 * Add a value to this one.
  	 *
  	 * @param other The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T add(long other);
  	/**
  	 * Add a value to this one.
  	 *
  	 * @param other The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T add(double other);
  	/**
  	 * Add a value to this one.
  	 *
  	 * @param other The value to add. If this value is invalid, this
  	 *        element will also be marked as invalid (for vectors, this is done
  	 *        on a component-by-component basis).
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T add(Element<?> other);
  
  	/**
  	 * Add a value to this one, unless the mask is invalid.
  	 *
  	 * @param other The value to add.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addIfValid(long other, Element<?> mask);
  	/**
  	 * Add a value to this one, unless the mask is invalid.
  	 *
  	 * @param other The value to add.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addIfValid(double other, Element<?> mask);
  	/**
  	 * Add a value to this one, unless it is invalid.
  	 *
  	 * @param other The value to add. If this value is invalid, it will be
  	 *        ignored (the operation will not take place).
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addIfValid(Element<?> other);
  	/**
  	 * Add a value to this one, unless it or the mask is
  	 * invalid.
  	 *
  	 * @param other The value to add. If this value is invalid, it will be
  	 *        ignored (the operation will not take place).
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addIfValid(Element<?> other, Element<?> mask);
  
  	/**
  	 * Add a value to this one.
  	 *
  	 * @param other The value to add.
  	 * @return The result as a new object.
  	 */
  	T addNew(long other);
  	/**
  	 * Add a value to this one.
  	 *
  	 * @param other The value to add. If this value is invalid, this
  	 *        element will also be marked as invalid (for vectors, this is done
  	 *        on a component-by-component basis).
  	 * @return The result as a new object.
  	 */
  	T addNew(double other);
  	/**
  	 * Add a value to this one.
  	 *
  	 * @param other The value to add. If this value is invalid, this
  	 *        element will also be marked as invalid (for vectors, this is done
  	 *        on a component-by-component basis).
  	 * @return The result as a new object.
  	 */
  	T addNew(Element<?> other);
  
  	/**
  	 * Add a value to this one, unless the mask is invalid.
  	 *
  	 * @param other The value to add.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return The result as a new object.
  	 */
  	T addNewIfValid(long other, Element<?> mask);
  	/**
  	 * Add a value to this one, unless the mask is invalid.
  	 *
  	 * @param other The value to add.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return The result as a new object.
  	 */
  	T addNewIfValid(double other, Element<?> mask);
  	/**
  	 * Add a value to this one, unless it is invalid.
  	 *
  	 * @param other The value to add. If this value is invalid, it will be
  	 *        ignored (the operation will not take place).
  	 * @return The result as a new object.
  	 */
  	T addNewIfValid(Element<?> other);
  	/**
  	 * Add a value to this one, unless it or the mask is
  	 * invalid.
  	 *
  	 * @param other The value to add. If this value is invalid, it will be
  	 *        ignored (the operation will not take place).
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return The result as a new object.
  	 */
  	T addNewIfValid(Element<?> other, Element<?> mask);
  
  	/**
  	 * Add two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOf(long a, long b);
  	/**
  	 * Add two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOf(double a, long b);
  	/**
  	 * Add two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOf(long a, double b);
  	/**
  	 * Add two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOf(double a, double b);
  	/**
  	 * Add two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOf(Element<?> a, long b);
  	/**
  	 * Add two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOf(long a, Element<?> b);
  	/**
  	 * Add two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOf(Element<?> a, double b);
  	/**
  	 * Add two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOf(double a, Element<?> b);
  	/**
  	 * Add two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOf(Element<?> a, Element<?> b);
  
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless the mask is invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(long a, long b, Element<?> mask);
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless the mask is invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(double a, long b, Element<?> mask);
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless the mask is invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(long a, double b, Element<?> mask);
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless the mask is invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(double a, double b, Element<?> mask);
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless any of the values are invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(Element<?> a, long b);
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless any of the values or the mask are invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(Element<?> a, long b, Element<?> mask);
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless any of the values are invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(long a, Element<?> b);
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless any of the values or the mask are invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(long a, Element<?> b, Element<?> mask);
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless any of the values are invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(Element<?> a, double b);
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless any of the values or the mask are invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(Element<?> a, double b, Element<?> mask);
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless any of the values are invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(double a, Element<?> b);
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless any of the values or the mask are invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(double a, Element<?> b, Element<?> mask);
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless any of the values are invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(Element<?> a, Element<?> b);
  	/**
  	 * Add two values, storing the result in this (third) instance,
  	 * unless any of the values or the mask are invalid.
  	 *
  	 * @param a The value to add to.
  	 * @param b The value to add.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T addOfIfValid(Element<?> a, Element<?> b, Element<?> mask);
  
  	/**
  	 * Subtract a value from this one.
  	 *
  	 * @param other The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T sub(long other);
  	/**
  	 * Subtract a value from this one.
  	 *
  	 * @param other The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T sub(double other);
  	/**
  	 * Subtract a value from this one.
  	 *
  	 * @param other The value to subtract. If this value is invalid, this
  	 *        element will also be marked as invalid (for vectors, this is done
  	 *        on a component-by-component basis).
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T sub(Element<?> other);
  
  	/**
  	 * Subtract a value from this one, unless the mask is invalid.
  	 *
  	 * @param other The value to subtract.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subIfValid(long other, Element<?> mask);
  	/**
  	 * Subtract a value from this one, unless the mask is invalid.
  	 *
  	 * @param other The value to subtract.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subIfValid(double other, Element<?> mask);
  	/**
  	 * Subtract a value from this one, unless it is invalid.
  	 *
  	 * @param other The value to subtract. If this value is invalid, it will be
  	 *        ignored (the operation will not take place).
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subIfValid(Element<?> other);
  	/**
  	 * Subtract a value from this one, unless it or the mask is
  	 * invalid.
  	 *
  	 * @param other The value to subtract. If this value is invalid, it will be
  	 *        ignored (the operation will not take place).
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subIfValid(Element<?> other, Element<?> mask);
  
  	/**
  	 * Subtract a value from this one.
  	 *
  	 * @param other The value to subtract.
  	 * @return The result as a new object.
  	 */
  	T subNew(long other);
  	/**
  	 * Subtract a value from this one.
  	 *
  	 * @param other The value to subtract. If this value is invalid, this
  	 *        element will also be marked as invalid (for vectors, this is done
  	 *        on a component-by-component basis).
  	 * @return The result as a new object.
  	 */
  	T subNew(double other);
  	/**
  	 * Subtract a value from this one.
  	 *
  	 * @param other The value to subtract. If this value is invalid, this
  	 *        element will also be marked as invalid (for vectors, this is done
  	 *        on a component-by-component basis).
  	 * @return The result as a new object.
  	 */
  	T subNew(Element<?> other);
  
  	/**
  	 * Subtract a value from this one, unless the mask is invalid.
  	 *
  	 * @param other The value to subtract.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return The result as a new object.
  	 */
  	T subNewIfValid(long other, Element<?> mask);
  	/**
  	 * Subtract a value from this one, unless the mask is invalid.
  	 *
  	 * @param other The value to subtract.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return The result as a new object.
  	 */
  	T subNewIfValid(double other, Element<?> mask);
  	/**
  	 * Subtract a value from this one, unless it is invalid.
  	 *
  	 * @param other The value to subtract. If this value is invalid, it will be
  	 *        ignored (the operation will not take place).
  	 * @return The result as a new object.
  	 */
  	T subNewIfValid(Element<?> other);
  	/**
  	 * Subtract a value from this one, unless it or the mask is
  	 * invalid.
  	 *
  	 * @param other The value to subtract. If this value is invalid, it will be
  	 *        ignored (the operation will not take place).
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return The result as a new object.
  	 */
  	T subNewIfValid(Element<?> other, Element<?> mask);
  
  	/**
  	 * Subtract two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOf(long a, long b);
  	/**
  	 * Subtract two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOf(double a, long b);
  	/**
  	 * Subtract two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOf(long a, double b);
  	/**
  	 * Subtract two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOf(double a, double b);
  	/**
  	 * Subtract two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOf(Element<?> a, long b);
  	/**
  	 * Subtract two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOf(long a, Element<?> b);
  	/**
  	 * Subtract two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOf(Element<?> a, double b);
  	/**
  	 * Subtract two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOf(double a, Element<?> b);
  	/**
  	 * Subtract two values, storing the result in this (third) instance.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOf(Element<?> a, Element<?> b);
  
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless the mask is invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(long a, long b, Element<?> mask);
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless the mask is invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(double a, long b, Element<?> mask);
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless the mask is invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(long a, double b, Element<?> mask);
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless the mask is invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(double a, double b, Element<?> mask);
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless any of the values are invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(Element<?> a, long b);
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless any of the values or the mask are invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(Element<?> a, long b, Element<?> mask);
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless any of the values are invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(long a, Element<?> b);
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless any of the values or the mask are invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(long a, Element<?> b, Element<?> mask);
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless any of the values are invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(Element<?> a, double b);
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless any of the values or the mask are invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(Element<?> a, double b, Element<?> mask);
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless any of the values are invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(double a, Element<?> b);
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless any of the values or the mask are invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(double a, Element<?> b, Element<?> mask);
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless any of the values are invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(Element<?> a, Element<?> b);
  	/**
  	 * Subtract two values, storing the result in this (third) instance,
  	 * unless any of the values or the mask are invalid.
  	 *
  	 * @param a The value to subtract from.
  	 * @param b The value to subtract.
  	 * @param mask A mask to use for the operation. If this is invalid, the
  	 *        operation will not take place.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  	T subOfIfValid(Element<?> a, Element<?> b, Element<?> mask);
  
  	/**
  	 * Multiply a value with this one.
  	 *
  	 * @param other The value to multiply.
  	 * @return A reference to this object. Note that this method does not create
  	 *         a new instance.
  	 */
  