using System;\r
+using Psychlops.Internal;\r
+\r
\r
namespace Psychlops\r
{\r
\r
+ public struct Interval {\r
+ public enum OPERATOR { CLOSE, OPEN };\r
+ public const OPERATOR CLOSE = OPERATOR.CLOSE, OPEN = OPERATOR.OPEN;\r
+ public struct VAL {\r
+ public double val;\r
+ public OPERATOR op;\r
+ public VAL(double v, OPERATOR o)\r
+ {\r
+ val = v;\r
+ op = o;\r
+ }\r
+ public bool bounded()\r
+ {\r
+ return !Double.IsNaN(val) && (!Double.IsInfinity(val) || op == OPERATOR.OPEN);\r
+ }\r
+ }\r
+ public VAL begin, end;\r
+\r
+ /*\r
+ public Interval()\r
+ {\r
+ begin = new VAL { val = Double.PositiveInfinity, op = OPERATOR.CLOSE };\r
+ end = new VAL { val = Double.NegativeInfinity, op = OPERATOR.CLOSE };\r
+ }\r
+ */\r
+ public Interval(double floor_val, double ceil_val)\r
+ {\r
+ begin.val = floor_val;\r
+ begin.op = OPERATOR.CLOSE;\r
+ end.val = ceil_val;\r
+ end.op = OPERATOR.CLOSE;\r
+ }\r
+ public Interval(double floor_val, OPERATOR floor_op, double ceil_val, OPERATOR ceil_op)\r
+ {\r
+ begin.val = floor_val;\r
+ begin.op = floor_op;\r
+ end.val = ceil_val;\r
+ end.op = ceil_op;\r
+ }\r
+\r
+ /*\r
+ public int int_floor();\r
+ public int int_floor(int minval);\r
+ public int int_ceil();\r
+ public int int_ceil(int maxval);\r
+ */\r
+ bool includes(double val)\r
+ {\r
+ bool result = false;\r
+ switch(begin.op) {\r
+ case OPERATOR.CLOSE:\r
+ result = begin.val<=val ? true : false;\r
+ break;\r
+ case OPERATOR.OPEN:\r
+ result = begin.val<val ? true : false;\r
+ break;\r
+ }\r
+ switch(end.op) {\r
+ case OPERATOR.CLOSE:\r
+ result = result && ( end.val>=val ? true : false );\r
+ break;\r
+ case OPERATOR.OPEN:\r
+ result = result && ( end.val>val ? true : false );\r
+ break;\r
+ }\r
+ return result;\r
+ }\r
+\r
+ public bool bounded()\r
+ {\r
+ return begin.bounded() && end.bounded();\r
+ }\r
+\r
+ System.Collections.Generic.IEnumerable<double> step(double steps)\r
+ {\r
+ if (steps > 0) throw new Exception("Interval: step must be a positive");\r
+ // return new IntervalIEnumerable(this, steps);\r
+ Interval it = this;\r
+ long front_step = (it.begin.op == Interval.OPERATOR.CLOSE ? -1 : 0);\r
+ long back_step = (long)System.Math.Floor((it.end.val - it.begin.val) / steps);\r
+ if (it.end.op == Interval.OPERATOR.OPEN && 0 == System.Math.IEEERemainder(it.end.val - it.begin.val, steps))\r
+ {\r
+ back_step -= 1;\r
+ }\r
+ while (front_step <= back_step)\r
+ yield return steps * front_step + it.begin.val;\r
+ }\r
+\r
+\r
+ #region accessor generation\r
+\r
+ public static IntervalAcc operator <(double val, Interval rng)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(val, OPERATOR.OPEN, Double.PositiveInfinity, OPERATOR.CLOSE) };\r
+ }\r
+ public static IntervalAcc operator <=(double val, Interval rng)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(val, OPERATOR.CLOSE, Double.PositiveInfinity, OPERATOR.CLOSE) };\r
+ }\r
+ public static IntervalAcc operator >(double val, Interval rng)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(Double.NegativeInfinity, OPERATOR.CLOSE, val, OPERATOR.OPEN) };\r
+ }\r
+ public static IntervalAcc operator >=(double val, Interval rng)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(Double.NegativeInfinity, OPERATOR.CLOSE, val, OPERATOR.CLOSE) };\r
+ }\r
+ public static IntervalAcc operator <(Interval rng, double val)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(Double.NegativeInfinity, OPERATOR.CLOSE, val, OPERATOR.OPEN) };\r
+ }\r
+ public static IntervalAcc operator <=(Interval rng, double val)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(Double.NegativeInfinity, OPERATOR.CLOSE, val, OPERATOR.CLOSE) };\r
+ }\r
+ public static IntervalAcc operator >(Interval rng, double val)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(val, OPERATOR.OPEN, Double.PositiveInfinity, OPERATOR.CLOSE) };\r
+ }\r
+ public static IntervalAcc operator >=(Interval rng, double val)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(val, OPERATOR.CLOSE, Double.PositiveInfinity, OPERATOR.CLOSE) };\r
+ }\r
+\r
+ #endregion\r
+\r
+ }\r
+\r
+ namespace Internal\r
+ {\r
+ #region accessor definition\r
+\r
+ public struct IntervalAcc\r
+ {\r
+ public Interval instance;\r
+\r
+ public static IntervalAcc operator <(double val, IntervalAcc rng)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.OPEN, rng.instance.end.val, rng.instance.end.op) };\r
+ }\r
+ public static IntervalAcc operator <=(double val, IntervalAcc rng)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.CLOSE, rng.instance.end.val, rng.instance.end.op) };\r
+ }\r
+ public static IntervalAcc operator >(double val, IntervalAcc rng)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(rng.instance.begin.val, rng.instance.begin.op, val, Interval.OPERATOR.OPEN) };\r
+ }\r
+ public static IntervalAcc operator >=(double val, IntervalAcc rng)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(rng.instance.begin.val, rng.instance.begin.op, val, Interval.OPERATOR.CLOSE) };\r
+ }\r
+ public static IntervalAcc operator <(IntervalAcc rng, double val)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(rng.instance.begin.val, rng.instance.begin.op, val, Interval.OPERATOR.OPEN) };\r
+ }\r
+ public static IntervalAcc operator <=(IntervalAcc rng, double val)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(rng.instance.begin.val, rng.instance.begin.op, val, Interval.OPERATOR.CLOSE) };\r
+ }\r
+ public static IntervalAcc operator >(IntervalAcc rng, double val)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.OPEN, rng.instance.end.val, rng.instance.end.op) };\r
+ }\r
+ public static IntervalAcc operator >=(IntervalAcc rng, double val)\r
+ {\r
+ return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.CLOSE, rng.instance.end.val, rng.instance.end.op) };\r
+ }\r
+\r
+ public static implicit operator Interval(IntervalAcc rhs)\r
+ {\r
+ return rhs.instance;\r
+ }\r
+ }\r
+\r
+ #endregion\r
+\r
+ }\r
+\r
+\r
}
\ No newline at end of file
OSDN Git Service
