namespace Invercargill {

    public class SignedNativeIntegers : NumberEnumerable<int, SignedNativeIntegers> {
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(int));
        }
        protected override int convert(int i) {
            return i;
        }
        protected override bool greater_than(int a, int b) {
            return a > b;
        }
        protected override bool less_than(int a, int b) {
            return a < b;
        }
        protected override bool equal_to(int a, int b) {
            return a == b;
        }
        protected override int add(int a, int b) {
            return a + b;
        }
        protected override int subtract(int a, int b) {
            return a - b;
        }
        protected override int multiply(int a, int b) {
            return a * b;
        }
        protected override int divide(int a, int b) {
            return a / b;
        }
        protected override int zero() {
            return 0;
        }        
    }

    public class UnsignedNativeIntegers : NumberEnumerable<uint, UnsignedNativeIntegers> {
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(uint));
        }
        protected override uint convert(int i) {
            return i;
        }
        protected override bool greater_than(uint a, uint b) {
            return a > b;
        }
        protected override bool less_than(uint a, uint b) {
            return a < b;
        }
        protected override bool equal_to(uint a, uint b) {
            return a == b;
        }
        protected override uint add(uint a, uint b) {
            return a + b;
        }
        protected override uint subtract(uint a, uint b) {
            return a - b;
        }
        protected override uint multiply(uint a, uint b) {
            return a * b;
        }
        protected override uint divide(uint a, uint b) {
            return a / b;
        }
        protected override uint zero() {
            return 0;
        }      
    }

    public class Signed8BitIntegers : NumberEnumerable<int8, Signed8BitIntegers> {
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(int8));
        }
        protected override int8 convert(int i) {
            return (int8)i;
        }
        protected override bool greater_than(int8 a, int8 b) {
            return a > b;
        }
        protected override bool less_than(int8 a, int8 b) {
            return a < b;
        }
        protected override bool equal_to(int8 a, int8 b) {
            return a == b;
        }
        protected override int8 add(int8 a, int8 b) {
            return a + b;
        }
        protected override int8 subtract(int8 a, int8 b) {
            return a - b;
        }
        protected override int8 multiply(int8 a, int8 b) {
            return a * b;
        }
        protected override int8 divide(int8 a, int8 b) {
            return a / b;
        }
        protected override int8 zero() {
            return 0;
        }      
    }

    public class Unsigned8BitIntegers : NumberEnumerable<uint8, Unsigned8BitIntegers> {
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(uint8));
        }
        protected override uint8 convert(int i) {
            return (uint8)i;
        }
        protected override bool greater_than(uint8 a, uint8 b) {
            return a > b;
        }
        protected override bool less_than(uint8 a, uint8 b) {
            return a < b;
        }
        protected override bool equal_to(uint8 a, uint8 b) {
            return a == b;
        }
        protected override uint8 add(uint8 a, uint8 b) {
            return a + b;
        }
        protected override uint8 subtract(uint8 a, uint8 b) {
            return a - b;
        }
        protected override uint8 multiply(uint8 a, uint8 b) {
            return a * b;
        }
        protected override uint8 divide(uint8 a, uint8 b) {
            return a / b;
        }
        protected override uint8 zero() {
            return 0;
        }      
    }

    public class Signed16BitIntegers : NumberEnumerable<int16, Signed16BitIntegers> {
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(int16));
        }
        protected override int16 convert(int i) {
            return (int16)i;
        }
        protected override bool greater_than(int16 a, int16 b) {
            return a > b;
        }
        protected override bool less_than(int16 a, int16 b) {
            return a < b;
        }
        protected override bool equal_to(int16 a, int16 b) {
            return a == b;
        }
        protected override int16 add(int16 a, int16 b) {
            return a + b;
        }
        protected override int16 subtract(int16 a, int16 b) {
            return a - b;
        }
        protected override int16 multiply(int16 a, int16 b) {
            return a * b;
        }
        protected override int16 divide(int16 a, int16 b) {
            return a / b;
        }
        protected override int16 zero() {
            return 0;
        }      
    }

    public class Unsigned16BitIntegers : NumberEnumerable<uint16, Unsigned16BitIntegers> {
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(uint16));
        }
        protected override uint16 convert(int i) {
            return (uint16)i;
        }
        protected override bool greater_than(uint16 a, uint16 b) {
            return a > b;
        }
        protected override bool less_than(uint16 a, uint16 b) {
            return a < b;
        }
        protected override bool equal_to(uint16 a, uint16 b) {
            return a == b;
        }
        protected override uint16 add(uint16 a, uint16 b) {
            return a + b;
        }
        protected override uint16 subtract(uint16 a, uint16 b) {
            return a - b;
        }
        protected override uint16 multiply(uint16 a, uint16 b) {
            return a * b;
        }
        protected override uint16 divide(uint16 a, uint16 b) {
            return a / b;
        }
        protected override uint16 zero() {
            return 0;
        }      
    }

    public class Signed32BitIntegers : NumberEnumerable<int32, Signed32BitIntegers> {
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(int32));
        }
        protected override int32 convert(int i) {
            return (int32)i;
        }
        protected override bool greater_than(int32 a, int32 b) {
            return a > b;
        }
        protected override bool less_than(int32 a, int32 b) {
            return a < b;
        }
        protected override bool equal_to(int32 a, int32 b) {
            return a == b;
        }
        protected override int32 add(int32 a, int32 b) {
            return a + b;
        }
        protected override int32 subtract(int32 a, int32 b) {
            return a - b;
        }
        protected override int32 multiply(int32 a, int32 b) {
            return a * b;
        }
        protected override int32 divide(int32 a, int32 b) {
            return a / b;
        }
        protected override int32 zero() {
            return 0;
        }      
    }

    public class Unsigned32BitIntegers : NumberEnumerable<uint32, Unsigned32BitIntegers> {
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(uint32));
        }
        protected override uint32 convert(int i) {
            return (uint32)i;
        }
        protected override bool greater_than(uint32 a, uint32 b) {
            return a > b;
        }
        protected override bool less_than(uint32 a, uint32 b) {
            return a < b;
        }
        protected override bool equal_to(uint32 a, uint32 b) {
            return a == b;
        }
        protected override uint32 add(uint32 a, uint32 b) {
            return a + b;
        }
        protected override uint32 subtract(uint32 a, uint32 b) {
            return a - b;
        }
        protected override uint32 multiply(uint32 a, uint32 b) {
            return a * b;
        }
        protected override uint32 divide(uint32 a, uint32 b) {
            return a / b;
        }
        protected override uint32 zero() {
            return 0;
        }      
    }

    public class Signed64BitIntegers : NumberEnumerable<int64?, Signed64BitIntegers> {
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(int64?));
        }
        protected override int64? convert(int i) {
            return (int64)i;
        }
        protected override bool greater_than(int64? a, int64? b) {
            return a > b;
        }
        protected override bool less_than(int64? a, int64? b) {
            return a < b;
        }
        protected override bool equal_to(int64? a, int64? b) {
            return a == b;
        }
        protected override int64? add(int64? a, int64? b) {
            return a + b;
        }
        protected override int64? subtract(int64? a, int64? b) {
            return a - b;
        }
        protected override int64? multiply(int64? a, int64? b) {
            return a * b;
        }
        protected override int64? divide(int64? a, int64? b) {
            return a / b;
        }
        protected override int64? zero() {
            return 0;
        }      
    }

    public class Unsigned64BitIntegers : NumberEnumerable<uint64?, Unsigned64BitIntegers> {
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(uint64?));
        }
        protected override uint64? convert(int i) {
            return (uint64)i;
        }
        protected override bool greater_than(uint64? a, uint64? b) {
            return a > b;
        }
        protected override bool less_than(uint64? a, uint64? b) {
            return a < b;
        }
        protected override bool equal_to(uint64? a, uint64? b) {
            return a == b;
        }
        protected override uint64? add(uint64? a, uint64? b) {
            return a + b;
        }
        protected override uint64? subtract(uint64? a, uint64? b) {
            return a - b;
        }
        protected override uint64? multiply(uint64? a, uint64? b) {
            return a * b;
        }
        protected override uint64? divide(uint64? a, uint64? b) {
            return a / b;
        }
        protected override uint64? zero() {
            return 0;
        }      
    }

    public class Doubles : NumberEnumerable<double?, Doubles> {
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(double?));
        }
        protected override double? convert(int i) {
            return (double?)i;
        }
        protected override bool greater_than(double? a, double? b) {
            return a > b;
        }
        protected override bool less_than(double? a, double? b) {
            return a < b;
        }
        protected override bool equal_to(double? a, double? b) {
            return a == b;
        }
        protected override double? add(double? a, double? b) {
            return a + b;
        }
        protected override double? subtract(double? a, double? b) {
            return a - b;
        }
        protected override double? multiply(double? a, double? b) {
            return a * b;
        }
        protected override double? divide(double? a, double? b) {
            return a / b;
        }
        protected override double? zero() {
            return 0;
        }      
    }

    public class Floats : NumberEnumerable<float?, Floats> {
        public override bool can_wrap(GLib.Type element_type) {
            return element_type.is_a(typeof(float?));
        }
        protected override float? convert(int i) {
            return (float?)i;
        }
        protected override bool greater_than(float? a, float? b) {
            return a > b;
        }
        protected override bool less_than(float? a, float? b) {
            return a < b;
        }
        protected override bool equal_to(float? a, float? b) {
            return a == b;
        }
        protected override float? add(float? a, float? b) {
            return a + b;
        }
        protected override float? subtract(float? a, float? b) {
            return a - b;
        }
        protected override float? multiply(float? a, float? b) {
            return a * b;
        }
        protected override float? divide(float? a, float? b) {
            return a / b;
        }
        protected override float? zero() {
            return 0;
        }      
    }

}