// Emacs -*- C++ -*-

// Machine generated include file, do not modify.

//prefix
//filename BIO-cvcomplex.c
// conversion I(complex) I(IA_Bit)
//unary pointwise to_complex subop=complex I(complex) I(IA_Bit)
friend IA_Image<IA_Point<int>,complex> to_complex(const IA_Image<IA_Point<int>,IA_Bit> & rhs);

//filename BIO-cvfloat.c
// conversion I(float) I(IA_Bit)
//unary pointwise to_float subop= I(float) I(IA_Bit)
friend IA_Image<IA_Point<int>,float> to_float(const IA_Image<IA_Point<int>,IA_Bit> & rhs);

//filename BIO-cvint.c
// conversion I(int) I(IA_Bit)
//unary pointwise to_int subop= I(int) I(IA_Bit)
friend IA_Image<IA_Point<int>,int> to_int(const IA_Image<IA_Point<int>,IA_Bit> & rhs);

//filename BIO-u_char.c
// conversion I(u_char) I(IA_Bit)
//unary pointwise to_uchar subop= I(u_char) I(IA_Bit)
friend IA_Image<IA_Point<int>,u_char> to_uchar(const IA_Image<IA_Point<int>,IA_Bit> & rhs);

//  Binary operations for the Bit Discrete Image
//filename BIO-__ad.c
//binary pointwise commutative operator& I(IA_Bit) I(IA_Bit) I(IA_Bit)
friend IA_Image<IA_Point<int>,IA_Bit> operator&(const IA_Image<IA_Point<int>,IA_Bit> &,const IA_Image<IA_Point<int>,IA_Bit> &);

//binary pointwise commutative operator& I(IA_Bit) I(IA_Bit) IA_Bit
friend IA_Image<IA_Point<int>,IA_Bit> operator&(const IA_Image<IA_Point<int>,IA_Bit> &,IA_Bit);
//** doesn't need to be friendly

//pointwise operator&= I(IA_Bit) I(IA_Bit)
// ** doesn't need to be friendly

//pointwise operator&= I(IA_Bit) IA_Bit
// ** doesn't need to be friendly

//filename BIO-__or.c
//binary pointwise commutative operator| I(IA_Bit) I(IA_Bit) I(IA_Bit)
friend IA_Image<IA_Point<int>,IA_Bit> operator|(const IA_Image<IA_Point<int>,IA_Bit> &,const IA_Image<IA_Point<int>,IA_Bit> &);

//binary pointwise commutative operator| I(IA_Bit) I(IA_Bit) IA_Bit
friend IA_Image<IA_Point<int>,IA_Bit> operator|(const IA_Image<IA_Point<int>,IA_Bit> &,IA_Bit);
//** doesn't need to be friendly

//pointwise operator|= I(IA_Bit) I(IA_Bit)
// ** doesn't need to be friendly

//pointwise operator|= I(IA_Bit) IA_Bit
// ** doesn't need to be friendly

//filename BIO-__er.c
//binary pointwise commutative operator^ I(IA_Bit) I(IA_Bit) I(IA_Bit)
friend IA_Image<IA_Point<int>,IA_Bit> operator^(const IA_Image<IA_Point<int>,IA_Bit> &,const IA_Image<IA_Point<int>,IA_Bit> &);

//binary pointwise commutative operator^ I(IA_Bit) I(IA_Bit) IA_Bit
friend IA_Image<IA_Point<int>,IA_Bit> operator^(const IA_Image<IA_Point<int>,IA_Bit> &,IA_Bit);
//** doesn't need to be friendly

//pointwise operator^= I(IA_Bit) I(IA_Bit)
// ** doesn't need to be friendly

//pointwise operator^= I(IA_Bit) IA_Bit
// ** doesn't need to be friendly

//filename BIO-__nt.c
//unary pointwise operator~ subop=operator! I(IA_Bit) I(IA_Bit)
friend IA_Image<IA_Point<int>,IA_Bit> operator~(const IA_Image<IA_Point<int>,IA_Bit> & rhs);

//unary pointwise operator! I(IA_Bit) I(IA_Bit)
friend IA_Image<IA_Point<int>,IA_Bit> operator!(const IA_Image<IA_Point<int>,IA_Bit> & rhs);

//filename BIO-__eq.c
//binary strictrel commutative operator== int I(IA_Bit) I(IA_Bit)
friend int operator==(const IA_Image<IA_Point<int>,IA_Bit> &,const IA_Image<IA_Point<int>,IA_Bit> &);

//binary strictrel commutative operator== int I(IA_Bit) IA_Bit
friend int operator==(const IA_Image<IA_Point<int>,IA_Bit> &,IA_Bit);
//** doesn't need to be friendly

//filename BIO-strict_ne.c
//binary strictrel commutative strict_ne subop=operator!= int I(IA_Bit) I(IA_Bit)
friend int strict_ne(const IA_Image<IA_Point<int>,IA_Bit> &,const IA_Image<IA_Point<int>,IA_Bit> &);

//binary strictrel commutative strict_ne subop=operator!= int I(IA_Bit) IA_Bit
friend int strict_ne(const IA_Image<IA_Point<int>,IA_Bit> &,IA_Bit);
//** doesn't need to be friendly

//filename BIO-reductions.c
//reduction sum subop=operator+ zero=0 int I(IA_Bit)
friend int sum(const IA_Image<IA_Point<int>,IA_Bit> &);

// Emacs -*- C++ -*-

// Machine generated include file, do not modify.

//prefix
//filename UIO-cvcomplex.c
// conversion I(complex) I(u_char)
//unary pointwise to_complex subop= I(complex) I(u_char)
friend IA_Image<IA_Point<int>,complex> to_complex(const IA_Image<IA_Point<int>,u_char> & rhs);

//filename UIO-cvfloat.c
// conversion I(float) I(u_char)
//unary pointwise to_float subop= I(float) I(u_char)
friend IA_Image<IA_Point<int>,float> to_float(const IA_Image<IA_Point<int>,u_char> & rhs);

//filename UIO-cvint.c
// conversion I(int) I(u_char)
//unary pointwise to_int subop= I(int) I(u_char)
friend IA_Image<IA_Point<int>,int> to_int(const IA_Image<IA_Point<int>,u_char> & rhs);

//filename UIO-to_bit.c
//unary pointwise to_bit subop=IA_Bit I(IA_Bit) I(u_char)
friend IA_Image<IA_Point<int>,IA_Bit> to_bit(const IA_Image<IA_Point<int>,u_char> & rhs);

//filename UIO-__pl.c
//binary pointwise commutative operator+ I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator+(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise commutative operator+ I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> operator+(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//pointwise operator+= I(u_char) I(u_char)
// ** doesn't need to be friendly

//pointwise operator+= I(u_char) u_char
// ** doesn't need to be friendly

//filename UIO-__mi.c
//binary pointwise non-commutative operator- I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator-(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise non-commutative operator- I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> operator-(const IA_Image<IA_Point<int>,u_char> &,u_char);

