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 fe *
 101 _zero(f)
 102         Field *f
 103         CODE:
 104         RETVAL = MP_COPY(f->zero);
 105         OUTPUT:
 106         RETVAL
 107
 108 fe *
 109 _one(f)
 110         Field *f
 111         CODE:
 112         RETVAL = MP_COPY(f->one);
 113         OUTPUT:
 114         RETVAL
 115
 116 fe *
 117 m(f)
 118         Field *f
 119         CODE:
 120         RETVAL = MP_COPY(f->m);
 121         OUTPUT:
 122         RETVAL
 123
 124 fe *
 125 q(f)
 126         Field *f
 127         CODE:
 128         RETVAL = MP_COPY(f->q);
 129         OUTPUT:
 130         RETVAL
 131
 132 UV
 133 nbits(f)
 134         Field *f
 135         CODE:
 136         RETVAL = f->nbits;
 137         OUTPUT:
 138         RETVAL
 139
 140 UV
 141 noctets(f)
 142         Field *f
 143         CODE:
 144         RETVAL = f->noctets;
 145         OUTPUT:
 146         RETVAL
 147
 148 fe *
 149 _rand(f, r = &rand_global)
 150         Field *f
 151         grand *r
 152         CODE:
 153         RETVAL = F_RAND(f, MP_NEW, r);
 154         OUTPUT:
 155         RETVAL
 156
 157 bool
 158 samep(f, ff)
 159         Field *f
 160         Field *ff
 161         CODE:
 162         RETVAL = F_SAMEP(f, ff);
 163         OUTPUT:
 164         RETVAL
 165
 166 fe *
 167 in(f, x)
 168         Field *f
 169         fe *x
 170         CODE:
 171         RETVAL = F_IN(f, MP_NEW, x);
 172         OUTPUT:
 173         RETVAL
 174
 175 fe *
 176 out(f, x)
 177         Field *f
 178         fe *x
 179         CODE:
 180         RETVAL = F_OUT(f, MP_NEW, x);
 181         OUTPUT:
 182         RETVAL
 183
 184 bool
 185 zerop(f, x)
 186         Field *f
 187         fe *x
 188         CODE:
 189         RETVAL = F_ZEROP(f, x);
 190         OUTPUT:
 191         RETVAL
 192
 193 fe *
 194 neg(f, x)
 195         Field *f
 196         fe *x
 197         CODE:
 198         RETVAL = F_NEG(f, MP_NEW, x);
 199         OUTPUT:
 200         RETVAL
 201
 202 fe *
 203 add(f, x, y)
 204         Field *f
 205         fe *x
 206         fe *y
 207         CODE:
 208         RETVAL = F_ADD(f, MP_NEW, x, y);
 209         OUTPUT:
 210         RETVAL
 211
 212 fe *
 213 sub(f, x, y)
 214         Field *f
 215         fe *x
 216         fe *y
 217         CODE:
 218         RETVAL = F_SUB(f, MP_NEW, x, y);
 219         OUTPUT:
 220         RETVAL
 221
 222 fe *
 223 mul(f, x, y)
 224         Field *f
 225         fe *x
 226         fe *y
 227         CODE:
 228         RETVAL = F_MUL(f, MP_NEW, x, y);
 229         OUTPUT:
 230         RETVAL
 231
 232 fe *
 233 sqr(f, x)
 234         Field *f
 235         fe *x
 236         CODE:
 237         RETVAL = F_SQR(f, MP_NEW, x);
 238         OUTPUT:
 239         RETVAL
 240
 241 fe *
 242 inv(f, x)
 243         Field *f
 244         fe *x
 245         CODE:
 246         if (F_ZEROP(f, x))
 247           croak("division by zero");
 248         RETVAL = F_INV(f, MP_NEW, x);
 249         OUTPUT:
 250         RETVAL
 251
 252 fe *
 253 reduce(f, x)
 254         Field *f
 255         fe *x
 256         CODE:
 257         RETVAL = F_REDUCE(f, MP_NEW, x);
 258         OUTPUT:
 259         RETVAL
 260
 261 fe *
 262 sqrt(f, x)
 263         Field *f
 264         fe *x
 265         CODE:
 266         RETVAL = F_SQRT(f, MP_NEW, x);
 267         OUTPUT:
 268         RETVAL
 269
 270 fe *
 271 quadsolve(f, x)
 272         Field *f
 273         fe *x
 274         CODE:
 275         if (F_TYPE(f) != FTY_BINARY)
 276           croak("quadsolve only works on binary fields");
 277         RETVAL = F_QUADSOLVE(f, MP_NEW, x);
 278         OUTPUT:
 279         RETVAL
 280
 281 fe *
 282 dbl(f, x)
 283         Field *f
 284         fe *x
 285         CODE:
 286         if (F_TYPE(f) != FTY_PRIME)
 287           croak("dbl only works on prime fields");
 288         RETVAL = F_DBL(f, MP_NEW, x);
 289         OUTPUT:
 290         RETVAL
 291
 292 fe *
 293 tpl(f, x)
 294         Field *f
 295         fe *x
 296         CODE:
 297         if (F_TYPE(f) != FTY_PRIME)
 298           croak("tpl only works on prime fields");
 299         RETVAL = F_TPL(f, MP_NEW, x);
 300         OUTPUT:
 301         RETVAL
 302
 303 fe *
 304 qdl(f, x)
 305         Field *f
 306         fe *x
 307         CODE:
 308         if (F_TYPE(f) != FTY_PRIME)
 309           croak("qdl only works on prime fields");
 310         RETVAL = F_QDL(f, MP_NEW, x);
 311         OUTPUT:
 312         RETVAL
 313
 314 fe *
 315 hlv(f, x)
 316         Field *f
 317         fe *x
 318         CODE:
 319         if (F_TYPE(f) != FTY_PRIME)
 320           croak("hlv only works on prime fields");
 321         RETVAL = F_HLV(f, MP_NEW, x);
 322         OUTPUT:
 323         RETVAL
 324
 325 SV *
 326 get(f)
 327         Field *f
 328         CODE:
 329         RETVAL = info_field(f);
 330         OUTPUT:
 331         RETVAL