cgit.sxemacs.org Git - sxemacs/blob - modules/ase/ase-interval.h

   1 /*
   2   ase-interval.h -- Interval Sorcery
   3   Copyright (C) 2006, 2007, 2008 Sebastian Freundt
   4
   5   Author:  Sebastian Freundt <hroptatyr@sxemacs.org>
   6
   7   * This file is part of SXEmacs.
   8   *
   9   * Redistribution and use in source and binary forms, with or without
  10   * modification, are permitted provided that the following conditions
  11   * are met:
  12   *
  13   * 1. Redistributions of source code must retain the above copyright
  14   *    notice, this list of conditions and the following disclaimer.
  15   *
  16   * 2. Redistributions in binary form must reproduce the above copyright
  17   *    notice, this list of conditions and the following disclaimer in the
  18   *    documentation and/or other materials provided with the distribution.
  19   *
  20   * 3. Neither the name of the author nor the names of any contributors
  21   *    may be used to endorse or promote products derived from this
  22   *    software without specific prior written permission.
  23   *
  24   * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
  25   * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  26   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  27   * DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  31   * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  32   * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  33   * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  34   * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35   */
  36
  37 /* Synched up with: Not in FSF. */
  38
  39 #ifndef INCLUDED_ase_interval_h_
  40 #define INCLUDED_ase_interval_h_ 1
  41
  42 #include "ase.h"
  43 #include "ase-cartesian.h"
  44
  45 extern const ase_category_t ase_interval_cat;
  46 typedef struct ase_interval_s *ase_interval_t;
  47 typedef struct ase_interval_union_s *ase_interval_union_t;
  48 typedef struct ase_interval_union_item_s *ase_interval_union_item_t;
  49
  50 #define EMOD_ASE_DEBUG_INTV(args...)    EMOD_ASE_DEBUG("[INTV]: " args)
  51 #define EMOD_ASE_DEBUG_INTVU(args...)   EMOD_ASE_DEBUG("[INTVU]: " args)
  52
  53 extern Lisp_Object Q_open, Q_closed, Q_less, Q_greater, Q_eql, Q_unknown;
  54 extern Lisp_Object Q_disjoint, Q_connected;
  55 extern Lisp_Object Qase_interval, Qase_intervalp;
  56 extern Lisp_Object Qase_interval_union, Qase_interval_union_p;
  57 extern Lisp_Object Qase_empty_interval, Qase_universe_interval;
  58
  59 extern void LTX_PUBINIT(ase_interval)(void);
  60 extern void LTX_PUBREINIT(ase_interval)(void);
  61 extern void LTX_PUBDEINIT(ase_interval)(void);
  62
  63 \f
  64 struct ase_interval_s {
  65         struct ase_object_s obj;
  66         int lower_open_p;
  67         int upper_open_p;
  68         int lower_eq_upper_p;
  69         Lisp_Object lower;
  70         Lisp_Object upper;
  71         Lisp_Object lebesgue_measure;
  72         Lisp_Object rational_measure;
  73         Lisp_Object colour;
  74         /* just a ref counter for those nifty recycled items */
  75         struct sxe_refcounter_s refcnt;
  76 };
  77
  78 struct ase_interval_union_item_s {
  79         Lisp_Object current;
  80         ase_interval_union_item_t next;
  81 };
  82
  83 struct ase_interval_union_s {
  84         ase_interval_union_item_t union_ser;
  85         Lisp_Object lebesgue_measure;
  86         Lisp_Object rational_measure;
  87         Lisp_Object colour;
  88         int no_intv;
  89         /* just a ref counter for those nifty recycled items */
  90         struct sxe_refcounter_s refcnt;
  91 };
  92
  93 \f
  94 #define ASE_INTERVALP(_i)                                               \
  95         (DYNACATP(_i) && EQ(XDYNACAT_TYPE(_i), Qase_interval))
  96 #define CHECK_ASE_INTERVAL(x)                                           \
  97         do {                                                            \
  98                 if (!ASE_INTERVALP(x))                                  \
  99                         dead_wrong_type_argument(Qase_intervalp, x);    \
 100         } while (0)
 101 #define CONCHECK_ASE_INTERVAL(x)                                        \
 102         do {                                                            \
 103                 if (!ASE_INTERVALP(x))                                  \
 104                         x = wrong_type_argument(Qase_intervalp, x);     \
 105         } while (0)
 106 extern Lisp_Object _ase_wrap_interval(ase_interval_t);
 107 #define XSETASE_INTERVAL(_res, _int)    (_res) = _ase_wrap_interval((_int))
 108 #define ase_interval_empty_p(_x)        ((_x) == NULL)
 109 #define XASE_INTERVAL(_x)               ((ase_interval_t)get_dynacat(_x))
 110 #define ASE_INTERVAL_EMPTY_P(_x)        ase_interval_empty_p(XASE_INTERVAL(_x))
 111
 112 #define ase_interval_refcnt(_a)         (&((_a)->refcnt))
 113 #define ase_interval_init_refcnt(_a)            \
 114         (sxe_refcounter_init(ase_interval_refcnt(_a)))
 115 #define ase_interval_fini_refcnt(_a)            \
 116         (sxe_refcounter_finish(ase_interval_refcnt(_a)))
 117 #define ase_interval_refval(_a)                 \
 118         (sxe_refcounter_value(ase_interval_refcnt(_a)))
 119 #define ase_interval_incref(_a)                 \
 120         (sxe_refcounter_incref(ase_interval_refcnt(_a)))
 121 #define ase_interval_decref(_a)                 \
 122         (sxe_refcounter_decref(ase_interval_refcnt(_a)))
 123 #define XASE_INTERVAL_REFVAL(_a)                \
 124         (ase_interval_refval(XASE_INTERVAL(_a)))
 125 #define XASE_INTERVAL_INCREF(_a)                \
 126         (ase_interval_incref(XASE_INTERVAL(_a)))
 127 #define XASE_INTERVAL_DECREF(_a)                \
 128         (ase_interval_decref(XASE_INTERVAL(_a)))
 129
 130 #define ASE_INTERVAL_UNION_P(_i)                                        \
 131         (DYNACATP(_i) && EQ(XDYNACAT_TYPE(_i), Qase_interval_union))
 132 #define CHECK_ASE_INTERVAL_UNION(x)                                     \
 133         do {                                                            \
 134                 if (!ASE_INTERVAL_UNION_P(x))                           \
 135                         dead_wrong_type_argument(                       \
 136                                 Qase_interval_union_p, x);              \
 137         } while (0)
 138 #define CONCHECK_ASE_INTERVAL_UNION(x)                                  \
 139         do {                                                            \
 140                 if (!ASE_INTERVAL_UNION_P(x))                           \
 141                         x = wrong_type_argument(                        \
 142                                 Qase_interval_union_p, x);              \
 143         } while (0)
 144 extern Lisp_Object _ase_wrap_interval_union(ase_interval_union_t);
 145 #define XSETASE_INTERVAL_UNION(_res, _intu)             \
 146         (_res) = _ase_wrap_interval_union((_intu))
 147
 148 #define ase_interval_union(_x)          ((_x)->union_ser)
 149 #define XASE_INTERVAL_UNION(_x)         ((ase_interval_union_t)get_dynacat(_x))
 150 #define XASE_INTERVAL_UNION_SER(_x)             \
 151         (ase_interval_union(XASE_INTERVAL_UNION(_x)))
 152 #define XASE_INTERVAL_UNION_FIRST(_x)                   \
 153         (XASE_INTERVAL_UNION_SER(_x)->current)
 154
 155 #define ase_interval_union_refcnt(_a)   (&((_a)->refcnt))
 156 #define ase_interval_union_init_refcnt(_a)              \
 157         (sxe_refcounter_init(ase_interval_union_refcnt(_a)))
 158 #define ase_interval_union_fini_refcnt(_a)              \
 159         (sxe_refcounter_finish(ase_interval_union_refcnt(_a)))
 160 #define ase_interval_union_refval(_a)           \
 161         (sxe_refcounter_value(ase_interval_union_refcnt(_a)))
 162 #define ase_interval_union_incref(_a)           \
 163         (sxe_refcounter_incref(ase_interval_union_refcnt(_a)))
 164 #define ase_interval_union_decref(_a)           \
 165         (sxe_refcounter_decref(ase_interval_union_refcnt(_a)))
 166 #define XASE_INTERVAL_UNION_REFVAL(_a)          \
 167         (ase_interval_union_refval(XASE_INTERVAL_UNION(_a)))
 168 #define XASE_INTERVAL_UNION_INCREF(_a)          \
 169         (ase_interval_union_incref(XASE_INTERVAL_UNION(_a)))
 170 #define XASE_INTERVAL_UNION_DECREF(_a)          \
 171         (ase_interval_union_decref(XASE_INTERVAL_UNION(_a)))
 172
 173 #define ASE_INTERVAL_OR_UNION_P(_i)                                     \
 174         (ASE_INTERVALP(_i) || ASE_INTERVAL_UNION_P(_i))
 175 #define CHECK_ASE_INTERVAL_OR_UNION(x)                                  \
 176         do {                                                            \
 177                 if (!ASE_INTERVAL_OR_UNION_P(x))                        \
 178                         dead_wrong_type_argument(                       \
 179                                 Qase_interval_union_p, x);              \
 180         } while (0)
 181 #define CONCHECK_ASE_INTERVAL_OR_UNION(x)                               \
 182         do {                                                            \
 183                 if (!ASE_INTERVAL_OR_UNION_P(x))                        \
 184                         x = wrong_type_argument(                        \
 185                                 Qase_interval_union_p, x);              \
 186         } while (0)
 187
 188 #define ASE_INTERVAL_INTERIOR_P(_i)                                     \
 189         (ASE_CARTESIAN_INTERIOR_P(_i) &&                                \
 190          EQ(XASE_CARTESIAN_INTERIOR_TYPE(_i), Qase_interval))
 191 #define CHECK_ASE_INTERVAL_INTERIOR(x)                                  \
 192         do {                                                            \
 193                 if (!ASE_INTERVAL_INTERIOR_P(x))                        \
 194                         dead_wrong_type_argument(                       \
 195                                 Qase_cartesian_interior_p, x);          \
 196         } while (0)
 197 #define CONCHECK_ASE_INTERVAL_INTERIOR_P(x)                             \
 198         do {                                                            \
 199                 if (!ASE_INTERVAL_INTERIOR_P(x))                        \
 200                         x = wrong_type_argument(                        \
 201                                 Qase_cartesian_interior_p, x);          \
 202         } while (0)
 203
 204 #define ASE_UBERINTERVALP(_i)                                           \
 205         (ASE_INTERVALP(_i) || ASE_INTERVAL_UNION_P(_i) ||               \
 206          ASE_INTERVAL_INTERIOR_P(_i))
 207 #define CHECK_ASE_UBERINTERVAL(x)                                       \
 208         do {                                                            \
 209                 if (!ASE_UBERINTERVALP(x))                              \
 210                         dead_wrong_type_argument(                       \
 211                                 Qase_interval_union_p, x);              \
 212         } while (0)
 213 #define CONCHECK_ASE_UBERINTERVAL(x)                                    \
 214         do {                                                            \
 215                 if (!ASE_UBERINTERVALP(x))                              \
 216                         x = wrong_type_argument(                        \
 217                                 Qase_interval_union_p, x);              \
 218         } while (0)
 219
 220 \f
 221 /* constructors */
 222 extern ase_interval_t
 223 _ase_make_interval(Lisp_Object, Lisp_Object, int, int);
 224 extern Lisp_Object
 225 ase_make_interval(Lisp_Object lower, Lisp_Object upper, int, int);
 226 extern Lisp_Object ase_copy_interval(Lisp_Object intv);
 227 extern Lisp_Object ase_empty_interval(void);
 228 extern Lisp_Object ase_universe_interval(void);
 229 extern Lisp_Object ase_empty_interval_union(void);
 230 extern Lisp_Object ase_interval_boundary(Lisp_Object intv);
 231 extern Lisp_Object ase_interval_interior_boundary(Lisp_Object intv_intr_prod);
 232 extern Lisp_Object ase_interval_union_boundary(Lisp_Object intv_union);
 233 extern Lisp_Object ase_interval_closure(Lisp_Object intv);
 234 extern Lisp_Object ase_interval_interior_closure(Lisp_Object intv_intr_prod);
 235 extern Lisp_Object ase_interval_union_closure(Lisp_Object intv_union);
 236 extern Lisp_Object ase_interval_interior(Lisp_Object intv);
 237 extern Lisp_Object ase_interval_interior_interior(Lisp_Object intv_intr_prod);
 238 extern Lisp_Object ase_interval_union_interior(Lisp_Object intv_union);
 239
 240 /* predicates */
 241 extern bool
 242 _ase_interval_contains_obj_p(ase_interval_t, Lisp_Object);
 243 extern Lisp_Object
 244 ase_interval_contains_obj_p(Lisp_Object i, Lisp_Object obj);
 245 extern int
 246 _ase_interval_contains_intv_p(ase_interval_t, ase_interval_t);
 247 extern Lisp_Object
 248 ase_interval_contains_intv_p(Lisp_Object i1, Lisp_Object i2);
 249 extern Lisp_Object
 250 ase_interval_contains_union_p(Lisp_Object i, Lisp_Object u);
 251 extern Lisp_Object
 252 ase_interval_union_contains_obj_p(Lisp_Object iu, Lisp_Object obj);
 253 extern Lisp_Object
 254 ase_interval_union_contains_intv_p(Lisp_Object, Lisp_Object);
 255 extern Lisp_Object
 256 ase_interval_union_contains_intr_p(Lisp_Object, Lisp_Object);
 257 extern Lisp_Object
 258 ase_interval_union_contains_union_p(Lisp_Object, Lisp_Object);
 259 extern Lisp_Object
 260 ase_interval_interior_contains_obj_p(Lisp_Object, Lisp_Object);
 261 extern Lisp_Object
 262 ase_interval_interior_contains_intr_p(Lisp_Object, Lisp_Object);
 263 extern Lisp_Object
 264 ase_interval_interior_contains_union_p(Lisp_Object, Lisp_Object);
 265 extern int
 266 ase_interval_connected_p(Lisp_Object i1, Lisp_Object i2);
 267 extern int
 268 ase_interval_connected_union_p(Lisp_Object i, Lisp_Object iu);
 269 extern int
 270 ase_interval_union_connected_intv_p(Lisp_Object iu, Lisp_Object i);
 271 extern int
 272 ase_interval_union_connected_intr_p(Lisp_Object iu, Lisp_Object iip);
 273 extern int
 274 ase_interval_union_connected_p(Lisp_Object iu1, Lisp_Object iu2);
 275 extern int
 276 ase_interval_interior_connected_union_p(Lisp_Object iip, Lisp_Object iu);
 277 extern int
 278 ase_interval_interior_connected_p(Lisp_Object iip1, Lisp_Object iip2);
 279 extern int
 280 ase_interval_disjoint_p(Lisp_Object i1, Lisp_Object i2);
 281 extern int
 282 ase_interval_disjoint_union_p(Lisp_Object i, Lisp_Object iu);
 283 extern int
 284 ase_interval_union_disjoint_intv_p(Lisp_Object iu, Lisp_Object i);
 285 extern int
 286 ase_interval_union_disjoint_intr_p(Lisp_Object iu, Lisp_Object iip);
 287 extern int
 288 ase_interval_union_disjoint_p(Lisp_Object iu1, Lisp_Object iu2);
 289 extern int
 290 ase_interval_interior_disjoint_union_p(Lisp_Object iip, Lisp_Object iu);
 291 extern int
 292 ase_interval_interior_disjoint_p(Lisp_Object iip1, Lisp_Object iip2);
 293 extern int
 294 ase_interval_open_p(Lisp_Object intv);
 295 extern int
 296 ase_interval_closed_p(Lisp_Object intv);
 297 extern int
 298 ase_interval_union_open_p(Lisp_Object intv_union);
 299 extern int
 300 ase_interval_union_closed_p(Lisp_Object intv_union);
 301 extern int
 302 ase_interval_interior_open_p(Lisp_Object);
 303 extern int
 304 ase_interval_interior_closed_p(Lisp_Object);
 305 EXFUN(Fase_interval_contains_p, 2);
 306 EXFUN(Fase_interval_connected_p, MANY);
 307 EXFUN(Fase_interval_disjoint_p, MANY);
 308 EXFUN(Fase_interval_equal_p, 2);
 309
 310 /* measures */
 311 extern Lisp_Object
 312 ase_interval_lebesgue_measure(ase_interval_t);
 313 extern Lisp_Object
 314 ase_interval_rational_measure(ase_interval_t);
 315 extern Lisp_Object
 316 ase_interval_union_lebesgue_measure(ase_interval_union_t);
 317 extern Lisp_Object
 318 ase_interval_union_rational_measure(ase_interval_union_t);
 319 extern Lisp_Object
 320 ase_interval_interior_lebesgue_measure(ase_cartesian_t);
 321 extern Lisp_Object
 322 ase_interval_interior_rational_measure(ase_cartesian_t);
 323 EXFUN(Fase_interval_lebesgue_measure, 1);
 324 EXFUN(Fase_interval_rational_measure, 1);
 325
 326 void ase_unite_interval(ase_interval_union_t, ase_interval_union_t);
 327
 328 #endif  /* INCLUDED_ase_interval_h_ */