chiark - git - mdw - catacomb-perl/blob - gf.xs

   1 # ---?---
   2 #
   3 # $Id$
   4 #
   5 # Multiprecision interface
   6 #
   7 # (c) 2000 Straylight/Edgeware
   8 #
   9
  10 #----- Licensing notice -----------------------------------------------------
  11 #
  12 # This file is part of the Perl interface to Catacomb.
  13 #
  14 # Catacomb/Perl is free software; you can redistribute it and/or modify
  15 # it under the terms of the GNU General Public License as published by
  16 # the Free Software Foundation; either version 2 of the License, or
  17 # (at your option) any later version.
  18 #
  19 # Catacomb/Perl is distributed in the hope that it will be useful,
  20 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 # GNU General Public License for more details.
  23 #
  24 # You should have received a copy of the GNU General Public License
  25 # along with Catacomb/Perl; if not, write to the Free Software Foundation,
  26 # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27 #
  28
  29 MODULE = Catacomb PACKAGE = Catacomb::GF PREFIX = gf_
  30
  31 gf *
  32 new(me, sv = 0, radix = 0)
  33         SV *me
  34         SV *sv
  35         int radix
  36         CODE:
  37         RETVAL = sv ? mp_fromsv(sv, "sv", "Catacomb::GF", radix, 1) : MP_ZERO;
  38         OUTPUT:
  39         RETVAL
  40
  41 gf *
  42 copy(x)
  43         gf *x
  44         CODE:
  45         RETVAL = MP_COPY(x);
  46         OUTPUT:
  47         RETVAL
  48
  49 gf *
  50 loadb(me, sv)
  51         SV *me
  52         SV *sv
  53         PREINIT:
  54         char *p;
  55         STRLEN len;
  56         CODE:
  57         p = SvPV(sv, len);
  58         RETVAL = mp_loadb(MP_NEW, p, len);
  59         OUTPUT:
  60         RETVAL
  61
  62 gf *
  63 loadl(me, sv)
  64         SV *me
  65         SV *sv
  66         PREINIT:
  67         char *p;
  68         STRLEN len;
  69         CODE:
  70         p = SvPV(sv, len);
  71         RETVAL = mp_loadl(MP_NEW, p, len);
  72         OUTPUT:
  73         RETVAL
  74
  75 int
  76 metrics(m)
  77         gf *m
  78         INTERFACE_MACRO:
  79         XSINTERFACE_FUNC
  80         XSINTERFACE_FUNC_SETMP
  81         INTERFACE:
  82         octets bits
  83
  84 SV *
  85 storeb(m, i = -1)
  86         gf *m
  87         int i
  88         PREINIT:
  89         size_t sz;
  90         CODE:
  91         sz = (i < 0) ? mp_octets(m) : i;
  92         RETVAL = NEWSV(0, sz ? sz : 1);
  93         mp_storeb(m, SvPVX(RETVAL), sz);
  94         SvCUR_set(RETVAL, sz);
  95         SvPOK_on(RETVAL);
  96         OUTPUT:
  97         RETVAL
  98
  99 SV *
 100 storel(m, i = -1)
 101         gf *m
 102         int i
 103         PREINIT:
 104         size_t sz;
 105         CODE:
 106         sz = (i < 0) ? mp_octets(m) : i;
 107         RETVAL = NEWSV(0, sz ? sz : 1);
 108         mp_storel(m, SvPVX(RETVAL), sz);
 109         SvCUR_set(RETVAL, sz);
 110         SvPOK_on(RETVAL);
 111         OUTPUT:
 112         RETVAL
 113
 114 SV *
 115 tostring(m, radix = 16)
 116         gf *m
 117         int radix
 118         CODE:
 119         RETVAL = NEWSV(0, 0);
 120         mp_writesv(m, RETVAL, radix);
 121         OUTPUT:
 122         RETVAL
 123
 124 SV *
 125 toint(m)
 126         gf *m
 127         CODE:
 128         RETVAL = newSViv(mp_toiv(m));
 129         OUTPUT:
 130         RETVAL
 131
 132 SV *
 133 DESTROY(m)
 134         gf *m
 135         CODE:
 136         mp_drop(m);
 137         XSRETURN_UNDEF;
 138
 139 mp *
 140 gf_sqr(a)
 141         gf *a
 142         C_ARGS:
 143         MP_NEW, a
 144         INTERFACE_MACRO:
 145         XSINTERFACE_FUNC
 146         XSINTERFACE_FUNC_SETGF
 147         INTERFACE:
 148         sqr
 149
 150 mp *
 151 binop(a, b)
 152         gf *a
 153         gf *b
 154         C_ARGS:
 155         MP_NEW, a, b
 156         INTERFACE_MACRO:
 157         XSINTERFACE_FUNC
 158         XSINTERFACE_FUNC_SETGF
 159         INTERFACE:
 160         add sub mul
 161
 162 gf *
 163 shiftop(a, n)
 164         mp *a
 165         int n
 166         C_ARGS:
 167         MP_NEW, a, n
 168         INTERFACE_MACRO:
 169         XSINTERFACE_FUNC
 170         XSINTERFACE_FUNC_SETMP
 171         INTERFACE:
 172         lsl lsr
 173
 174 int
 175 gf_eq(a, b)
 176         gf *a
 177         gf *b
 178         CODE:
 179         RETVAL = mp_eq(a, b);
 180         OUTPUT:
 181         RETVAL
 182
 183 int
 184 gf_irreduciblep(a)
 185         gf *a
 186
 187 void
 188 div(a, b)
 189         mp *a
 190         mp *b
 191         PREINIT:
 192         mp *q = MP_NEW, *r = MP_NEW;
 193         PPCODE:
 194         if (MP_EQ(b, MP_ZERO))
 195           croak("Divide by zero in Catacomb::GF::div");
 196         q = MP_NEW;
 197         switch (GIMME_V) {
 198           case G_ARRAY:
 199             r = MP_NEW;
 200             mp_div(&q, &r, a, b);
 201             EXTEND(SP, 2);
 202             PUSHs(RET_GF(q));
 203             PUSHs(RET_GF(r));
 204             break;
 205           case G_VOID:
 206             break;
 207           default:
 208             mp_div(&q, &r, a, b);
 209             EXTEND(SP, 1);
 210             PUSHs(RET_GF(q));
 211             break;
 212         }
 213
 214 void
 215 gcd(a, b)
 216         gf *a
 217         gf *b
 218         PREINIT:
 219         gf *g = MP_NEW, *x = MP_NEW, *y = MP_NEW;
 220         PPCODE:
 221         switch (GIMME_V) {
 222           case G_ARRAY:
 223             gf_gcd(&g, &x, &y, a, b);
 224             EXTEND(SP, 3);
 225             PUSHs(RET_GF(g));
 226             PUSHs(RET_GF(x));
 227             PUSHs(RET_GF(y));
 228             break;
 229           case G_VOID:
 230             break;
 231           default:
 232             gf_gcd(&g, 0, 0, a, b);
 233             EXTEND(SP, 1);
 234             PUSHs(RET_GF(g));
 235             break;
 236         }
 237
 238 GF_Reduce *
 239 makereduce(x)
 240         gf *x
 241         CODE:
 242         RETVAL = CREATE(GF_Reduce);
 243         gfreduce_create(RETVAL, x);
 244         OUTPUT:
 245         RETVAL
 246
 247 MODULE = Catacomb PACKAGE = Catacomb::GF::Reduce PREFIX = gfreduce_
 248
 249 GF_Reduce *
 250 new(me, x)
 251         gf *x
 252         CODE:
 253         RETVAL = CREATE(GF_Reduce);
 254         gfreduce_create(RETVAL, x);
 255         OUTPUT:
 256         RETVAL
 257
 258 SV *
 259 DESTROY(r)
 260         GF_Reduce *r
 261         CODE:
 262         gfreduce_destroy(r);
 263         DESTROY(r);
 264         XSRETURN_UNDEF;
 265
 266 gf *
 267 reduce(r, x)
 268         GF_Reduce *r
 269         gf *x
 270         CODE:
 271         RETVAL = gfreduce_do(r, MP_NEW, x);
 272         OUTPUT:
 273         RETVAL
 274
 275 gf *
 276 sqrt(r, x)
 277         GF_Reduce *r
 278         gf *x
 279         CODE:
 280         if ((RETVAL = gfreduce_sqrt(r, MP_NEW, x)) == 0)
 281           XSRETURN_UNDEF;
 282         OUTPUT:
 283         RETVAL
 284
 285 int
 286 gfreduce_trace(r, x)
 287         GF_Reduce *r
 288         gf *x
 289
 290 gf *
 291 gfreduce_halftrace(r, x)
 292         GF_Reduce *r
 293         gf *x
 294         C_ARGS:
 295         r, MP_NEW, x
 296
 297 gf *
 298 quadsolve(r, x)
 299         GF_Reduce *r
 300         gf *x
 301         CODE:
 302         if ((RETVAL = gfreduce_quadsolve(r, MP_NEW, x)) == 0)
 303           XSRETURN_UNDEF;
 304         OUTPUT:
 305         RETVAL
 306
 307 gf *
 308 m(r)
 309         GF_Reduce *r
 310         CODE:
 311         RETVAL = MP_COPY(r->p);
 312         OUTPUT:
 313         RETVAL
 314
 315 gf *
 316 gfreduce_exp(r, x, y)
 317         GF_Reduce *r
 318         gf *x
 319         gf *y
 320         C_ARGS:
 321         r, MP_NEW, x, y
 322
 323 #----- That's all, folks ----------------------------------------------------