//------------------------------------------------------------------------------
//
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
//
//------------------------------------------------------------------------------
namespace NetVips;
public partial class Image
{
#region auto-generated operator overloads
///
/// This operation calculates + .
///
/// Left .
/// Right .
/// A new .
public static Image operator +(Image left, Image right) =>
left.Call("add", right) as Image;
///
/// This operation calculates + .
///
/// Left double constant.
/// Right .
/// A new .
public static Image operator +(double left, Image right) =>
right.Call("linear", 1.0, left) as Image;
///
/// This operation calculates + .
///
/// Left .
/// Right double constant.
/// A new .
public static Image operator +(Image left, double right) =>
left.Call("linear", 1.0, right) as Image;
///
/// This operation calculates + .
///
/// Left double array.
/// Right .
/// A new .
public static Image operator +(double[] left, Image right) =>
right.Call("linear", 1.0, left) as Image;
///
/// This operation calculates + .
///
/// Left .
/// Right double array.
/// A new .
public static Image operator +(Image left, double[] right) =>
left.Call("linear", 1.0, right) as Image;
///
/// This operation calculates + .
///
/// Left integer array.
/// Right .
/// A new .
public static Image operator +(int[] left, Image right) =>
right.Call("linear", 1.0, left) as Image;
///
/// This operation calculates + .
///
/// Left .
/// Right integer array.
/// A new .
public static Image operator +(Image left, int[] right) =>
left.Call("linear", 1.0, right) as Image;
///
/// This operation calculates - .
///
/// Left .
/// Right .
/// A new .
public static Image operator -(Image left, Image right) =>
left.Call("subtract", right) as Image;
///
/// This operation calculates - .
///
/// Left double constant.
/// Right .
/// A new .
public static Image operator -(double left, Image right) =>
right.Call("linear", -1.0, left) as Image;
///
/// This operation calculates - .
///
/// Left .
/// Right double constant.
/// A new .
public static Image operator -(Image left, double right) =>
left.Call("linear", 1.0, -right) as Image;
///
/// This operation calculates - .
///
/// Left double array.
/// Right .
/// A new .
public static Image operator -(double[] left, Image right) =>
right.Call("linear", -1.0, left) as Image;
///
/// This operation calculates - .
///
/// Left .
/// Right double array.
/// A new .
public static Image operator -(Image left, double[] right) =>
left.Call("linear", 1.0, right.Negate()) as Image;
///
/// This operation calculates - .
///
/// Left integer array.
/// Right .
/// A new .
public static Image operator -(int[] left, Image right) =>
right.Call("linear", -1.0, left) as Image;
///
/// This operation calculates - .
///
/// Left .
/// Right integer array.
/// A new .
public static Image operator -(Image left, int[] right) =>
left.Call("linear", 1.0, right.Negate()) as Image;
///
/// This operation calculates * .
///
/// Left .
/// Right .
/// A new .
public static Image operator *(Image left, Image right) =>
left.Call("multiply", right) as Image;
///
/// This operation calculates * .
///
/// Left double constant.
/// Right .
/// A new .
public static Image operator *(double left, Image right) =>
right.Call("linear", left, 0.0) as Image;
///
/// This operation calculates * .
///
/// Left .
/// Right double constant.
/// A new .
public static Image operator *(Image left, double right) =>
left.Call("linear", right, 0.0) as Image;
///
/// This operation calculates * .
///
/// Left double array.
/// Right .
/// A new .
public static Image operator *(double[] left, Image right) =>
right.Call("linear", left, 0.0) as Image;
///
/// This operation calculates * .
///
/// Left .
/// Right double array.
/// A new .
public static Image operator *(Image left, double[] right) =>
left.Call("linear", right, 0.0) as Image;
///
/// This operation calculates * .
///
/// Left integer array.
/// Right .
/// A new .
public static Image operator *(int[] left, Image right) =>
right.Call("linear", left, 0.0) as Image;
///
/// This operation calculates * .
///
/// Left .
/// Right integer array.
/// A new .
public static Image operator *(Image left, int[] right) =>
left.Call("linear", right, 0.0) as Image;
///
/// This operation calculates / .
///
/// Left .
/// Right .
/// A new .
public static Image operator /(Image left, Image right) =>
left.Call("divide", right) as Image;
///
/// This operation calculates / .
///
/// Left double constant.
/// Right .
/// A new .
public static Image operator /(double left, Image right) =>
right.Pow(-1.0).Call("linear", left, 0.0) as Image;
///
/// This operation calculates / .
///
/// Left .
/// Right double constant.
/// A new .
public static Image operator /(Image left, double right) =>
left.Call("linear", 1.0 / right, 0.0) as Image;
///
/// This operation calculates / .
///
/// Left double array.
/// Right .
/// A new .
public static Image operator /(double[] left, Image right) =>
right.Pow(-1.0).Call("linear", left, 0.0) as Image;
///
/// This operation calculates / .
///
/// Left .
/// Right double array.
/// A new .
public static Image operator /(Image left, double[] right) =>
left.Call("linear", right.Invert(), 0.0) as Image;
///
/// This operation calculates / .
///
/// Left integer array.
/// Right .
/// A new .
public static Image operator /(int[] left, Image right) =>
right.Pow(-1.0).Call("linear", left, 0.0) as Image;
///
/// This operation calculates / .
///
/// Left .
/// Right integer array.
/// A new .
public static Image operator /(Image left, int[] right) =>
left.Call("linear", right.Invert(), 0.0) as Image;
///
/// This operation calculates %
/// (remainder after integer division).
///
/// Left .
/// Right .
/// A new .
public static Image operator %(Image left, Image right) =>
left.Call("remainder", right) as Image;
///
/// This operation calculates %
/// (remainder after integer division).
///
/// Left double constant.
/// Right .
/// A new .
public static Image operator %(double left, Image right) =>
right.Call("remainder_const", left) as Image;
///
/// This operation calculates %
/// (remainder after integer division).
///
/// Left .
/// Right double constant.
/// A new .
public static Image operator %(Image left, double right) =>
left.Call("remainder_const", right) as Image;
///
/// This operation calculates %
/// (remainder after integer division).
///
/// Left double array.
/// Right .
/// A new .
public static Image operator %(double[] left, Image right) =>
right.Call("remainder_const", left) as Image;
///
/// This operation calculates %
/// (remainder after integer division).
///
/// Left .
/// Right double array.
/// A new .
public static Image operator %(Image left, double[] right) =>
left.Call("remainder_const", right) as Image;
///
/// This operation calculates %
/// (remainder after integer division).
///
/// Left integer array.
/// Right .
/// A new .
public static Image operator %(int[] left, Image right) =>
right.Call("remainder_const", left) as Image;
///
/// This operation calculates %
/// (remainder after integer division).
///
/// Left .
/// Right integer array.
/// A new .
public static Image operator %(Image left, int[] right) =>
left.Call("remainder_const", right) as Image;
///
/// This operation computes the logical bitwise AND of its operands.
///
/// Left .
/// Right .
/// A new .
public static Image operator &(Image left, Image right) =>
left.Call("boolean", right, Enums.OperationBoolean.And) as Image;
///
/// This operation computes the logical bitwise AND of its operands.
///
/// Left double constant.
/// Right .
/// A new .
public static Image operator &(double left, Image right) =>
right.Call("boolean_const", Enums.OperationBoolean.And, left) as Image;
///
/// This operation computes the logical bitwise AND of its operands.
///
/// Left .
/// Right double constant.
/// A new .
public static Image operator &(Image left, double right) =>
left.Call("boolean_const", Enums.OperationBoolean.And, right) as Image;
///
/// This operation computes the logical bitwise AND of its operands.
///
/// Left double array.
/// Right .
/// A new .
public static Image operator &(double[] left, Image right) =>
right.Call("boolean_const", Enums.OperationBoolean.And, left) as Image;
///
/// This operation computes the logical bitwise AND of its operands.
///
/// Left .
/// Right double array.
/// A new .
public static Image operator &(Image left, double[] right) =>
left.Call("boolean_const", Enums.OperationBoolean.And, right) as Image;
///
/// This operation computes the logical bitwise AND of its operands.
///
/// Left integer array.
/// Right .
/// A new .
public static Image operator &(int[] left, Image right) =>
right.Call("boolean_const", Enums.OperationBoolean.And, left) as Image;
///
/// This operation computes the logical bitwise AND of its operands.
///
/// Left .
/// Right integer array.
/// A new .
public static Image operator &(Image left, int[] right) =>
left.Call("boolean_const", Enums.OperationBoolean.And, right) as Image;
///
/// This operation computes the bitwise OR of its operands.
///
/// Left .
/// Right .
/// A new .
public static Image operator |(Image left, Image right) =>
left.Call("boolean", right, Enums.OperationBoolean.Or) as Image;
///
/// This operation computes the bitwise OR of its operands.
///
/// Left double constant.
/// Right .
/// A new .
public static Image operator |(double left, Image right) =>
right.Call("boolean_const", Enums.OperationBoolean.Or, left) as Image;
///
/// This operation computes the bitwise OR of its operands.
///
/// Left .
/// Right double constant.
/// A new .
public static Image operator |(Image left, double right) =>
left.Call("boolean_const", Enums.OperationBoolean.Or, right) as Image;
///
/// This operation computes the bitwise OR of its operands.
///
/// Left double array.
/// Right .
/// A new .
public static Image operator |(double[] left, Image right) =>
right.Call("boolean_const", Enums.OperationBoolean.Or, left) as Image;
///
/// This operation computes the bitwise OR of its operands.
///
/// Left .
/// Right double array.
/// A new .
public static Image operator |(Image left, double[] right) =>
left.Call("boolean_const", Enums.OperationBoolean.Or, right) as Image;
///
/// This operation computes the bitwise OR of its operands.
///
/// Left integer array.
/// Right .
/// A new .
public static Image operator |(int[] left, Image right) =>
right.Call("boolean_const", Enums.OperationBoolean.Or, left) as Image;
///
/// This operation computes the bitwise OR of its operands.
///
/// Left .
/// Right integer array.
/// A new .
public static Image operator |(Image left, int[] right) =>
left.Call("boolean_const", Enums.OperationBoolean.Or, right) as Image;
///
/// This operation computes the bitwise exclusive-OR of its operands.
///
/// Left .
/// Right .
/// A new .
public static Image operator ^(Image left, Image right) =>
left.Call("boolean", right, Enums.OperationBoolean.Eor) as Image;
///
/// This operation computes the bitwise exclusive-OR of its operands.
///
/// Left double constant.
/// Right .
/// A new .
public static Image operator ^(double left, Image right) =>
right.Call("boolean_const", Enums.OperationBoolean.Eor, left) as Image;
///
/// This operation computes the bitwise exclusive-OR of its operands.
///
/// Left .
/// Right double constant.
/// A new .
public static Image operator ^(Image left, double right) =>
left.Call("boolean_const", Enums.OperationBoolean.Eor, right) as Image;
///
/// This operation computes the bitwise exclusive-OR of its operands.
///
/// Left double array.
/// Right .
/// A new .
public static Image operator ^(double[] left, Image right) =>
right.Call("boolean_const", Enums.OperationBoolean.Eor, left) as Image;
///
/// This operation computes the bitwise exclusive-OR of its operands.
///
/// Left .
/// Right double array.
/// A new .
public static Image operator ^(Image left, double[] right) =>
left.Call("boolean_const", Enums.OperationBoolean.Eor, right) as Image;
///
/// This operation computes the bitwise exclusive-OR of its operands.
///
/// Left integer array.
/// Right .
/// A new .
public static Image operator ^(int[] left, Image right) =>
right.Call("boolean_const", Enums.OperationBoolean.Eor, left) as Image;
///
/// This operation computes the bitwise exclusive-OR of its operands.
///
/// Left .
/// Right integer array.
/// A new .
public static Image operator ^(Image left, int[] right) =>
left.Call("boolean_const", Enums.OperationBoolean.Eor, right) as Image;
///
/// This operation shifts its first operand left by the number of bits specified by its second operand.
///
/// Left .
/// The number of bits.
/// A new .
public static Image operator <<(Image left, int right) =>
left.Call("boolean_const", Enums.OperationBoolean.Lshift, right) as Image;
///
/// This operation shifts its first operand right by the number of bits specified by its second operand.
///
/// Left .
/// The number of bits.
/// A new .
public static Image operator >>(Image left, int right) =>
left.Call("boolean_const", Enums.OperationBoolean.Rshift, right) as Image;
///
/// This operation compares two images on equality.
///
/// Left double constant to compare.
/// Right to compare.
/// A new .
public static Image operator ==(double left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Equal, left) as Image;
///
/// This operation compares two images on equality.
///
/// Left double array to compare.
/// Right to compare.
/// A new .
public static Image operator ==(double[] left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Equal, left) as Image;
///
/// This operation compares two images on equality.
///
/// Left integer array to compare.
/// Right to compare.
/// A new .
public static Image operator ==(int[] left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Equal, left) as Image;
///
/// This operation compares two images on inequality.
///
/// Left double constant to compare.
/// Right to compare.
/// A new .
public static Image operator !=(double left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Noteq, left) as Image;
///
/// This operation compares two images on inequality.
///
/// Left double array to compare.
/// Right to compare.
/// A new .
public static Image operator !=(double[] left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Noteq, left) as Image;
///
/// This operation compares two images on inequality.
///
/// Left integer array to compare.
/// Right to compare.
/// A new .
public static Image operator !=(int[] left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Noteq, left) as Image;
///
/// This operation compares if the left operand is less than the right operand.
///
/// Left .
/// Right .
/// A new .
public static Image operator <(Image left, Image right) =>
left.Call("relational", right, Enums.OperationRelational.Less) as Image;
///
/// This operation compares if the left operand is less than the right operand.
///
/// Left double constant.
/// Right .
/// A new .
public static Image operator <(double left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.More, left) as Image;
///
/// This operation compares if the left operand is less than the right operand.
///
/// Left .
/// Right double constant.
/// A new .
public static Image operator <(Image left, double right) =>
left.Call("relational_const", Enums.OperationRelational.Less, right) as Image;
///
/// This operation compares if the left operand is less than the right operand.
///
/// Left double array.
/// Right .
/// A new .
public static Image operator <(double[] left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.More, left) as Image;
///
/// This operation compares if the left operand is less than the right operand.
///
/// Left .
/// Right double array.
/// A new .
public static Image operator <(Image left, double[] right) =>
left.Call("relational_const", Enums.OperationRelational.Less, right) as Image;
///
/// This operation compares if the left operand is less than the right operand.
///
/// Left integer array.
/// Right .
/// A new .
public static Image operator <(int[] left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.More, left) as Image;
///
/// This operation compares if the left operand is less than the right operand.
///
/// Left .
/// Right integer array.
/// A new .
public static Image operator <(Image left, int[] right) =>
left.Call("relational_const", Enums.OperationRelational.Less, right) as Image;
///
/// This operation compares if the left operand is greater than the right operand.
///
/// Left .
/// Right .
/// A new .
public static Image operator >(Image left, Image right) =>
left.Call("relational", right, Enums.OperationRelational.More) as Image;
///
/// This operation compares if the left operand is greater than the right operand.
///
/// Left double constant.
/// Right .
/// A new .
public static Image operator >(double left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Less, left) as Image;
///
/// This operation compares if the left operand is greater than the right operand.
///
/// Left .
/// Right double constant.
/// A new .
public static Image operator >(Image left, double right) =>
left.Call("relational_const", Enums.OperationRelational.More, right) as Image;
///
/// This operation compares if the left operand is greater than the right operand.
///
/// Left double array.
/// Right .
/// A new .
public static Image operator >(double[] left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Less, left) as Image;
///
/// This operation compares if the left operand is greater than the right operand.
///
/// Left .
/// Right double array.
/// A new .
public static Image operator >(Image left, double[] right) =>
left.Call("relational_const", Enums.OperationRelational.More, right) as Image;
///
/// This operation compares if the left operand is greater than the right operand.
///
/// Left integer array.
/// Right .
/// A new .
public static Image operator >(int[] left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Less, left) as Image;
///
/// This operation compares if the left operand is greater than the right operand.
///
/// Left .
/// Right integer array.
/// A new .
public static Image operator >(Image left, int[] right) =>
left.Call("relational_const", Enums.OperationRelational.More, right) as Image;
///
/// This operation compares if the left operand is less than or equal to the right operand.
///
/// Left .
/// Right .
/// A new .
public static Image operator <=(Image left, Image right) =>
left.Call("relational", right, Enums.OperationRelational.Lesseq) as Image;
///
/// This operation compares if the left operand is less than or equal to the right operand.
///
/// Left double constant.
/// Right .
/// A new .
public static Image operator <=(double left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Moreeq, left) as Image;
///
/// This operation compares if the left operand is less than or equal to the right operand.
///
/// Left .
/// Right double constant.
/// A new .
public static Image operator <=(Image left, double right) =>
left.Call("relational_const", Enums.OperationRelational.Lesseq, right) as Image;
///
/// This operation compares if the left operand is less than or equal to the right operand.
///
/// Left double array.
/// Right .
/// A new .
public static Image operator <=(double[] left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Moreeq, left) as Image;
///
/// This operation compares if the left operand is less than or equal to the right operand.
///
/// Left .
/// Right double array.
/// A new .
public static Image operator <=(Image left, double[] right) =>
left.Call("relational_const", Enums.OperationRelational.Lesseq, right) as Image;
///
/// This operation compares if the left operand is less than or equal to the right operand.
///
/// Left integer array.
/// Right .
/// A new .
public static Image operator <=(int[] left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Moreeq, left) as Image;
///
/// This operation compares if the left operand is less than or equal to the right operand.
///
/// Left .
/// Right integer array.
/// A new .
public static Image operator <=(Image left, int[] right) =>
left.Call("relational_const", Enums.OperationRelational.Lesseq, right) as Image;
///
/// This operation compares if the left operand is greater than or equal to the right operand.
///
/// Left .
/// Right .
/// A new .
public static Image operator >=(Image left, Image right) =>
left.Call("relational", right, Enums.OperationRelational.Moreeq) as Image;
///
/// This operation compares if the left operand is greater than or equal to the right operand.
///
/// Left double constant.
/// Right .
/// A new .
public static Image operator >=(double left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Lesseq, left) as Image;
///
/// This operation compares if the left operand is greater than or equal to the right operand.
///
/// Left .
/// Right double constant.
/// A new .
public static Image operator >=(Image left, double right) =>
left.Call("relational_const", Enums.OperationRelational.Moreeq, right) as Image;
///
/// This operation compares if the left operand is greater than or equal to the right operand.
///
/// Left double array.
/// Right .
/// A new .
public static Image operator >=(double[] left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Lesseq, left) as Image;
///
/// This operation compares if the left operand is greater than or equal to the right operand.
///
/// Left .
/// Right double array.
/// A new .
public static Image operator >=(Image left, double[] right) =>
left.Call("relational_const", Enums.OperationRelational.Moreeq, right) as Image;
///
/// This operation compares if the left operand is greater than or equal to the right operand.
///
/// Left integer array.
/// Right .
/// A new .
public static Image operator >=(int[] left, Image right) =>
right.Call("relational_const", Enums.OperationRelational.Lesseq, left) as Image;
///
/// This operation compares if the left operand is greater than or equal to the right operand.
///
/// Left .
/// Right integer array.
/// A new .
public static Image operator >=(Image left, int[] right) =>
left.Call("relational_const", Enums.OperationRelational.Moreeq, right) as Image;
///
/// Returns a value indicating whether a given is definitely .
///
/// The image to check.
/// if is definitely ; otherwise, .
public static bool operator true(Image image) =>
// Always evaluate to false so that each side of the && equation is evaluated
false;
///
/// Returns a value indicating whether a given is definitely .
///
/// The image to check.
/// if is definitely ; otherwise, .
public static bool operator false(Image image) =>
// Always evaluate to false so that each side of the && equation is evaluated
false;
#endregion
}