def sub(self, left: IndexOpsLike, right: Any) -> SeriesOrIndex:
_sanitize_list_like(right)
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError("Subtraction can not be applied to given types.")
right = transform_boolean_operand_to_numeric(right, spark_type=left.spark.data_type)
return column_op(Column.__sub__)(left, right)
def mul(self, left: IndexOpsLike, right: Any) -> SeriesOrIndex:
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError(
"Multiplication can not be applied to given types.")
right = transform_boolean_operand_to_numeric(
right, spark_type=left.spark.data_type)
return column_op(Column.__mul__)(left, right)
def pow(self, left: IndexOpsLike, right: Any) -> SeriesOrIndex:
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError("Exponentiation can not be applied to given types.")
def pow_func(left: Column, right: Any) -> Column:
return F.when(left == 1, left).otherwise(Column.__pow__(left, right))
right = transform_boolean_operand_to_numeric(right, spark_type=left.spark.data_type)
return column_op(pow_func)(left, right)
def mod(self, left: IndexOpsLike, right: Any) -> SeriesOrIndex:
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError("Modulo can not be applied to given types.")
def mod(left: Column, right: Any) -> Column:
return ((left % right) + right) % right
right = transform_boolean_operand_to_numeric(right, spark_type=left.spark.data_type)
return column_op(mod)(left, right)
def mul(self, left: IndexOpsLike, right: Any) -> SeriesOrIndex:
_sanitize_list_like(right)
if isinstance(right, IndexOpsMixin) and isinstance(right.spark.data_type, StringType):
return column_op(SF.repeat)(right, left)
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError("Multiplication can not be applied to given types.")
right = transform_boolean_operand_to_numeric(right, spark_type=left.spark.data_type)
return column_op(Column.__mul__)(left, right)
def truediv(self, left: IndexOpsLike, right: Any) -> SeriesOrIndex:
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError("True division can not be applied to given types.")
def truediv(left: Column, right: Any) -> Column:
return F.when(
SF.lit(right != 0) | SF.lit(right).isNull(), left.__div__(right)
).otherwise(SF.lit(np.inf).__div__(left))
right = transform_boolean_operand_to_numeric(right, spark_type=left.spark.data_type)
return numpy_column_op(truediv)(left, right)
def floordiv(self, left, right) -> Union["Series", "Index"]:
if not is_valid_operand_for_numeric_arithmetic(right, allow_bool=False):
raise TypeError(
"Floor division can not be applied to %s and the given type." % self.pretty_name)
if isinstance(right, numbers.Number) and not isinstance(right, bool):
left = left.spark.transform(lambda scol: scol.cast(as_spark_type(type(right))))
return left // right
else:
assert isinstance(right, IndexOpsMixin)
left = transform_boolean_operand_to_numeric(left, right.spark.data_type)
return left // right
def sub(self, left: T_IndexOps, right: Any) -> IndexOpsLike:
if not is_valid_operand_for_numeric_arithmetic(right, allow_bool=False):
raise TypeError(
"Subtraction can not be applied to %s and the given type." % self.pretty_name
)
if isinstance(right, numbers.Number) and not isinstance(right, bool):
left = left.spark.transform(lambda scol: scol.cast(as_spark_type(type(right))))
return left - right
else:
assert isinstance(right, IndexOpsMixin)
left = transform_boolean_operand_to_numeric(left, right.spark.data_type)
return left - right
def sub(self, left: T_IndexOps, right: Any) -> IndexOpsLike:
if (isinstance(right, IndexOpsMixin) and isinstance(
right.spark.data_type, StringType)) or isinstance(right, str):
raise TypeError(
"subtraction can not be applied to string series or literals.")
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError("subtraction can not be applied to given types.")
right = transform_boolean_operand_to_numeric(right,
left.spark.data_type)
return column_op(Column.__sub__)(left, right)
def sub(self, left: IndexOpsLike, right: Any) -> SeriesOrIndex:
_sanitize_list_like(right)
if not is_valid_operand_for_numeric_arithmetic(right, allow_bool=False):
raise TypeError(
"Subtraction can not be applied to %s and the given type." % self.pretty_name
)
if isinstance(right, numbers.Number):
left = transform_boolean_operand_to_numeric(left, spark_type=as_spark_type(type(right)))
return left - right
else:
assert isinstance(right, IndexOpsMixin)
left = transform_boolean_operand_to_numeric(left, spark_type=right.spark.data_type)
return left - right
def add(self, left, right) -> Union["Series", "Index"]:
if (isinstance(right, IndexOpsMixin) and isinstance(
right.spark.data_type, StringType)) or isinstance(right, str):
raise TypeError(
"string addition can only be applied to string series or literals."
)
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError("addition can not be applied to given types.")
right = transform_boolean_operand_to_numeric(right,
left.spark.data_type)
return column_op(Column.__add__)(left, right)
def mod(self, left: T_IndexOps, right: Any) -> IndexOpsLike:
if (isinstance(right, IndexOpsMixin) and isinstance(
right.spark.data_type, StringType)) or isinstance(right, str):
raise TypeError(
"modulo can not be applied on string series or literals.")
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError("modulo can not be applied to given types.")
right = transform_boolean_operand_to_numeric(right,
left.spark.data_type)
def mod(left: Column, right: Any) -> Column:
return ((left % right) + right) % right
return column_op(mod)(left, right)
def mul(self, left, right) -> Union["Series", "Index"]:
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError(
"Multiplication can not be applied to %s and the given type." % self.pretty_name
)
if isinstance(right, bool):
return left.__and__(right)
elif isinstance(right, numbers.Number):
left = left.spark.transform(lambda scol: scol.cast(as_spark_type(type(right))))
return left * right
else:
assert isinstance(right, IndexOpsMixin)
if isinstance(right, IndexOpsMixin) and isinstance(right.spark.data_type, BooleanType):
return left.__and__(right)
else:
left = transform_boolean_operand_to_numeric(left, right.spark.data_type)
return left * right
def mul(self, left: T_IndexOps, right: Any) -> IndexOpsLike:
if isinstance(right, str):
raise TypeError(
"multiplication can not be applied to a string literal.")
if isinstance(right, IndexOpsMixin) and isinstance(
right.spark.data_type, TimestampType):
raise TypeError("multiplication can not be applied to date times.")
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError(
"multiplication can not be applied to given types.")
right = transform_boolean_operand_to_numeric(right,
left.spark.data_type)
return column_op(Column.__mul__)(left, right)
def mul(self, left: IndexOpsLike, right: Any) -> SeriesOrIndex:
_sanitize_list_like(right)
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError(
"Multiplication can not be applied to %s and the given type." % self.pretty_name
)
if isinstance(right, bool):
return left.__and__(right)
elif isinstance(right, numbers.Number):
left = transform_boolean_operand_to_numeric(left, spark_type=as_spark_type(type(right)))
return left * right
else:
assert isinstance(right, IndexOpsMixin)
if isinstance(right, IndexOpsMixin) and isinstance(right.spark.data_type, BooleanType):
return left.__and__(right)
else:
left = transform_boolean_operand_to_numeric(left, spark_type=right.spark.data_type)
return left * right
def truediv(self, left: T_IndexOps, right: Any) -> IndexOpsLike:
if (isinstance(right, IndexOpsMixin) and isinstance(
right.spark.data_type, StringType)) or isinstance(right, str):
raise TypeError(
"division can not be applied on string series or literals.")
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError("division can not be applied to given types.")
right = transform_boolean_operand_to_numeric(right,
left.spark.data_type)
def truediv(left: Column, right: Any) -> Column:
return F.when(
F.lit(right != 0) | F.lit(right).isNull(),
left.__div__(right)).otherwise(F.lit(np.inf).__div__(left))
return numpy_column_op(truediv)(left, right)
def floordiv(self, left: IndexOpsLike, right: Any) -> SeriesOrIndex:
_sanitize_list_like(right)
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError("Floor division can not be applied to given types.")
def floordiv(left: Column, right: Any) -> Column:
return F.when(SF.lit(right is np.nan), np.nan).otherwise(
F.when(
SF.lit(right != 0) | SF.lit(right).isNull(), F.floor(left.__div__(right))
).otherwise(
F.when(SF.lit(left == np.inf) | SF.lit(left == -np.inf), left).otherwise(
SF.lit(np.inf).__div__(left)
)
)
)
right = transform_boolean_operand_to_numeric(right, spark_type=left.spark.data_type)
return numpy_column_op(floordiv)(left, right)
def pow(self, left: T_IndexOps, right: Any) -> IndexOpsLike:
if (isinstance(right, IndexOpsMixin) and isinstance(
right.spark.data_type, StringType)) or isinstance(right, str):
raise TypeError(
"exponentiation can not be applied on string series or literals."
)
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError(
"exponentiation can not be applied to given types.")
right = transform_boolean_operand_to_numeric(right,
left.spark.data_type)
def pow_func(left: Column, right: Any) -> Column:
return F.when(left == 1,
left).otherwise(Column.__pow__(left, right))
return column_op(pow_func)(left, right)
def floordiv(self, left, right) -> Union["Series", "Index"]:
if (isinstance(right, IndexOpsMixin) and isinstance(
right.spark.data_type, StringType)) or isinstance(right, str):
raise TypeError(
"division can not be applied on string series or literals.")
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError("division can not be applied to given types.")
right = transform_boolean_operand_to_numeric(right,
left.spark.data_type)
def floordiv(left, right):
return F.when(F.lit(right is np.nan), np.nan).otherwise(
F.when(
F.lit(right != 0) | F.lit(right).isNull(),
F.floor(left.__div__(right))).otherwise(
F.lit(np.inf).__div__(left)))
return numpy_column_op(floordiv)(left, right)
def add(self, left: IndexOpsLike, right: Any) -> SeriesOrIndex:
if not is_valid_operand_for_numeric_arithmetic(right):
raise TypeError(
"Addition can not be applied to %s and the given type." %
self.pretty_name)
if isinstance(right, bool):
return left.__or__(right)
elif isinstance(right, numbers.Number):
left = left.spark.transform(
lambda scol: scol.cast(as_spark_type(type(right))))
return left + right
else:
assert isinstance(right, IndexOpsMixin)
if isinstance(right, IndexOpsMixin) and isinstance(
right.spark.data_type, BooleanType):
return left.__or__(right)
else:
left = transform_boolean_operand_to_numeric(
left, right.spark.data_type)
return left + right
