Extract Subversion ignore data.

[catacomb-perl] / field.xs

# ---?---
#
# $Id$
#
# Field abstraction
#
# (c) 2001 Straylight/Edgeware
#

#----- Licensing notice -----------------------------------------------------
#
# This file is part of the Perl interface to Catacomb.
#
# Catacomb/Perl is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# 
# Catacomb/Perl is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with Catacomb/Perl; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

MODULE = Catacomb PACKAGE = Catacomb::Field PREFIX = field_

Field *
field_prime(me, p)
	SV *me
	mp *p
	C_ARGS:
	p

Field *
field_niceprime(me, p)
	SV *me
	mp *p
	C_ARGS:
	p

Field *
field_binpoly(me, p)
	SV *me
	gf *p
	C_ARGS:
	p

Field *
field_binnorm(me, p, beta)
	SV *me
	gf *p
	gf *beta
	C_ARGS:
	p, beta

Field *
byname(me, str)
	SV *me
	char *str
	PREINIT:
	qd_parse qd;
	CODE:
	qd.e = 0;
	qd.p = str;
	if ((RETVAL = field_parse(&qd)) == 0)
	  croak("bad field spec: %s", qd.e);
	else if (!qd_eofp(&qd)) {
	  F_DESTROY(RETVAL);
	  croak("junk at end of field spec");
	}
	OUTPUT:
	RETVAL

SV *
DESTROY(f)
	Field *f
	CODE:
	F_DESTROY(f);
	XSRETURN_YES;

char *
name(f)
	Field *f
	CODE:
	RETVAL = (char *)F_NAME(f);
	OUTPUT:
	RETVAL

UV
type(f)
	Field *f
	CODE:
	RETVAL = F_TYPE(f);
	OUTPUT:
	RETVAL

fe *
_zero(f)
	Field *f
	CODE:
	RETVAL = MP_COPY(f->zero);
	OUTPUT:
	RETVAL

fe *
_one(f)
	Field *f
	CODE:
	RETVAL = MP_COPY(f->one);
	OUTPUT:
	RETVAL

fe *
m(f)
	Field *f
	CODE:
	RETVAL = MP_COPY(f->m);
	OUTPUT:
	RETVAL

fe *
q(f)
	Field *f
	CODE:
	RETVAL = MP_COPY(f->q);
	OUTPUT:
	RETVAL

UV
nbits(f)
	Field *f
	CODE:
	RETVAL = f->nbits;
	OUTPUT:
	RETVAL

UV
noctets(f)
	Field *f
	CODE:
	RETVAL = f->noctets;
	OUTPUT:
	RETVAL

fe *
_rand(f, r = &rand_global)
	Field *f
	grand *r
	CODE:
	RETVAL = F_RAND(f, MP_NEW, r);
	OUTPUT:
	RETVAL

bool
samep(f, ff)
	Field *f
	Field *ff
	CODE:
	RETVAL = F_SAMEP(f, ff);
	OUTPUT:
	RETVAL

fe *
in(f, x)
	Field *f
	fe *x
	CODE:
	RETVAL = F_IN(f, MP_NEW, x);
	OUTPUT:
	RETVAL

fe *
out(f, x)
	Field *f
	fe *x
	CODE:
	RETVAL = F_OUT(f, MP_NEW, x);
	OUTPUT:
	RETVAL

bool
zerop(f, x)
	Field *f
	fe *x
	CODE:
	RETVAL = F_ZEROP(f, x);
	OUTPUT:
	RETVAL

fe *
neg(f, x)
	Field *f
	fe *x
	CODE:
	RETVAL = F_NEG(f, MP_NEW, x);
	OUTPUT:
	RETVAL

fe *
add(f, x, y)
	Field *f
	fe *x
	fe *y
	CODE:
	RETVAL = F_ADD(f, MP_NEW, x, y);
	OUTPUT:
	RETVAL

fe *
sub(f, x, y)
	Field *f
	fe *x
	fe *y
	CODE:
	RETVAL = F_SUB(f, MP_NEW, x, y);
	OUTPUT:
	RETVAL

fe *
mul(f, x, y)
	Field *f
	fe *x
	fe *y
	CODE:
	RETVAL = F_MUL(f, MP_NEW, x, y);
	OUTPUT:
	RETVAL

fe *
sqr(f, x)
	Field *f
	fe *x
	CODE:
	RETVAL = F_SQR(f, MP_NEW, x);
	OUTPUT:
	RETVAL

fe *
inv(f, x)
	Field *f
	fe *x
	CODE:
	if (F_ZEROP(f, x))
	  croak("division by zero");
	RETVAL = F_INV(f, MP_NEW, x);
	OUTPUT:
	RETVAL

fe *
reduce(f, x)
	Field *f
	fe *x
	CODE:
	RETVAL = F_REDUCE(f, MP_NEW, x);
	OUTPUT:
	RETVAL

fe *
sqrt(f, x)
	Field *f
	fe *x
	CODE:
	RETVAL = F_SQRT(f, MP_NEW, x);
	OUTPUT:
	RETVAL

fe *
quadsolve(f, x)
	Field *f
	fe *x
	CODE:
	if (F_TYPE(f) != FTY_BINARY)
	  croak("quadsolve only works on binary fields");
	RETVAL = F_QUADSOLVE(f, MP_NEW, x);
	OUTPUT:
	RETVAL

fe *
dbl(f, x)
	Field *f
	fe *x
	CODE:
	if (F_TYPE(f) != FTY_PRIME)
	  croak("dbl only works on prime fields");
	RETVAL = F_DBL(f, MP_NEW, x);
	OUTPUT:
	RETVAL

fe *
tpl(f, x)
	Field *f
	fe *x
	CODE:
	if (F_TYPE(f) != FTY_PRIME)
	  croak("tpl only works on prime fields");
	RETVAL = F_TPL(f, MP_NEW, x);
	OUTPUT:
	RETVAL

fe *
qdl(f, x)
	Field *f
	fe *x
	CODE:
	if (F_TYPE(f) != FTY_PRIME)
	  croak("qdl only works on prime fields");
	RETVAL = F_QDL(f, MP_NEW, x);
	OUTPUT:
	RETVAL

fe *
hlv(f, x)
	Field *f
	fe *x
	CODE:
	if (F_TYPE(f) != FTY_PRIME)
	  croak("hlv only works on prime fields");
	RETVAL = F_HLV(f, MP_NEW, x);
	OUTPUT:
	RETVAL

SV *
get(f)
	Field *f
	CODE:
	RETVAL = info_field(f);
	OUTPUT:
	RETVAL