//binary pointwise non-commutative operator- I(u_char) u_char I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator-(u_char,const IA_Image<IA_Point<int>,u_char> &);

//unary pointwise operator- I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator-(const IA_Image<IA_Point<int>,u_char> & rhs);

//pointwise operator-= I(u_char) I(u_char)
// ** doesn't need to be friendly

//pointwise operator-= I(u_char) u_char
// ** doesn't need to be friendly

//filename UIO-__ml.c
//binary pointwise commutative operator* I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator*(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise commutative operator* I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> operator*(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//pointwise operator*= I(u_char) I(u_char)
// ** doesn't need to be friendly

//pointwise operator*= I(u_char) u_char
// ** doesn't need to be friendly

// filename UIO-__mlBit.c
// binary pointwise commutative operator* I(u_char) I(u_char) I(IA_Bit)
// binary pointwise commutative operator* I(u_char) u_char I(IA_Bit)
// pointwise operator*= I(u_char) I(IA_Bit)
//filename UIO-__dv.c
//binary pointwise non-commutative operator/ I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator/(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise non-commutative operator/ I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> operator/(const IA_Image<IA_Point<int>,u_char> &,u_char);

//binary pointwise non-commutative operator/ I(u_char) u_char I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator/(u_char,const IA_Image<IA_Point<int>,u_char> &);

//pointwise operator/= I(u_char) I(u_char)
// ** doesn't need to be friendly

//pointwise operator/= I(u_char) u_char
// ** doesn't need to be friendly

//filename UIO-__md.c
//binary pointwise non-commutative operator% I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator%(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise non-commutative operator% I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> operator%(const IA_Image<IA_Point<int>,u_char> &,u_char);

//binary pointwise non-commutative operator% I(u_char) u_char I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator%(u_char,const IA_Image<IA_Point<int>,u_char> &);

//pointwise operator%= I(u_char) I(u_char)
// ** doesn't need to be friendly

//pointwise operator%= I(u_char) u_char
// ** doesn't need to be friendly

//filename UIO-__ad.c
//binary pointwise commutative operator& I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator&(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise commutative operator& I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> operator&(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//pointwise operator&= I(u_char) I(u_char)
// ** doesn't need to be friendly

//pointwise operator&= I(u_char) u_char
// ** doesn't need to be friendly

//filename UIO-__or.c
//binary pointwise commutative operator| I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator|(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise commutative operator| I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> operator|(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//pointwise operator|= I(u_char) I(u_char)
// ** doesn't need to be friendly

//pointwise operator|= I(u_char) u_char
// ** doesn't need to be friendly

//filename UIO-__er.c
//binary pointwise commutative operator^ I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator^(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise commutative operator^ I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> operator^(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//pointwise operator^= I(u_char) I(u_char)
// ** doesn't need to be friendly

//pointwise operator^= I(u_char) u_char
// ** doesn't need to be friendly

//filename UIO-__ls.c
//binary pointwise commutative operator<< I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator<<(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise commutative operator<< I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> operator<<(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//pointwise operator<<= I(u_char) I(u_char)
// ** doesn't need to be friendly

//pointwise operator<<= I(u_char) u_char
// ** doesn't need to be friendly

//filename UIO-__rs.c
//binary pointwise commutative operator>> I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator>>(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise commutative operator>> I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> operator>>(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//pointwise operator>>= I(u_char) I(u_char)
// ** doesn't need to be friendly

//pointwise operator>>= I(u_char) u_char
// ** doesn't need to be friendly

//filename UIO-__co.c
//unary pointwise operator~ I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator~(const IA_Image<IA_Point<int>,u_char> & rhs);

//filename UIO-__aa.c
//binary pointwise commutative operator&& I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator&&(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise commutative operator&& I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> operator&&(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//filename UIO-__oo.c
//binary pointwise commutative operator|| I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator||(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise commutative operator|| I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> operator||(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//filename UIO-__nt.c
//unary pointwise operator! I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> operator!(const IA_Image<IA_Point<int>,u_char> & rhs);

