/* (non-Javadoc)
@see org.joml.Matrix3fc#sub(org.joml.Matrix3fc, org.joml.Matrix3f)
165722
public Matrix3f sub(Matrix3fc subtrahend, Matrix3f dest) {
        dest.m00 = m00 - subtrahend.m00();
        dest.m01 = m01 - subtrahend.m01();
        dest.m02 = m02 - subtrahend.m02();
        dest.m10 = m10 - subtrahend.m10();
        dest.m11 = m11 - subtrahend.m11();
        dest.m12 = m12 - subtrahend.m12();
        dest.m20 = m20 - subtrahend.m20();
        dest.m21 = m21 - subtrahend.m21();
        dest.m22 = m22 - subtrahend.m22();
        return dest;
    }
689321
public static <T> List<T> sub(List<T> list, int start, int end, int step) {
		if (list == null || list.isEmpty()) {
			return null;
		}

		final int size = list.size();
		if (start < 0) {
			start += size;
		}
		if (end < 0) {
			end += size;
		}
		if (start == size) {
			return new ArrayList<>(0);
		}
		if (start > end) {
			int tmp = start;
			start = end;
			end = tmp;
		}
		if (end > size) {
			if (start >= size) {
				return new ArrayList<>(0);
			}
			end = size;
		}

		if (step <= 1) {
			return list.subList(start, end);
		}

		final List<T> result = new ArrayList<>();
		for (int i = start; i < end; i += step) {
			result.add(list.get(i));
		}
		return result;
	}
294026
function subBytes()
    {

        for ($i = 0; $i < 4; $i++) {
            for ($j = 0; $j < $this->Nb; $j++) $this->s[$i][$j] = $this->sBox[$this->s[$i][$j]];
        }
    }
223421
public Vector3i sub(Vector3ic v) {
        return sub(v.x(), v.y(), v.z(), thisOrNew());
    }
360310
def _internal_sub(self, other, method=None):
        
        if hasattr(other, "datatype"):
            if other.datatype == self.datatype:
                oval = other.value
            else:
                oval = int(other.value)
        else:
            oval = int(other)
        if method == 'rsub':
            rtn_val = oval - self.value
        else:
            rtn_val = self.value - oval
        return XsdInteger(rtn_val)
1033406
public static byte[] sub(byte[] b, int off, int len) {
		byte[] result = new byte[len];
		System.arraycopy(b, off, result, 0, len);
		return result;
	}
1206678
function sub(a, b){
    return Vector3(a.x-b.x, a.y-b.y, a.z-b.z);
  }
300683
public static INDArray sub(INDArray x, INDArray y, INDArray z, int... dimensions) {
        if(dimensions == null || dimensions.length == 0) {
            validateShapesNoDimCase(x,y,z);
            return Nd4j.getExecutioner().exec(new OldSubOp(x,y,z));
        }

        return Nd4j.getExecutioner().exec(new BroadcastSubOp(x,y,z,dimensions));
    }
544975
def sub!(pat, rep)
      each_with_index { |fn, i| self[i] = fn.sub(pat, rep) }
      self
    end
45976
def sub(x, y, context=None):
    
    return _apply_function_in_current_context(
        BigFloat,
        mpfr.mpfr_sub,
        (
            BigFloat._implicit_convert(x),
            BigFloat._implicit_convert(y),
        ),
        context,
    )
917481
public Vector sub(Vector b) {
        if ((b == null) || (size != b.size)) return null;

        int i;
        Vector result = new Vector(size);
        for (i = 0; i < size; i++)
            result.vector[i] = vector[i] - b.vector[i];
        return result;
    }
941952
public void sub(Vector3d v1) {
        x -= v1.x;
        y -= v1.y;
        z -= v1.z;
    }
201951
public Vector3i sub(int x, int y, int z, Vector3i dest) {
        dest.x = this.x - x;
        dest.y = this.y - y;
        dest.z = this.z - z;
        return dest;
    }
243856
public Vector3i sub(int x, int y, int z) {
        return sub(x, y, z, thisOrNew());
    }
565014
protected static double[] sub(double[] base, double subNumber)
    {
        int dataNum = base.length;
        double[] result = new double[dataNum];

        for (int index = 0; index < dataNum; index++)
        {
            result[index] = base[index] / subNumber;
        }

        return result;
    }
1078710
public Vector2i sub(Vector2ic v, Vector2i dest) {
        dest.x = x - v.x();
        dest.y = y - v.y();
        return dest;
    }
9071
def sub(x1, x2, output_shape=None, name=None):
  
  output_shape = convert_to_shape(output_shape)
  if not isinstance(x2, Tensor):
    return ScalarAddOperation(x1, -x2).outputs[0]
  with tf.name_scope(name, default_name="sub"):
    x1, x2 = binary_arguments_to_tensors(x1, x2)
    return add(x1, negative(x2), output_shape=output_shape)