return x*y for bigInts x and y. This is faster when y<x.
326947
function mult(x, y) {
  var ans=expand(x, x.length+y.length);
  mult_(ans, y);
  return trim(ans, 1);
}
339353
public int multiply(int x, int y) {
    assert(x >= 0 && x < getFieldSize() && y >= 0 && y < getFieldSize());
    return mulTable[x][y];
  }
969164
def get_value_by_xy(self, x, y):
        
        if x < self.xMin or x > self.xMax or y < self.yMin or y > self.yMax:
            return None
            # raise ValueError("The x or y value must be within the Min and Max!")
        else:
            row = self.nRows - int(numpy.ceil((y - self.yMin) / self.dx))
            col = int(numpy.floor((x - self.xMin) / self.dx))
            value = self.data[row][col]
            if value == self.noDataValue:
                return None
            else:
                return value
1186168
def add(x, y, context=None):
    
    return _apply_function_in_current_context(
        BigFloat,
        mpfr.mpfr_add,
        (
            BigFloat._implicit_convert(x),
            BigFloat._implicit_convert(y),
        ),
        context,
    )
1002176
def notequal(x, y):
    
    x = BigFloat._implicit_convert(x)
    y = BigFloat._implicit_convert(y)
    return not mpfr.mpfr_equal_p(x, y)
887790
def xy(self):
        """"""
        if self._xy != (None, None):
            self._x, self._y = self._xy

        if self._x is not None and self._y is not None:
            x = self._x
            if self._x > 1:
                x = self._x / 65555
            y = self._y
            if self._y > 1:
                y = self._y / 65555
            return (x, y)

        return None
589216
public static int unionSize(long[] x, long[] y) {
    final int lx = x.length, ly = y.length;
    final int min = (lx < ly) ? lx : ly;
    int i = 0, res = 0;
    for(; i < min; i++) {
      res += Long.bitCount(x[i] | y[i]);
    }
    for(; i < lx; i++) {
      res += Long.bitCount(x[i]);
    }
    for(; i < ly; i++) {
      res += Long.bitCount(y[i]);
    }
    return res;
  }
338414
public static UnsignedInteger64 add(UnsignedInteger64 x, int y) {
		return new UnsignedInteger64(x.bigInt.add(BigInteger.valueOf(y)));
	}
85120
def y0(x, context=None):
    
    return _apply_function_in_current_context(
        BigFloat,
        mpfr.mpfr_y0,
        (BigFloat._implicit_convert(x),),
        context,
    )
419638
def unordered(x, y):
    
    x = BigFloat._implicit_convert(x)
    y = BigFloat._implicit_convert(y)
    return mpfr.mpfr_unordered_p(x, y)
13174
public double get(int x, int y) {
    return (x == y) ? 0 : (x < y) //
        ? matrix[MatrixParadigm.triangleSize(y) + x] //
        : matrix[MatrixParadigm.triangleSize(x) + y];
  }
209053
public static double logAdd(double x, double y) {
        if (FastMath.useLogAddTable) {
            return SmoothedLogAddTable.logAdd(x,y);
        } else {
            return FastMath.logAddExact(x,y);
        }
    }
805836
def compute(self, x, y):
        '''
        
        '''
        if x in self.__memo_dict:
            x_v = self.__memo_dict[x]
        else:
            x_v = self.__cost_functionable.compute(self.__params_arr[x, :])
            self.__memo_dict.setdefault(x, x_v)
        if y in self.__memo_dict:
            y_v = self.__memo_dict[y]
        else:
            y_v = self.__cost_functionable.compute(self.__params_arr[y, :])
            self.__memo_dict.setdefault(y, y_v)

        return abs(x_v - y_v)
1258977
public static long multiplyExact(long x, long y) {
        long r = x * y;
        long ax = Math.abs(x);
        long ay = Math.abs(y);
        if (((ax | ay) >>> 31 != 0)) {
            // Some bits greater than 2^31 that might cause overflow
            // Check the result using the divide operator
            // and check for the special case of Long.MIN_VALUE * -1
           if (((y != 0) && (r / y != x)) ||
               (x == Long.MIN_VALUE && y == -1)) {
                throw new ArithmeticException("long overflow");
            }
        }
        return r;
    }
623444
def rdist(x, y):
    
    result = 0.0
    for i in range(x.shape[0]):
        result += (x[i] - y[i]) ** 2

    return result
211421
def preprocess_x_y(x, y):
    
    def is_iterable_slicable(a):
        if hasattr(a, "__iter__") and hasattr(a, "__getitem__"):
            return True
        else:
            return False

    if is_iterable_slicable(x):
        if is_iterable_slicable(x[0]):
            return x, y
        else:
            return (x,), (y,)
    else:
        raise ValueError("invalid input!")
1178578
def lessequal(x, y):
    
    x = BigFloat._implicit_convert(x)
    y = BigFloat._implicit_convert(y)
    return mpfr.mpfr_lessequal_p(x, y)