//filename UIO-__lt.c
//binary strictrel non-commutative operator< int I(u_char) I(u_char)
friend int operator<(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary strictrel non-commutative operator< int I(u_char) u_char
friend int operator<(const IA_Image<IA_Point<int>,u_char> &,u_char);

//binary strictrel non-commutative operator< int u_char I(u_char)
friend int operator<(u_char,const IA_Image<IA_Point<int>,u_char> &);

//filename UIO-__le.c
//binary strictrel non-commutative operator<= int I(u_char) I(u_char)
friend int operator<=(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary strictrel non-commutative operator<= int I(u_char) u_char
friend int operator<=(const IA_Image<IA_Point<int>,u_char> &,u_char);

//binary strictrel non-commutative operator<= int u_char I(u_char)
friend int operator<=(u_char,const IA_Image<IA_Point<int>,u_char> &);

//filename UIO-__eq.c
//binary strictrel commutative operator== int I(u_char) I(u_char)
friend int operator==(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary strictrel commutative operator== int I(u_char) u_char
friend int operator==(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//filename UIO-strict_ne.c
//binary strictrel commutative strict_ne subop=operator!= int I(u_char) I(u_char)
friend int strict_ne(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary strictrel commutative strict_ne subop=operator!= int I(u_char) u_char
friend int strict_ne(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//filename UIO-__ge.c
//binary strictrel non-commutative operator>= int I(u_char) I(u_char)
friend int operator>=(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary strictrel non-commutative operator>= int I(u_char) u_char
friend int operator>=(const IA_Image<IA_Point<int>,u_char> &,u_char);

//binary strictrel non-commutative operator>= int u_char I(u_char)
friend int operator>=(u_char,const IA_Image<IA_Point<int>,u_char> &);

//filename UIO-__gt.c
//binary strictrel non-commutative operator> int I(u_char) I(u_char)
friend int operator>(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary strictrel non-commutative operator> int I(u_char) u_char
friend int operator>(const IA_Image<IA_Point<int>,u_char> &,u_char);

//binary strictrel non-commutative operator> int u_char I(u_char)
friend int operator>(u_char,const IA_Image<IA_Point<int>,u_char> &);

//filename UIO-X_lt.c
//binary pointwise non-commutative chi_lt subop=operator< I(IA_Bit) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,IA_Bit> chi_lt(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise non-commutative chi_lt subop=operator< I(IA_Bit) I(u_char) u_char
friend IA_Image<IA_Point<int>,IA_Bit> chi_lt(const IA_Image<IA_Point<int>,u_char> &,u_char);

//binary pointwise non-commutative chi_lt subop=operator< I(IA_Bit) u_char I(u_char)
friend IA_Image<IA_Point<int>,IA_Bit> chi_lt(u_char,const IA_Image<IA_Point<int>,u_char> &);

//filename UIO-X_le.c
//binary pointwise non-commutative chi_le subop=operator<= I(IA_Bit) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,IA_Bit> chi_le(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise non-commutative chi_le subop=operator<= I(IA_Bit) I(u_char) u_char
friend IA_Image<IA_Point<int>,IA_Bit> chi_le(const IA_Image<IA_Point<int>,u_char> &,u_char);

//binary pointwise non-commutative chi_le subop=operator<= I(IA_Bit) u_char I(u_char)
friend IA_Image<IA_Point<int>,IA_Bit> chi_le(u_char,const IA_Image<IA_Point<int>,u_char> &);

//filename UIO-X_eq.c
//binary pointwise commutative chi_eq subop=operator== I(IA_Bit) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,IA_Bit> chi_eq(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise commutative chi_eq subop=operator== I(IA_Bit) I(u_char) u_char
friend IA_Image<IA_Point<int>,IA_Bit> chi_eq(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//filename UIO-X_ne.c
//binary pointwise commutative chi_ne subop=operator!= I(IA_Bit) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,IA_Bit> chi_ne(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise commutative chi_ne subop=operator!= I(IA_Bit) I(u_char) u_char
friend IA_Image<IA_Point<int>,IA_Bit> chi_ne(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//filename UIO-X_ge.c
//binary pointwise non-commutative chi_ge subop=operator>= I(IA_Bit) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,IA_Bit> chi_ge(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise non-commutative chi_ge subop=operator>= I(IA_Bit) I(u_char) u_char
friend IA_Image<IA_Point<int>,IA_Bit> chi_ge(const IA_Image<IA_Point<int>,u_char> &,u_char);

//binary pointwise non-commutative chi_ge subop=operator>= I(IA_Bit) u_char I(u_char)
friend IA_Image<IA_Point<int>,IA_Bit> chi_ge(u_char,const IA_Image<IA_Point<int>,u_char> &);

//filename UIO-X_gt.c
//binary pointwise non-commutative chi_gt subop=operator> I(IA_Bit) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,IA_Bit> chi_gt(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise non-commutative chi_gt subop=operator> I(IA_Bit) I(u_char) u_char
friend IA_Image<IA_Point<int>,IA_Bit> chi_gt(const IA_Image<IA_Point<int>,u_char> &,u_char);

//binary pointwise non-commutative chi_gt subop=operator> I(IA_Bit) u_char I(u_char)
friend IA_Image<IA_Point<int>,IA_Bit> chi_gt(u_char,const IA_Image<IA_Point<int>,u_char> &);

//filename UIO-minmax.c
//binary pointwise commutative max I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> max(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise commutative max I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> max(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//binary pointwise commutative min I(u_char) I(u_char) I(u_char)
friend IA_Image<IA_Point<int>,u_char> min(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,u_char> &);

//binary pointwise commutative min I(u_char) I(u_char) u_char
friend IA_Image<IA_Point<int>,u_char> min(const IA_Image<IA_Point<int>,u_char> &,u_char);
//** doesn't need to be friendly

//filename UIO-reductions.c
//reduction sum subop=operator+ zero=0 int I(u_char)
friend int sum(const IA_Image<IA_Point<int>,u_char> &);

//reduction product subop=operator* zero=1 int I(u_char)
friend int product(const IA_Image<IA_Point<int>,u_char> &);

//reduction max subop=max zero=0 u_char I(u_char)
friend u_char max(const IA_Image<IA_Point<int>,u_char> &);

//reduction min subop=min zero=255 u_char I(u_char)
friend u_char min(const IA_Image<IA_Point<int>,u_char> &);

//filename UIO-unaries.c
//unary pointwise sqr I(int) I(u_char)
friend IA_Image<IA_Point<int>,int> sqr(const IA_Image<IA_Point<int>,u_char> & rhs);

// Emacs -*- C++ -*-

// Machine generated include file, do not modify.

//prefix
//filename IIO-cvcomplex.c
// conversion I(complex) I(int)
//unary pointwise to_complex subop= I(complex) I(int)
friend IA_Image<IA_Point<int>,complex> to_complex(const IA_Image<IA_Point<int>,int> & rhs);

//filename IIO-cvfloat.c
// conversion I(float) I(int)
//unary pointwise to_float subop= I(float) I(int)
friend IA_Image<IA_Point<int>,float> to_float(const IA_Image<IA_Point<int>,int> & rhs);

//filename IIO-to_uchar.c
//unary pointwise to_uchar subop=u_char I(u_char) I(int)
friend IA_Image<IA_Point<int>,u_char> to_uchar(const IA_Image<IA_Point<int>,int> & rhs);

//filename IIO-to_bit.c
//unary pointwise to_bit subop=IA_Bit I(IA_Bit) I(int)
friend IA_Image<IA_Point<int>,IA_Bit> to_bit(const IA_Image<IA_Point<int>,int> & rhs);

//filename IIO-__pl.c
//binary pointwise commutative operator+ I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator+(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise commutative operator+ I(int) I(int) int
friend IA_Image<IA_Point<int>,int> operator+(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//pointwise operator+= I(int) I(int)
// ** doesn't need to be friendly

//pointwise operator+= I(int) int
// ** doesn't need to be friendly

//filename IIO-__mi.c
//binary pointwise non-commutative operator- I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator-(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise non-commutative operator- I(int) I(int) int
friend IA_Image<IA_Point<int>,int> operator-(const IA_Image<IA_Point<int>,int> &,int);

//binary pointwise non-commutative operator- I(int) int I(int)
friend IA_Image<IA_Point<int>,int> operator-(int,const IA_Image<IA_Point<int>,int> &);

//unary pointwise operator- I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator-(const IA_Image<IA_Point<int>,int> & rhs);

//pointwise operator-= I(int) I(int)
// ** doesn't need to be friendly

//pointwise operator-= I(int) int
// ** doesn't need to be friendly

//filename IIO-__ml.c
//binary pointwise commutative operator* I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator*(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise commutative operator* I(int) I(int) int
friend IA_Image<IA_Point<int>,int> operator*(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//pointwise operator*= I(int) I(int)
// ** doesn't need to be friendly

//pointwise operator*= I(int) int
// ** doesn't need to be friendly

// filename IIO-__mlBit.c
// binary pointwise commutative operator* I(int) I(int) I(IA_Bit)
// binary pointwise commutative operator* I(int) int I(IA_Bit)
// pointwise operator*= I(int) I(IA_Bit)
//filename IIO-__dv.c
//binary pointwise non-commutative operator/ I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator/(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise non-commutative operator/ I(int) I(int) int
friend IA_Image<IA_Point<int>,int> operator/(const IA_Image<IA_Point<int>,int> &,int);

//binary pointwise non-commutative operator/ I(int) int I(int)
friend IA_Image<IA_Point<int>,int> operator/(int,const IA_Image<IA_Point<int>,int> &);

//pointwise operator/= I(int) I(int)
// ** doesn't need to be friendly

//pointwise operator/= I(int) int
// ** doesn't need to be friendly

//binary pointwise non-commutative pseudo_div I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> pseudo_div(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise non-commutative pseudo_div I(int) int I(int)
friend IA_Image<IA_Point<int>,int> pseudo_div(int,const IA_Image<IA_Point<int>,int> &);

//filename IIO-__md.c
//binary pointwise non-commutative operator% I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator%(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise non-commutative operator% I(int) I(int) int
friend IA_Image<IA_Point<int>,int> operator%(const IA_Image<IA_Point<int>,int> &,int);

//binary pointwise non-commutative operator% I(int) int I(int)
friend IA_Image<IA_Point<int>,int> operator%(int,const IA_Image<IA_Point<int>,int> &);

//pointwise operator%= I(int) I(int)
// ** doesn't need to be friendly

//pointwise operator%= I(int) int
// ** doesn't need to be friendly

//filename IIO-__ad.c
//binary pointwise commutative operator& I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator&(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise commutative operator& I(int) I(int) int
friend IA_Image<IA_Point<int>,int> operator&(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//pointwise operator&= I(int) I(int)
// ** doesn't need to be friendly

//pointwise operator&= I(int) int
// ** doesn't need to be friendly

//filename IIO-__or.c
//binary pointwise commutative operator| I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator|(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise commutative operator| I(int) I(int) int
friend IA_Image<IA_Point<int>,int> operator|(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//pointwise operator|= I(int) I(int)
// ** doesn't need to be friendly

//pointwise operator|= I(int) int
// ** doesn't need to be friendly

//filename IIO-__er.c
//binary pointwise commutative operator^ I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator^(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise commutative operator^ I(int) I(int) int
friend IA_Image<IA_Point<int>,int> operator^(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//pointwise operator^= I(int) I(int)
// ** doesn't need to be friendly

//pointwise operator^= I(int) int
// ** doesn't need to be friendly

//filename IIO-__ls.c
//binary pointwise commutative operator<< I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator<<(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise commutative operator<< I(int) I(int) int
friend IA_Image<IA_Point<int>,int> operator<<(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//pointwise operator<<= I(int) I(int)
// ** doesn't need to be friendly

//pointwise operator<<= I(int) int
// ** doesn't need to be friendly

//filename IIO-__rs.c
//binary pointwise commutative operator>> I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator>>(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise commutative operator>> I(int) I(int) int
friend IA_Image<IA_Point<int>,int> operator>>(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//pointwise operator>>= I(int) I(int)
// ** doesn't need to be friendly

//pointwise operator>>= I(int) int
// ** doesn't need to be friendly

//filename IIO-__co.c
//unary pointwise operator~ I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator~(const IA_Image<IA_Point<int>,int> & rhs);

//filename IIO-__aa.c
//binary pointwise commutative operator&& I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator&&(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise commutative operator&& I(int) I(int) int
friend IA_Image<IA_Point<int>,int> operator&&(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//filename IIO-__oo.c
//binary pointwise commutative operator|| I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator||(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise commutative operator|| I(int) I(int) int
friend IA_Image<IA_Point<int>,int> operator||(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//filename IIO-__nt.c
//unary pointwise operator! I(int) I(int)
friend IA_Image<IA_Point<int>,int> operator!(const IA_Image<IA_Point<int>,int> & rhs);

//filename IIO-__lt.c
//binary strictrel non-commutative operator< int I(int) I(int)
friend int operator<(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary strictrel non-commutative operator< int I(int) int
friend int operator<(const IA_Image<IA_Point<int>,int> &,int);

//binary strictrel non-commutative operator< int int I(int)
friend int operator<(int,const IA_Image<IA_Point<int>,int> &);

//filename IIO-__le.c
//binary strictrel non-commutative operator<= int I(int) I(int)
friend int operator<=(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary strictrel non-commutative operator<= int I(int) int
friend int operator<=(const IA_Image<IA_Point<int>,int> &,int);

//binary strictrel non-commutative operator<= int int I(int)
friend int operator<=(int,const IA_Image<IA_Point<int>,int> &);

//filename IIO-__eq.c
//binary strictrel commutative operator== int I(int) I(int)
friend int operator==(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary strictrel commutative operator== int I(int) int
friend int operator==(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//filename IIO-strict_ne.c
//binary strictrel commutative strict_ne subop=operator!= int I(int) I(int)
friend int strict_ne(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary strictrel commutative strict_ne subop=operator!= int I(int) int
friend int strict_ne(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//filename IIO-__ge.c
//binary strictrel non-commutative operator>= int I(int) I(int)
friend int operator>=(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary strictrel non-commutative operator>= int I(int) int
friend int operator>=(const IA_Image<IA_Point<int>,int> &,int);

//binary strictrel non-commutative operator>= int int I(int)
friend int operator>=(int,const IA_Image<IA_Point<int>,int> &);

//filename IIO-__gt.c
//binary strictrel non-commutative operator> int I(int) I(int)
friend int operator>(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary strictrel non-commutative operator> int I(int) int
friend int operator>(const IA_Image<IA_Point<int>,int> &,int);

//binary strictrel non-commutative operator> int int I(int)
friend int operator>(int,const IA_Image<IA_Point<int>,int> &);

//filename IIO-X_lt.c
//binary pointwise non-commutative chi_lt subop=operator< I(IA_Bit) I(int) I(int)
friend IA_Image<IA_Point<int>,IA_Bit> chi_lt(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise non-commutative chi_lt subop=operator< I(IA_Bit) I(int) int
friend IA_Image<IA_Point<int>,IA_Bit> chi_lt(const IA_Image<IA_Point<int>,int> &,int);

//binary pointwise non-commutative chi_lt subop=operator< I(IA_Bit) int I(int)
friend IA_Image<IA_Point<int>,IA_Bit> chi_lt(int,const IA_Image<IA_Point<int>,int> &);

//filename IIO-X_le.c
//binary pointwise non-commutative chi_le subop=operator<= I(IA_Bit) I(int) I(int)
friend IA_Image<IA_Point<int>,IA_Bit> chi_le(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise non-commutative chi_le subop=operator<= I(IA_Bit) I(int) int
friend IA_Image<IA_Point<int>,IA_Bit> chi_le(const IA_Image<IA_Point<int>,int> &,int);

//binary pointwise non-commutative chi_le subop=operator<= I(IA_Bit) int I(int)
friend IA_Image<IA_Point<int>,IA_Bit> chi_le(int,const IA_Image<IA_Point<int>,int> &);

//filename IIO-X_eq.c
//binary pointwise commutative chi_eq subop=operator== I(IA_Bit) I(int) I(int)
friend IA_Image<IA_Point<int>,IA_Bit> chi_eq(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise commutative chi_eq subop=operator== I(IA_Bit) I(int) int
friend IA_Image<IA_Point<int>,IA_Bit> chi_eq(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//filename IIO-X_ne.c
//binary pointwise commutative chi_ne subop=operator!= I(IA_Bit) I(int) I(int)
friend IA_Image<IA_Point<int>,IA_Bit> chi_ne(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise commutative chi_ne subop=operator!= I(IA_Bit) I(int) int
friend IA_Image<IA_Point<int>,IA_Bit> chi_ne(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//filename IIO-X_ge.c
//binary pointwise non-commutative chi_ge subop=operator>= I(IA_Bit) I(int) I(int)
friend IA_Image<IA_Point<int>,IA_Bit> chi_ge(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise non-commutative chi_ge subop=operator>= I(IA_Bit) I(int) int
friend IA_Image<IA_Point<int>,IA_Bit> chi_ge(const IA_Image<IA_Point<int>,int> &,int);

//binary pointwise non-commutative chi_ge subop=operator>= I(IA_Bit) int I(int)
friend IA_Image<IA_Point<int>,IA_Bit> chi_ge(int,const IA_Image<IA_Point<int>,int> &);

//filename IIO-X_gt.c
//binary pointwise non-commutative chi_gt subop=operator> I(IA_Bit) I(int) I(int)
friend IA_Image<IA_Point<int>,IA_Bit> chi_gt(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise non-commutative chi_gt subop=operator> I(IA_Bit) I(int) int
friend IA_Image<IA_Point<int>,IA_Bit> chi_gt(const IA_Image<IA_Point<int>,int> &,int);

//binary pointwise non-commutative chi_gt subop=operator> I(IA_Bit) int I(int)
friend IA_Image<IA_Point<int>,IA_Bit> chi_gt(int,const IA_Image<IA_Point<int>,int> &);

//filename IIO-unaries.c
//unary pointwise isqrt I(int) I(int)
friend IA_Image<IA_Point<int>,int> isqrt(const IA_Image<IA_Point<int>,int> & rhs);

//unary pointwise sqr I(int) I(int)
friend IA_Image<IA_Point<int>,int> sqr(const IA_Image<IA_Point<int>,int> & rhs);

//unary pointwise abs I(int) I(int)
friend IA_Image<IA_Point<int>,int> abs(const IA_Image<IA_Point<int>,int> & rhs);

//unary pointwise sgn I(int) I(int)
friend IA_Image<IA_Point<int>,int> sgn(const IA_Image<IA_Point<int>,int> & rhs);

//filename IIO-minmax.c
//binary pointwise commutative max I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> max(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise commutative max I(int) I(int) int
friend IA_Image<IA_Point<int>,int> max(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//binary pointwise commutative min I(int) I(int) I(int)
friend IA_Image<IA_Point<int>,int> min(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,int> &);

//binary pointwise commutative min I(int) I(int) int
friend IA_Image<IA_Point<int>,int> min(const IA_Image<IA_Point<int>,int> &,int);
//** doesn't need to be friendly

//filename IIO-reductions.c
//reduction sum subop=operator+ zero=0 int I(int)
friend int sum(const IA_Image<IA_Point<int>,int> &);

//reduction product zero=1 subop=operator* int I(int)
friend int product(const IA_Image<IA_Point<int>,int> &);

//reduction max zero=-MAXINT int I(int)
friend int max(const IA_Image<IA_Point<int>,int> &);

//reduction min zero=MAXINT int I(int)
friend int min(const IA_Image<IA_Point<int>,int> &);

// Emacs -*- C++ -*-

// Machine generated include file, do not modify.

//prefix
//filename FIO-to_int.c
//unary pointwise to_int subop=int I(int) I(float)
friend IA_Image<IA_Point<int>,int> to_int(const IA_Image<IA_Point<int>,float> & rhs);

//filename FIO-to_uchar.c
//unary pointwise to_uchar subop=u_char I(u_char) I(float)
friend IA_Image<IA_Point<int>,u_char> to_uchar(const IA_Image<IA_Point<int>,float> & rhs);

//filename FIO-__pl.c
//binary pointwise commutative operator+ I(float) I(float) I(float)
friend IA_Image<IA_Point<int>,float> operator+(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise commutative operator+ I(float) I(float) float
friend IA_Image<IA_Point<int>,float> operator+(const IA_Image<IA_Point<int>,float> &,float);
//** doesn't need to be friendly

//pointwise operator+= I(float) I(float)
// ** doesn't need to be friendly

//pointwise operator+= I(float) float
// ** doesn't need to be friendly

//filename FIO-__mi.c
//binary pointwise non-commutative operator- I(float) I(float) I(float)
friend IA_Image<IA_Point<int>,float> operator-(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise non-commutative operator- I(float) I(float) float
friend IA_Image<IA_Point<int>,float> operator-(const IA_Image<IA_Point<int>,float> &,float);

//binary pointwise non-commutative operator- I(float) float I(float)
friend IA_Image<IA_Point<int>,float> operator-(float,const IA_Image<IA_Point<int>,float> &);

//unary pointwise operator- I(float) I(float)
friend IA_Image<IA_Point<int>,float> operator-(const IA_Image<IA_Point<int>,float> & rhs);

//pointwise operator-= I(float) I(float)
// ** doesn't need to be friendly

//pointwise operator-= I(float) float
// ** doesn't need to be friendly

//filename FIO-__ml.c
//binary pointwise commutative operator* I(float) I(float) I(float)
friend IA_Image<IA_Point<int>,float> operator*(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise commutative operator* I(float) I(float) float
friend IA_Image<IA_Point<int>,float> operator*(const IA_Image<IA_Point<int>,float> &,float);
//** doesn't need to be friendly

//pointwise operator*= I(float) I(float)
// ** doesn't need to be friendly

//pointwise operator*= I(float) float
// ** doesn't need to be friendly

// filename FIO-__mlBit.c
// binary pointwise commutative operator* I(float) I(float) I(IA_Bit)
// binary pointwise commutative operator* I(float) float I(IA_Bit)
// pointwise operator*= I(float) I(IA_Bit)
//filename FIO-__dv.c
//binary pointwise non-commutative operator/ I(float) I(float) I(float)
friend IA_Image<IA_Point<int>,float> operator/(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise non-commutative operator/ I(float) I(float) float
friend IA_Image<IA_Point<int>,float> operator/(const IA_Image<IA_Point<int>,float> &,float);

//binary pointwise non-commutative operator/ I(float) float I(float)
friend IA_Image<IA_Point<int>,float> operator/(float,const IA_Image<IA_Point<int>,float> &);

//pointwise operator/= I(float) I(float)
// ** doesn't need to be friendly

//pointwise operator/= I(float) float
// ** doesn't need to be friendly

//binary pointwise non-commutative pseudo_div I(float) I(float) I(float)
friend IA_Image<IA_Point<int>,float> pseudo_div(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise non-commutative pseudo_div I(float) I(float) float
friend IA_Image<IA_Point<int>,float> pseudo_div(const IA_Image<IA_Point<int>,float> &,float);

//binary pointwise non-commutative pseudo_div I(float) float I(float)
friend IA_Image<IA_Point<int>,float> pseudo_div(float,const IA_Image<IA_Point<int>,float> &);

//unary pointwise pseudo_inv I(float) I(float)
friend IA_Image<IA_Point<int>,float> pseudo_inv(const IA_Image<IA_Point<int>,float> & rhs);

//filename FIO-__aa.c
//binary pointwise commutative operator&& I(float) I(float) I(float)
friend IA_Image<IA_Point<int>,float> operator&&(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise commutative operator&& I(float) I(float) float
friend IA_Image<IA_Point<int>,float> operator&&(const IA_Image<IA_Point<int>,float> &,float);
//** doesn't need to be friendly

//filename FIO-__oo.c
//binary pointwise commutative operator|| I(float) I(float) I(float)
friend IA_Image<IA_Point<int>,float> operator||(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise commutative operator|| I(float) I(float) float
friend IA_Image<IA_Point<int>,float> operator||(const IA_Image<IA_Point<int>,float> &,float);
//** doesn't need to be friendly

//filename FIO-__nt.c
//unary pointwise operator! I(float) I(float)
friend IA_Image<IA_Point<int>,float> operator!(const IA_Image<IA_Point<int>,float> & rhs);

//filename FIO-__lt.c
//binary strictrel non-commutative operator< int I(float) I(float)
friend int operator<(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary strictrel non-commutative operator< int I(float) float
friend int operator<(const IA_Image<IA_Point<int>,float> &,float);

//binary strictrel non-commutative operator< int float I(float)
friend int operator<(float,const IA_Image<IA_Point<int>,float> &);

//filename FIO-__le.c
//binary strictrel non-commutative operator<= int I(float) I(float)
friend int operator<=(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary strictrel non-commutative operator<= int I(float) float
friend int operator<=(const IA_Image<IA_Point<int>,float> &,float);

//binary strictrel non-commutative operator<= int float I(float)
friend int operator<=(float,const IA_Image<IA_Point<int>,float> &);

//filename FIO-__eq.c
//binary strictrel commutative operator== int I(float) I(float)
friend int operator==(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary strictrel commutative operator== int I(float) float
friend int operator==(const IA_Image<IA_Point<int>,float> &,float);
//** doesn't need to be friendly

//filename FIO-strict_ne.c
//binary strictrel commutative strict_ne subop=operator!= int I(float) I(float)
friend int strict_ne(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary strictrel commutative strict_ne subop=operator!= int I(float) float
friend int strict_ne(const IA_Image<IA_Point<int>,float> &,float);
//** doesn't need to be friendly

//filename FIO-__ge.c
//binary strictrel non-commutative operator>= int I(float) I(float)
friend int operator>=(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary strictrel non-commutative operator>= int I(float) float
friend int operator>=(const IA_Image<IA_Point<int>,float> &,float);

//binary strictrel non-commutative operator>= int float I(float)
friend int operator>=(float,const IA_Image<IA_Point<int>,float> &);

//filename FIO-__gt.c
//binary strictrel non-commutative operator> int I(float) I(float)
friend int operator>(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary strictrel non-commutative operator> int I(float) float
friend int operator>(const IA_Image<IA_Point<int>,float> &,float);

//binary strictrel non-commutative operator> int float I(float)
friend int operator>(float,const IA_Image<IA_Point<int>,float> &);

//filename FIO-X_lt.c
//binary pointwise non-commutative chi_lt subop=operator< I(IA_Bit) I(float) I(float)
friend IA_Image<IA_Point<int>,IA_Bit> chi_lt(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise non-commutative chi_lt subop=operator< I(IA_Bit) I(float) float
friend IA_Image<IA_Point<int>,IA_Bit> chi_lt(const IA_Image<IA_Point<int>,float> &,float);

//binary pointwise non-commutative chi_lt subop=operator< I(IA_Bit) float I(float)
friend IA_Image<IA_Point<int>,IA_Bit> chi_lt(float,const IA_Image<IA_Point<int>,float> &);

//filename FIO-X_le.c
//binary pointwise non-commutative chi_le subop=operator<= I(IA_Bit) I(float) I(float)
friend IA_Image<IA_Point<int>,IA_Bit> chi_le(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise non-commutative chi_le subop=operator<= I(IA_Bit) I(float) float
friend IA_Image<IA_Point<int>,IA_Bit> chi_le(const IA_Image<IA_Point<int>,float> &,float);

//binary pointwise non-commutative chi_le subop=operator<= I(IA_Bit) float I(float)
friend IA_Image<IA_Point<int>,IA_Bit> chi_le(float,const IA_Image<IA_Point<int>,float> &);

//filename FIO-X_eq.c
//binary pointwise commutative chi_eq subop=operator== I(IA_Bit) I(float) I(float)
friend IA_Image<IA_Point<int>,IA_Bit> chi_eq(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise commutative chi_eq subop=operator== I(IA_Bit) I(float) float
friend IA_Image<IA_Point<int>,IA_Bit> chi_eq(const IA_Image<IA_Point<int>,float> &,float);
//** doesn't need to be friendly

//filename FIO-X_ne.c
//binary pointwise commutative chi_ne subop=operator!= I(IA_Bit) I(float) I(float)
friend IA_Image<IA_Point<int>,IA_Bit> chi_ne(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise commutative chi_ne subop=operator!= I(IA_Bit) I(float) float
friend IA_Image<IA_Point<int>,IA_Bit> chi_ne(const IA_Image<IA_Point<int>,float> &,float);
//** doesn't need to be friendly

//filename FIO-X_ge.c
//binary pointwise non-commutative chi_ge subop=operator>= I(IA_Bit) I(float) I(float)
friend IA_Image<IA_Point<int>,IA_Bit> chi_ge(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise non-commutative chi_ge subop=operator>= I(IA_Bit) I(float) float
friend IA_Image<IA_Point<int>,IA_Bit> chi_ge(const IA_Image<IA_Point<int>,float> &,float);

//binary pointwise non-commutative chi_ge subop=operator>= I(IA_Bit) float I(float)
friend IA_Image<IA_Point<int>,IA_Bit> chi_ge(float,const IA_Image<IA_Point<int>,float> &);

//filename FIO-X_gt.c
//binary pointwise non-commutative chi_gt subop=operator> I(IA_Bit) I(float) I(float)
friend IA_Image<IA_Point<int>,IA_Bit> chi_gt(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise non-commutative chi_gt subop=operator> I(IA_Bit) I(float) float
friend IA_Image<IA_Point<int>,IA_Bit> chi_gt(const IA_Image<IA_Point<int>,float> &,float);

//binary pointwise non-commutative chi_gt subop=operator> I(IA_Bit) float I(float)
friend IA_Image<IA_Point<int>,IA_Bit> chi_gt(float,const IA_Image<IA_Point<int>,float> &);

//filename FIO-libm.c
//unary pointwise sqrt I(float) I(float)
friend IA_Image<IA_Point<int>,float> sqrt(const IA_Image<IA_Point<int>,float> & rhs);

//unary pointwise sqr I(float) I(float)
friend IA_Image<IA_Point<int>,float> sqr(const IA_Image<IA_Point<int>,float> & rhs);

//unary pointwise fabs I(float) I(float)
friend IA_Image<IA_Point<int>,float> fabs(const IA_Image<IA_Point<int>,float> & rhs);

//unary pointwise sgn I(float) I(float)
friend IA_Image<IA_Point<int>,float> sgn(const IA_Image<IA_Point<int>,float> & rhs);

//unary pointwise cos I(float) I(float)
friend IA_Image<IA_Point<int>,float> cos(const IA_Image<IA_Point<int>,float> & rhs);

//unary pointwise sin I(float) I(float)
friend IA_Image<IA_Point<int>,float> sin(const IA_Image<IA_Point<int>,float> & rhs);

//unary pointwise tan I(float) I(float)
friend IA_Image<IA_Point<int>,float> tan(const IA_Image<IA_Point<int>,float> & rhs);

//unary pointwise exp I(float) I(float)
friend IA_Image<IA_Point<int>,float> exp(const IA_Image<IA_Point<int>,float> & rhs);

//unary pointwise log I(float) I(float)
friend IA_Image<IA_Point<int>,float> log(const IA_Image<IA_Point<int>,float> & rhs);

//unary pointwise ceil I(float) I(float)
friend IA_Image<IA_Point<int>,float> ceil(const IA_Image<IA_Point<int>,float> & rhs);

//unary pointwise floor I(float) I(float)
friend IA_Image<IA_Point<int>,float> floor(const IA_Image<IA_Point<int>,float> & rhs);

//filename FIO-minmax.c
//binary pointwise commutative max I(float) I(float) I(float)
friend IA_Image<IA_Point<int>,float> max(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise commutative max I(float) I(float) float
friend IA_Image<IA_Point<int>,float> max(const IA_Image<IA_Point<int>,float> &,float);
//** doesn't need to be friendly

//binary pointwise commutative min I(float) I(float) I(float)
friend IA_Image<IA_Point<int>,float> min(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,float> &);

//binary pointwise commutative min I(float) I(float) float
friend IA_Image<IA_Point<int>,float> min(const IA_Image<IA_Point<int>,float> &,float);
//** doesn't need to be friendly

//filename FIO-reduce.c
//reduction sum zero=0 subop=operator+ float I(float)
friend float sum(const IA_Image<IA_Point<int>,float> &);

//reduction product zero=1 subop=operator* float I(float)
friend float product(const IA_Image<IA_Point<int>,float> &);

//reduction max zero=infinity() subop=max double I(float)
friend double max(const IA_Image<IA_Point<int>,float> &);

//reduction min zero=-infinity() subop=min double I(float)
friend double min(const IA_Image<IA_Point<int>,float> &);

// Emacs -*- C++ -*-

// Machine generated include file, do not modify.

//prefix
//filename CIO-__pl.c
//binary pointwise commutative operator+ I(complex) I(complex) I(complex)
friend IA_Image<IA_Point<int>,complex> operator+(const IA_Image<IA_Point<int>,complex> &,const IA_Image<IA_Point<int>,complex> &);

//binary pointwise commutative operator+ I(complex) I(complex) complex
friend IA_Image<IA_Point<int>,complex> operator+(const IA_Image<IA_Point<int>,complex> &,complex);
//** doesn't need to be friendly

//pointwise operator+= I(complex) I(complex)
// ** doesn't need to be friendly

//pointwise operator+= I(complex) complex
// ** doesn't need to be friendly

//filename CIO-__mi.c
//binary pointwise non-commutative operator- I(complex) I(complex) I(complex)
friend IA_Image<IA_Point<int>,complex> operator-(const IA_Image<IA_Point<int>,complex> &,const IA_Image<IA_Point<int>,complex> &);

//binary pointwise non-commutative operator- I(complex) I(complex) complex
friend IA_Image<IA_Point<int>,complex> operator-(const IA_Image<IA_Point<int>,complex> &,complex);

//binary pointwise non-commutative operator- I(complex) complex I(complex)
friend IA_Image<IA_Point<int>,complex> operator-(complex,const IA_Image<IA_Point<int>,complex> &);

//unary pointwise operator- I(complex) I(complex)
friend IA_Image<IA_Point<int>,complex> operator-(const IA_Image<IA_Point<int>,complex> & rhs);

//pointwise operator-= I(complex) I(complex)
// ** doesn't need to be friendly

//pointwise operator-= I(complex) complex
// ** doesn't need to be friendly

//filename CIO-__ml.c
//binary pointwise commutative operator* I(complex) I(complex) I(complex)
friend IA_Image<IA_Point<int>,complex> operator*(const IA_Image<IA_Point<int>,complex> &,const IA_Image<IA_Point<int>,complex> &);

//binary pointwise commutative operator* I(complex) I(complex) complex
friend IA_Image<IA_Point<int>,complex> operator*(const IA_Image<IA_Point<int>,complex> &,complex);
//** doesn't need to be friendly

//pointwise operator*= I(complex) I(complex)
// ** doesn't need to be friendly

//pointwise operator*= I(complex) complex
// ** doesn't need to be friendly

// filename CIO-__mlBit.c
// binary pointwise commutative operator* I(complex) I(complex) I(IA_Bit)
// binary pointwise commutative operator* I(complex) complex I(IA_Bit)
// pointwise operator*= I(complex) I(IA_Bit)
//filename CIO-__dv.c
//binary pointwise non-commutative operator/ I(complex) I(complex) I(complex)
friend IA_Image<IA_Point<int>,complex> operator/(const IA_Image<IA_Point<int>,complex> &,const IA_Image<IA_Point<int>,complex> &);

//binary pointwise non-commutative operator/ I(complex) I(complex) complex
friend IA_Image<IA_Point<int>,complex> operator/(const IA_Image<IA_Point<int>,complex> &,complex);

//binary pointwise non-commutative operator/ I(complex) complex I(complex)
friend IA_Image<IA_Point<int>,complex> operator/(complex,const IA_Image<IA_Point<int>,complex> &);

//pointwise operator/= I(complex) I(complex)
// ** doesn't need to be friendly

//pointwise operator/= I(complex) complex
// ** doesn't need to be friendly

// filename CIO-__polar.c
// binary pointwise non-commutative polar I(complex) I(float) I(float)
// binary pointwise non-commutative polar I(complex) I(float) float
// binary pointwise non-commutative polar I(complex) float I(float)
//filename CIO-__eq.c
//binary strictrel commutative operator== int I(complex) I(complex)
friend int operator==(const IA_Image<IA_Point<int>,complex> &,const IA_Image<IA_Point<int>,complex> &);

//binary strictrel commutative operator== int I(complex) complex
friend int operator==(const IA_Image<IA_Point<int>,complex> &,complex);
//** doesn't need to be friendly

//filename CIO-strict_ne.c
//binary strictrel commutative strict_ne subop=operator!= int I(complex) I(complex)
friend int strict_ne(const IA_Image<IA_Point<int>,complex> &,const IA_Image<IA_Point<int>,complex> &);

//binary strictrel commutative strict_ne subop=operator!= int I(complex) complex
friend int strict_ne(const IA_Image<IA_Point<int>,complex> &,complex);
//** doesn't need to be friendly

//filename CIO-X_eq.c
//binary pointwise commutative chi_eq subop=operator== I(IA_Bit) I(complex) I(complex)
friend IA_Image<IA_Point<int>,IA_Bit> chi_eq(const IA_Image<IA_Point<int>,complex> &,const IA_Image<IA_Point<int>,complex> &);

//binary pointwise commutative chi_eq subop=operator== I(IA_Bit) I(complex) complex
friend IA_Image<IA_Point<int>,IA_Bit> chi_eq(const IA_Image<IA_Point<int>,complex> &,complex);
//** doesn't need to be friendly

//filename CIO-X_ne.c
//binary pointwise commutative chi_ne subop=operator!= I(IA_Bit) I(complex) I(complex)
friend IA_Image<IA_Point<int>,IA_Bit> chi_ne(const IA_Image<IA_Point<int>,complex> &,const IA_Image<IA_Point<int>,complex> &);

//binary pointwise commutative chi_ne subop=operator!= I(IA_Bit) I(complex) complex
friend IA_Image<IA_Point<int>,IA_Bit> chi_ne(const IA_Image<IA_Point<int>,complex> &,complex);
//** doesn't need to be friendly

//filename CIO-math.c
//unary pointwise sqrt I(complex) I(complex)
friend IA_Image<IA_Point<int>,complex> sqrt(const IA_Image<IA_Point<int>,complex> & rhs);

//unary pointwise sqr I(complex) I(complex)
friend IA_Image<IA_Point<int>,complex> sqr(const IA_Image<IA_Point<int>,complex> & rhs);

//unary pointwise abs_f subop=abs I(float) I(complex)
friend IA_Image<IA_Point<int>,float> abs_f(const IA_Image<IA_Point<int>,complex> & rhs);

//unary pointwise arg_f subop=abs I(float) I(complex)
friend IA_Image<IA_Point<int>,float> arg_f(const IA_Image<IA_Point<int>,complex> & rhs);

//unary pointwise conj subop=conj I(complex) I(complex)
friend IA_Image<IA_Point<int>,complex> conj(const IA_Image<IA_Point<int>,complex> & rhs);

//unary pointwise imag_f subop=imag I(float) I(complex)
friend IA_Image<IA_Point<int>,float> imag_f(const IA_Image<IA_Point<int>,complex> & rhs);

//unary pointwise real_f subop=real I(float) I(complex) 
friend IA_Image<IA_Point<int>,float> real_f(const IA_Image<IA_Point<int>,complex> & rhs);

//filename CIO-reduce.c
//reduction sum zero=0 subop=operator+ complex I(complex)
friend complex sum(const IA_Image<IA_Point<int>,complex> &);

//reduction product zero=1 subop=operator* complex I(complex)
friend complex product(const IA_Image<IA_Point<int>,complex> &);

// Emacs -*- C++ -*-

// Machine generated include file, do not modify.

//filename RGBIOps.c

// 	Copyright 1994, Center for Computer Vision and Visualization,
// 	University of Florida.  All rights reserved.


//  $Log: rgb-operations.desc,v $
//  Revision 1.3.1.1  1994/12/28  18:20:26  thoth
//  Image operations are now friendly with FBI
//  Image ops now use operations table instead of switch.

//  Revision 1.3  1994/08/22  15:20:29  thoth
//  DOS-inspired name rework.

//  Revision 1.2  1994/05/17  12:58:54  thoth
//  modifications to work with new operations generation scheme.

//  RGB operations for the RGB Discrete Image
//constructor I(IA_RGB) I(IA_Bit)
//** constructors are obsolete?

//constructor I(IA_RGB) I(u_char)
//** constructors are obsolete?


//  Need to be able to construct an RGB from three u_chars

// constructor I(IA_RGB) I(u_char) I(u_char) I(u_char)
//unary pointwise to_int I(int) I(IA_RGB)
friend IA_Image<IA_Point<int>,int> to_int(const IA_Image<IA_Point<int>,IA_RGB> & rhs);

//unary pointwise to_float I(float) I(IA_RGB)
friend IA_Image<IA_Point<int>,float> to_float(const IA_Image<IA_Point<int>,IA_RGB> & rhs);

//unary pointwise red I(u_char) I(IA_RGB)
friend IA_Image<IA_Point<int>,u_char> red(const IA_Image<IA_Point<int>,IA_RGB> & rhs);

//unary pointwise green I(u_char) I(IA_RGB)
friend IA_Image<IA_Point<int>,u_char> green(const IA_Image<IA_Point<int>,IA_RGB> & rhs);

//unary pointwise blue I(u_char) I(IA_RGB)
friend IA_Image<IA_Point<int>,u_char> blue(const IA_Image<IA_Point<int>,IA_RGB> & rhs);

//binary strictrel commutative operator== int I(IA_RGB) I(IA_RGB)
friend int operator==(const IA_Image<IA_Point<int>,IA_RGB> &,const IA_Image<IA_Point<int>,IA_RGB> &);

//binary strictrel commutative operator== int I(IA_RGB) IA_RGB
friend int operator==(const IA_Image<IA_Point<int>,IA_RGB> &,IA_RGB);
//** doesn't need to be friendly

//binary strictrel commutative strict_ne subop=operator!= int I(IA_RGB) I(IA_RGB)
friend int strict_ne(const IA_Image<IA_Point<int>,IA_RGB> &,const IA_Image<IA_Point<int>,IA_RGB> &);

//binary strictrel commutative strict_ne subop=operator!= int I(IA_RGB) IA_RGB
friend int strict_ne(const IA_Image<IA_Point<int>,IA_RGB> &,IA_RGB);
//** doesn't need to be friendly

//binary pointwise commutative chi_eq subop=operator== I(IA_Bit) I(IA_RGB) I(IA_RGB)
friend IA_Image<IA_Point<int>,IA_Bit> chi_eq(const IA_Image<IA_Point<int>,IA_RGB> &,const IA_Image<IA_Point<int>,IA_RGB> &);

//binary pointwise commutative chi_eq subop=operator== I(IA_Bit) I(IA_RGB) IA_RGB
friend IA_Image<IA_Point<int>,IA_Bit> chi_eq(const IA_Image<IA_Point<int>,IA_RGB> &,IA_RGB);
//** doesn't need to be friendly

//binary pointwise commutative chi_ne subop=operator!= I(IA_Bit) I(IA_RGB) I(IA_RGB)
friend IA_Image<IA_Point<int>,IA_Bit> chi_ne(const IA_Image<IA_Point<int>,IA_RGB> &,const IA_Image<IA_Point<int>,IA_RGB> &);

//binary pointwise commutative chi_ne subop=operator!= I(IA_Bit) I(IA_RGB) IA_RGB
friend IA_Image<IA_Point<int>,IA_Bit> chi_ne(const IA_Image<IA_Point<int>,IA_RGB> &,IA_RGB);
//** doesn't need to be friendly

