mdw@git.distorted.org.uk Git - catacomb-perl/blob - field.xs

   1 # ---?---
   2 #
   3 # $Id$
   4 #
   5 # Field abstraction
   6 #
   7 # (c) 2001 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 MODULE = Catacomb PACKAGE = Catacomb::Field PREFIX = field_
  29
  30 Field *
  31 field_prime(me, p)
  32         SV *me
  33         mp *p
  34         C_ARGS:
  35         p
  36
  37 Field *
  38 field_niceprime(me, p)
  39         SV *me
  40         mp *p
  41         C_ARGS:
  42         p
  43
  44 Field *
  45 field_binpoly(me, p)
  46         SV *me
  47         gf *p
  48         C_ARGS:
  49         p
  50
  51 Field *
  52 field_binnorm(me, p, beta)
  53         SV *me
  54         gf *p
  55         gf *beta
  56         C_ARGS:
  57         p, beta
  58
  59 Field *
  60 byname(me, str)
  61         SV *me
  62         char *str
  63         PREINIT:
  64         qd_parse qd;
  65         CODE:
  66         qd.e = 0;
  67         qd.p = str;
  68         if ((RETVAL = field_parse(&qd)) == 0)
  69           croak("bad field spec: %s", qd.e);
  70         else if (!qd_eofp(&qd)) {
  71           F_DESTROY(RETVAL);
  72           croak("junk at end of field spec");
  73         }
  74         OUTPUT:
  75         RETVAL
  76
  77 SV *
  78 DESTROY(f)
  79         Field *f
  80         CODE:
  81         F_DESTROY(f);
  82         XSRETURN_YES;
  83
  84 char *
  85 name(f)
  86         Field *f
  87         CODE:
  88         RETVAL = (char *)F_NAME(f);
  89         OUTPUT:
  90         RETVAL
  91
  92 UV
  93 type(f)
  94         Field *f
  95         CODE:
  96         RETVAL = F_TYPE(f);
  97         OUTPUT:
  98         RETVAL
  99
 100 mp *
 101 zero(f)
 102         Field *f
 103         CODE:
 104         RETVAL = MP_COPY(f->zero);
 105         OUTPUT:
 106         RETVAL
 107
 108 mp *
 109 one(f)
 110         Field *f
 111         CODE:
 112         RETVAL = MP_COPY(f->one);
 113         OUTPUT:
 114         RETVAL
 115
 116 mp *
 117 m(f)
 118         Field *f
 119         CODE:
 120         RETVAL = MP_COPY(f->m);
 121         OUTPUT:
 122         RETVAL
 123
 124 UV
 125 nbits(f)
 126         Field *f
 127         CODE:
 128         RETVAL = f->nbits;
 129         OUTPUT:
 130         RETVAL
 131
 132 UV
 133 noctets(f)
 134         Field *f
 135         CODE:
 136         RETVAL = f->noctets;
 137         OUTPUT:
 138         RETVAL
 139
 140 mp *
 141 rand(f, r = &rand_global)
 142         Field *f
 143         grand *r
 144         CODE:
 145         RETVAL = F_RAND(f, MP_NEW, r);
 146         OUTPUT:
 147         RETVAL
 148
 149 bool
 150 samep(f, ff)
 151         Field *f
 152         Field *ff
 153         CODE:
 154         RETVAL = F_SAMEP(f, ff);
 155         OUTPUT:
 156         RETVAL
 157
 158 mp *
 159 in(f, x)
 160         Field *f
 161         mp *x
 162         CODE:
 163         RETVAL = F_IN(f, MP_NEW, x);
 164         OUTPUT:
 165         RETVAL
 166
 167 mp *
 168 out(f, x)
 169         Field *f
 170         mp *x
 171         CODE:
 172         RETVAL = F_OUT(f, MP_NEW, x);
 173         OUTPUT:
 174         RETVAL
 175
 176 bool
 177 zerop(f, x)
 178         Field *f
 179         mp *x
 180         CODE:
 181         RETVAL = F_ZEROP(f, x);
 182         OUTPUT:
 183         RETVAL
 184
 185 mp *
 186 neg(f, x)
 187         Field *f
 188         mp *x
 189         CODE:
 190         RETVAL = F_NEG(f, MP_NEW, x);
 191         OUTPUT:
 192         RETVAL
 193
 194 mp *
 195 add(f, x, y)
 196         Field *f
 197         mp *x
 198         mp *y
 199         CODE:
 200         RETVAL = F_ADD(f, MP_NEW, x, y);
 201         OUTPUT:
 202         RETVAL
 203
 204 mp *
 205 sub(f, x, y)
 206         Field *f
 207         mp *x
 208         mp *y
 209         CODE:
 210         RETVAL = F_SUB(f, MP_NEW, x, y);
 211         OUTPUT:
 212         RETVAL
 213
 214 mp *
 215 mul(f, x, y)
 216         Field *f
 217         mp *x
 218         mp *y
 219         CODE:
 220         RETVAL = F_MUL(f, MP_NEW, x, y);
 221         OUTPUT:
 222         RETVAL
 223
 224 mp *
 225 sqr(f, x)
 226         Field *f
 227         mp *x
 228         CODE:
 229         RETVAL = F_SQR(f, MP_NEW, x);
 230         OUTPUT:
 231         RETVAL
 232
 233 mp *
 234 inv(f, x)
 235         Field *f
 236         mp *x
 237         CODE:
 238         RETVAL = F_INV(f, MP_NEW, x);
 239         OUTPUT:
 240         RETVAL
 241
 242 mp *
 243 reduce(f, x)
 244         Field *f
 245         mp *x
 246         CODE:
 247         RETVAL = F_REDUCE(f, MP_NEW, x);
 248         OUTPUT:
 249         RETVAL
 250
 251 mp *
 252 sqrt(f, x)
 253         Field *f
 254         mp *x
 255         CODE:
 256         RETVAL = F_SQRT(f, MP_NEW, x);
 257         OUTPUT:
 258         RETVAL
 259
 260 mp *
 261 quadsolve(f, x)
 262         Field *f
 263         mp *x
 264         CODE:
 265         if (F_TYPE(f) != FTY_BINARY)
 266           croak("quadsolve only works on binary fields");
 267         RETVAL = F_QUADSOLVE(f, MP_NEW, x);
 268         OUTPUT:
 269         RETVAL
 270
 271 mp *
 272 dbl(f, x)
 273         Field *f
 274         mp *x
 275         CODE:
 276         if (F_TYPE(f) != FTY_PRIME)
 277           croak("dbl only works on prime fields");
 278         RETVAL = F_DBL(f, MP_NEW, x);
 279         OUTPUT:
 280         RETVAL
 281
 282 mp *
 283 tpl(f, x)
 284         Field *f
 285         mp *x
 286         CODE:
 287         if (F_TYPE(f) != FTY_PRIME)
 288           croak("tpl only works on prime fields");
 289         RETVAL = F_TPL(f, MP_NEW, x);
 290         OUTPUT:
 291         RETVAL
 292
 293 mp *
 294 qdl(f, x)
 295         Field *f
 296         mp *x
 297         CODE:
 298         if (F_TYPE(f) != FTY_PRIME)
 299           croak("qdl only works on prime fields");
 300         RETVAL = F_QDL(f, MP_NEW, x);
 301         OUTPUT:
 302         RETVAL
 303
 304 mp *
 305 hlv(f, x)
 306         Field *f
 307         mp *x
 308         CODE:
 309         if (F_TYPE(f) != FTY_PRIME)
 310           croak("hlv only works on prime fields");
 311         RETVAL = F_HLV(f, MP_NEW, x);
 312         OUTPUT:
 313         RETVAL
 314