[Octave-cvsupdate] octave-forge/main/comm/src Makeconf.base, NONE, 1.1 Makeconf.in, NONE, 1.1 Makef

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Update of /cvsroot/octave/octave-forge/main/comm/src
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv21751/src

Added Files:
	Makeconf.base Makeconf.in Makefile _errcore.cc _gfweight.cc 
	autogen.sh configure.base cyclgen.cc cyclpoly.cc galois-def.cc 
	galois-def.h galois-ops.h galois.cc galois.h galoisfield.cc 
	galoisfield.h genqamdemod.cc gf.cc install-sh isprimitive.cc 
	octinst.sh.in op-fil-gm.cc op-gm-gm.cc op-gm-m.cc op-gm-s.cc 
	op-m-gm.cc op-s-gm.cc ov-galois.cc ov-galois.h primpoly.cc 
	syndtable.cc 
Log Message:
Changed the directory structure of comm to match the package system

--- NEW FILE: galois.h ---
/*

Copyright (C) 2003 David Bateman

This program 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, or (at your option) any
later version.

This program 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 this program; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

In addition to the terms of the GPL, you are permitted to link
this program with any Open Source program, as defined by the
Open Source Initiative (www.opensource.org)

*/

#if !defined (octave_galois_int_h)
#define octave_galois_int_h 1

#if defined (__GNUG__) && defined (USE_PRAGMA_INTERFACE_IMPLEMENTATION)
#pragma interface
#endif

#include <string>

#include <octave/config.h>
#include <octave/lo-utils.h>
#include <octave/lo-specfun.h>
#include <octave/lo-ieee.h>
#include <octave/lo-error.h>
#include <octave/mx-base.h>
#include <octave/str-vec.h>

#include <octave/defun-dld.h>
#include <octave/error.h>
#include <octave/gripes.h>
#include <octave/oct-obj.h>
#include <octave/ops.h>
#include <octave/ov-base.h>
#include <octave/ov-typeinfo.h>
#include <octave/ov.h>
#include <octave/ov-scalar.h>
#include <octave/ov-re-mat.h>
#include <octave/pr-output.h>
#include <octave/base-lu.h>

#include <octave/mx-defs.h>
#include <octave/mx-op-defs.h>

#ifdef NEED_OCTAVE_QUIT
#define OCTAVE_QUIT do {} while (0)
#else
#include <octave/quit.h>
#endif

#include "galoisfield.h"

typedef void (*solve_singularity_handler) (double rcond);

class
galois : public MArray2<int>
{
public:
  galois (void) : field (NULL) { }
  galois (const MArray2<int>& a, const int& m=1, const int& primpoly=0);
  galois (const Matrix& a, const int& m=1, const int& primpoly=0);
  galois (int nr, int nc, const int& val=0, const int& _m=1, const int& _primpoly=0);
  galois (int nr, int nc, double val=0., const int& _m=1, const int& _primpoly=0);
  galois (const galois& a);
  ~galois (void);

  galois index (idx_vector& i, int resize_ok = 0, const int& rfv = 0) const;

  galois index (idx_vector& i, idx_vector& j, int resize_ok = 0,
		const int& rfv = 0) const;

  // unary operations

  boolMatrix operator ! (void) const;

  galois transpose(void) const;

  // other operations
  boolMatrix all (int dim = -1) const;
  boolMatrix any (int dim = -1) const;

#ifdef HAVE_OLD_OCTAVE_CONCAT
  friend galois concat (const galois& ra, const galois& rb, 
			 const Array<int>& ra_idx);
  friend galois concat (const galois& ra, const Matrix& rb, 
			 const Array<int>& ra_idx);
#endif

#ifdef HAVE_OCTAVE_CONCAT
  galois concat (const galois& rb, const Array<int>& ra_idx);
  galois concat (const Matrix& rb, const Array<int>& ra_idx);
#endif

#if defined(HAVE_OCTAVE_CONCAT) || defined(HAVE_OLD_OCTAVE_CONCAT)
  friend galois concat (const Matrix& ra, const galois& rb, 
			 const Array<int>& ra_idx);

  galois& insert (const galois& a, int r, int c);
#endif

  galois diag (void) const;
  galois diag (int k) const;

  galois prod (int dim) const;
  galois sum (int dim) const;
  galois sumsq (int dim) const;
  galois sqrt (void) const;
  galois log (void) const;
  galois exp (void) const;
  galois inverse (void) const;
  galois inverse (int &info, int force = 0) const;
  galois solve (const galois& b) const;
  galois solve (const galois& b, int& info) const;
  galois solve (const galois& b, int& info,
		solve_singularity_handler sing_handler) const;

  galois determinant (void) const;
  galois determinant (int& info) const;

  galois &operator = (const galois& t); 
  galois &operator += (const galois& a); 
  galois &operator -= (const galois& a); 

 private:
  // Pointer to the Galois field structure used
  galois_field_node *field;

 public:
  // Is the variable initialized??
  bool have_field (void) const { return (field ? true : false); };

  // Access to Galois field structures
  int m (void) const { return (field->m); }
  int primpoly (void) const { return (field->primpoly); }

  int n (void) const { return (field->n); }
  int alpha_to (const int& idx) const { return (field->alpha_to(idx)); }
  int index_of (const int& idx) const { return (field->index_of(idx)); }
};

class
LU : public base_lu <galois, int, Matrix, double>
{
  friend class galois;
public:

  enum pivot_type {
    ROW,
    COL
  };

  LU (void) : base_lu <galois, int, Matrix, double> () { }

  LU (const galois& a, const pivot_type& typ) { factor (a, typ); }

  LU (const galois& a) { factor (a, LU::ROW); }

  LU (const LU& a) : base_lu <galois, int, Matrix, double> (a) { }

  LU& operator = (const LU& a)
    {
      if (this != &a)
	base_lu <galois, int, Matrix, double> :: operator = (a);

      return *this;
    }

  ~LU (void) { }

  galois L (void) const;

  galois U (void) const;

  Matrix P (void) const;

  bool singular (void) const { return info != 0; }

  pivot_type type (void) const { return ptype; }
private:
  void factor (const galois& a, const pivot_type& typ);

  Array<int> IP (void) const;

  galois A (void) const;

  int info;

  pivot_type ptype;
};

void install_gm_gm_ops (void);
void install_gm_m_ops (void);
void install_m_gm_ops (void);
void install_gm_s_ops (void);
void install_s_gm_ops (void);
void install_fil_gm_ops (void);

galois elem_pow (const galois& a, const galois& b);
galois elem_pow (const galois& a, const Matrix& b);
galois elem_pow (const galois& a, double b);
galois elem_pow (const galois& a, int b);

galois pow (const galois& a, const galois& b);
galois pow (const galois& a, double b);
galois pow (const galois& a, int b);

galois xdiv (const galois& a, const galois& b);
galois xdiv (const galois& a, const Matrix& b);
galois xdiv (const Matrix& a, const galois& b);
galois xleftdiv (const galois& a, const galois& b);
galois xleftdiv (const galois& a, const Matrix& b);
galois xleftdiv (const Matrix& a, const galois& b);

galois operator * (const galois& a, const galois& b);
galois operator * (const galois& a, const Matrix& b);
galois operator * (const Matrix& a, const galois& b);

MM_OP_DECLS(galois, galois, galois);
MM_OP_DECLS(galois, galois, Matrix);
MM_OP_DECLS(galois, Matrix, galois);

#endif

/*
;;; Local Variables: ***
;;; mode: C++ ***
;;; End: ***
*/

--- NEW FILE: Makefile ---
sinclude Makeconf

GALOISTARGET = gf.oct
GALOISSOURCES = galois.cc galois-def.cc galoisfield.cc gf.cc op-fil-gm.cc \
	      op-gm-gm.cc op-gm-m.cc op-gm-s.cc op-m-gm.cc op-s-gm.cc \
	      ov-galois.cc 
GALOISOBJECTS = $(patsubst %.cc,%.o,$(GALOISSOURCES))
GALOISLINKTARGETS = $(patsubst %,%$(OCTLINK), \
		    isgalois gdiag greshape gprod gsum \
                    gsumsq gsqrt glog gexp gfilter \
                    glu ginv ginverse gdet grank \
                    rsenc rsdec bchenco bchdeco)

GALOISDEPENDS = $(patsubst %.cc,%.d,$(GALOISSOURCES))
OTHERSOURCES = primpoly.cc isprimitive.cc _errcore.cc cyclpoly.cc cyclgen.cc \
                    syndtable.cc _gfweight.cc genqamdemod.cc
OTHERTARGETS = $(patsubst %.cc,%.oct,$(OTHERSOURCES))
OTHEROBJECTS = $(patsubst %.cc,%.o,$(OTHERSOURCES))
OTHERDEPENDS = $(patsubst %.cc,%.d,$(OTHERSOURCES))
SUBDIRS = doc

TARGETS = $(GALOISTARGET) $(GALOISLINKTARGETS) $(OTHERTARGETS)
OBJECTS = $(GALOISOBJECTS) $(OTHEROBJECTS)
ifeq ($(MAKECMDGOALS),all)
DEPENDS = $(GALOISDEPENDS) $(OTHERDEPENDS)
endif
ifeq ($(MAKECMDGOALS),)
DEPENDS = $(GALOISDEPENDS) $(OTHERDEPENDS)
endif

DELETES = $(OBJECTS) $(GALOISDEPENDS) $(OTHERDEPENDS) *~ $(TARGETS) core octave-core

DEFINES = -DGALOIS_DISP_PRIVATES $(HAVE_DO_FORTRAN_INDEXING) $(HAVE_PROPAGATE_EMPTY_MATRICES) $(HAVE_ND_ARRAYS) $(TYPEID_HAS_CLASS) $(CLASS_HAS_LOAD_SAVE) $(HAVE_OCTAVE_CONCAT) $(HAVE_SWAP_BYTES) $(HAVE_OCTAVE_UPLUS)
MOFLAGS =

.PHONY: all dist clean realclean count $(SUBDIRS)
.SUFFIXES:

all : $(DEPENDS) $(OTHERTARGETS) $(GALOISTARGET) $(GALOISLINKTARGETS) $(SUBDIRS)

install : $(SUBDIRS)
	@$(INSTALL) -d $(DESTDIR)$(MPATH)/comm

$(GALOISTARGET) : $(DEPENDS) $(GALOISOBJECTS) 
	@echo "Linking $@"; \
	$(MKOCTFILE) $(MOFLAGS) $(GALOISOBJECTS) -o $@

$(GALOISLINKTARGETS) :
	@echo "Symbolic linking $@"; $(RM) $@ ; \
	$(MKOCTLINK) $(GALOISTARGET) $@

ifneq (,$(DEPENDS))
  sinclude $(DEPENDS)
endif

$(SUBDIRS) :
	@if test -z "$(MAKECMDGOALS)" ; then \
	    cd $@ && $(MAKE) ; \
	elif grep -q "^$(MAKECMDGOALS) *[:]" $@/Makefile ; then \
	    cd $@ && $(MAKE) $(MAKECMDGOALS) ; \
	fi

%.oct : %.d %.o
	@echo "Linking $@"; \
	$(MKOCTFILE) $(MOFLAGS) $(@:.oct=.o) -o $@

%.d: %.cc
	@echo "Depending $<"; \
	$(MKOCTFILE) $(MOFLAGS) $(DEFINES) -M $<

%.o:%.cc
	@echo "Compiling $@"; \
	$(MKOCTFILE) $(MOFLAGS) $(DEFINES) -c $< 

clean: $(SUBDIRS)
	@echo "Cleaning..."; \
	$(RM) -f $(DELETES)

realclean: $(SUBDIRS)
	@echo "Cleaning..."; \
	$(RM) -f $(DELETES)

dist: $(SUBDIRS)

count: $(SUBDIRS)
	wc *{.cc,.h,.m,.txi}

--- NEW FILE: configure.base ---
dnl The configure script is generated by autogen.sh from configure.base 
dnl and the various configure.add files in the source tree.  Edit 
dnl configure.base and reprocess rather than modifying ./configure.

dnl autoconf 2.13 certainly doesn't work! What is the minimum requirement?
AC_PREREQ(2.2)

AC_INIT(configure.base)

PACKAGE=octave-forge
MAJOR_VERSION=0
MINOR_VERSION=1
PATCH_LEVEL=0

dnl Kill caching --- this ought to be the default
define([AC_CACHE_LOAD], )dnl
define([AC_CACHE_SAVE], )dnl

dnl uncomment to put support files in another directory
dnl AC_CONFIG_AUX_DIR(admin)

VERSION=$MAJOR_VERSION.$MINOR_VERSION.$PATCH_LEVEL
AC_SUBST(PACKAGE)
AC_SUBST(VERSION)

dnl need to find admin files, so keep track of the top dir.
TOPDIR=`pwd`
AC_SUBST(TOPDIR)

dnl if mkoctfile doesn't work, then we need the following:
dnl AC_PROG_CXX
dnl AC_PROG_F77

dnl Need C compiler regardless so define it in a way that
dnl makes autoconf happy and we can override whatever we
dnl need with mkoctfile -p.
dnl XXX FIXME XXX should use mkoctfile to get CC and CFLAGS
AC_PROG_CC

dnl XXX FIXME XXX need tests for -p -c -s in mkoctfile.

dnl *******************************************************************
dnl Sort out mkoctfile version number and install paths

dnl XXX FIXME XXX latest octave has octave-config so we don't
dnl need to discover things here.  Doesn't have --exe-site-dir
dnl but defines --oct-site-dir and --m-site-dir

dnl Check for mkoctfile
AC_CHECK_PROG(MKOCTFILE,mkoctfile,mkoctfile)
test -z "$MKOCTFILE" &&	AC_MSG_WARN([no mkoctfile found on path])

AC_SUBST(ver)
AC_SUBST(subver)
AC_SUBST(mpath)
AC_SUBST(opath)
AC_SUBST(xpath)
AC_SUBST(altpath)
AC_SUBST(altmpath)
AC_SUBST(altopath)

AC_ARG_WITH(path, 
	[  --with-path             install path prefix],
	[ path=$withval ])
AC_ARG_WITH(mpath,
	[  --with-mpath            override path for m-files],
	[mpath=$withval])
AC_ARG_WITH(opath,
	[  --with-opath            override path for oct-files],
	[opath=$withval])
AC_ARG_WITH(xpath,
	[  --with-xpath            override path for executables],
	[xpath=$withval])
AC_ARG_WITH(altpath, 
	[  --with-altpath          alternative functions install path prefix],
	[ altpath=$withval ])
AC_ARG_WITH(altmpath,
	[  --with-altmpath         override path for alternative m-files],
	[altmpath=$withval])
AC_ARG_WITH(altopath,
	[  --with-altopath         override path for alternative oct-files],
	[altopath=$withval])	

if test -n "$path" ; then
   test -z "$mpath" && mpath=$path 
   test -z "$opath" && opath=$path/oct 
   test -z "$xpath" && xpath=$path/bin
   test -z "$altpath" && altpath=$path-alternatives
fi

if test -n "$altpath" ; then
   test -z "$altmpath" && altmpath=$altpath 
   test -z "$altopath" && altopath=$altpath/oct 
fi

dnl Don't query if path/ver are given in the configure environment
#if test -z "$mpath" || test -z "$opath" || test -z "$xpath" || test -z "$altmpath" || test -z "$altopath" || test -z "$ver" ; then
if test -z "$mpath" || test -z "$opath" || test -z "$xpath" || test -z "$ver" ; then
   dnl Construct program to get mkoctfile version and local install paths
   cat > conftest.cc <<EOF
#include <octave/config.h>
#include <octave/version.h>
#include <octave/defaults.h>

#define INFOV "\nINFOV=" OCTAVE_VERSION "\n"

#define INFOH "\nINFOH=" OCTAVE_CANONICAL_HOST_TYPE "\n"

#ifdef OCTAVE_LOCALVERFCNFILEDIR
# define INFOM "\nINFOM=" OCTAVE_LOCALVERFCNFILEDIR "\n"
#else
# define INFOM "\nINFOM=" OCTAVE_LOCALFCNFILEPATH "\n"
#endif

#ifdef OCTAVE_LOCALVEROCTFILEDIR
# define INFOO "\nINFOO=" OCTAVE_LOCALVEROCTFILEDIR "\n"
#else
# define INFOO "\nINFOO=" OCTAVE_LOCALOCTFILEPATH  "\n"
#endif

#ifdef OCTAVE_LOCALVERARCHLIBDIR
# define INFOX "\nINFOX=" OCTAVE_LOCALVERARCHLIBDIR  "\n"
#else
# define INFOX "\nINFOX=" OCTAVE_LOCALARCHLIBDIR  "\n"
#endif

const char *infom = INFOM;
const char *infoo = INFOO;
const char *infox = INFOX;
const char *infoh = INFOH;
const char *infov = INFOV;
EOF

   dnl Compile program perhaps with a special version of mkoctfile
   $MKOCTFILE conftest.cc || AC_MSG_ERROR(Could not run $MKOCTFILE)

   dnl Strip the config info from the compiled file
   eval `strings conftest.o | grep "^INFO.=" | sed -e "s,//.*$,,"`
   rm -rf conftest*

   dnl set the appropriate variables if they are not already set
   ver=`echo $INFOV | sed -e "s/\.//" -e "s/\..*$//"`
   subver=`echo $INFOV | sed -e "[s/^[^.]*[.][^.]*[.]//]"`
   alt_mbase=`echo $INFOM | sed -e "[s,\/[^\/]*$,,]"`
   alt_obase=`echo $INFOO | sed -e "[s,/site.*$,/site,]"`
   test -z "$mpath" && mpath=$INFOM/octave-forge
   test -z "$opath" && opath=$INFOO/octave-forge
   test -z "$xpath" && xpath=$INFOX
   test -z "$altmpath" && altmpath=$alt_mbase/octave-forge-alternatives/m
   test -z "$altopath" && altopath=$alt_obase/octave-forge-alternatives/oct/$INFOH
fi

dnl *******************************************************************

dnl XXX FIXME XXX Should we allow the user to override these?
dnl Do we even need them?  The individual makefiles can call mkoctfile -p
dnl themselves, so the only reason to keep them is for configure, and
dnl for those things which are not built using mkoctfile (e.g., aurecord)
dnl but it is not clear we should be using octave compile flags for those.

dnl C compiler and flags
AC_MSG_RESULT([retrieving compile and link flags from $MKOCTFILE])
CC=`$MKOCTFILE -p CC`
CFLAGS=`$MKOCTFILE -p CFLAGS`
CPPFLAGS=`$MKOCTFILE -p CPPFLAGS`
CPICFLAG=`$MKOCTFILE -p CPICFLAG`
LDFLAGS=`$MKOCTFILE -p LDFLAGS`
LIBS=`$MKOCTFILE -p LIBS`
AC_SUBST(CC)
AC_SUBST(CFLAGS)
AC_SUBST(CPPFLAGS)
AC_SUBST(CPICFLAG)

dnl Fortran compiler and flags
F77=`$MKOCTFILE -p F77`
FFLAGS=`$MKOCTFILE -p FFLAGS`
FPICFLAG=`$MKOCTFILE -p FPICFLAG`
AC_SUBST(F77)
AC_SUBST(FFLAGS)
AC_SUBST(FPICFLAG)

dnl C++ compiler and flags
CXX=`$MKOCTFILE -p CXX`
CXXFLAGS=`$MKOCTFILE -p CXXFLAGS`
CXXPICFLAG=`$MKOCTFILE -p CXXPICFLAG`
AC_SUBST(CXX)
AC_SUBST(CXXFLAGS)
AC_SUBST(CXXPICFLAG)

dnl *******************************************************************

dnl Check for features of your version of mkoctfile.
dnl All checks should be designed so that the default
dnl action if the tests are not performed is to do whatever
dnl is appropriate for the most recent version of Octave.

dnl Define the following macro:
dnl    OF_CHECK_LIB(lib,fn,true,false,helpers)
dnl This is just like AC_CHECK_LIB, but it doesn't update LIBS
AC_DEFUN(OF_CHECK_LIB,
[save_LIBS="$LIBS"
AC_CHECK_LIB($1,$2,$3,$4,$5)
LIBS="$save_LIBS"
])

dnl Define the following macro:
dnl    TRY_MKOCTFILE(msg,program,action_if_true,action_if_false)
dnl
AC_DEFUN(TRY_MKOCTFILE,
[AC_MSG_CHECKING($1)
cat > conftest.cc << EOF
#include <octave/config.h>
$2
EOF
ac_try="$MKOCTFILE -c conftest.cc"
if AC_TRY_EVAL(ac_try) ; then
   AC_MSG_RESULT(yes)
   $3
else
   AC_MSG_RESULT(no)
   $4
fi
])

dnl
dnl Check if F77_FUNC works with MKOCTFILE
dnl
TRY_MKOCTFILE([for F77_FUNC],
[int F77_FUNC (hello, HELLO) (const int &n);],,
[MKOCTFILE="$MKOCTFILE -DF77_FUNC=F77_FCN"])

dnl
dnl Check if octave still uses SLList.h
dnl
TRY_MKOCTFILE([for SLList.h],[#include <octave/SLList.h>],
[MKOCTFILE="$MKOCTFILE -DHAVE_SLLIST_H"],)

dnl
dnl Check if octave has lo_ieee_nan_value
dnl
TRY_MKOCTFILE([for lo_ieee_nan_value],
[ #include <octave/lo-ieee.h>
int test(void) { lo_ieee_nan_value(); }],,
[MKOCTFILE="$MKOCTFILE -DUSE_OCTAVE_NAN"])

dnl
dnl Check if octave is needs octave_idx_type
dnl
TRY_MKOCTFILE([for octave_idx_type],
[#include <octave/oct-types.h>
octave_idx_type test(void) { octave_idx_type idx = 1; return idx; }],,
[MKOCTFILE="$MKOCTFILE -Doctave_idx_type=int"])

dnl
dnl Check if octave uses quit.h
dnl
TRY_MKOCTFILE([for quit.h],[#include <octave/quit.h>],,
[MKOCTFILE="$MKOCTFILE -DNEED_OCTAVE_QUIT"])

dnl **********************************************************

dnl Evaluate an expression in octave
dnl
dnl OCTAVE_EVAL(expr,var) -> var=expr
dnl
AC_DEFUN(OCTAVE_EVAL,
[AC_MSG_CHECKING([for $1 in Octave])
$2=`echo "disp($1)" | $OCTAVE -qf`
AC_MSG_RESULT($$2)
AC_SUBST($2)
])

dnl Check status of an octave variable
dnl
dnl OCTAVE_CHECK_EXIST(variable,action_if_true,action_if_false)
dnl
AC_DEFUN(OCTAVE_CHECK_EXIST,
[AC_MSG_CHECKING([for $1 in Octave])
if test `echo 'disp(exist("$1"))' | $OCTAVE -qf`X != 0X ; then
   AC_MSG_RESULT(yes)
   $2
else
   AC_MSG_RESULT(no)
   $3
fi
])

dnl should check that $(OCTAVE) --version matches $(MKOCTFILE) --version
AC_CHECK_PROG(OCTAVE,octave,octave)
OCTAVE_EVAL(OCTAVE_VERSION,OCTAVE_VERSION)

dnl grab canonical host type so we can write system specific install stuff
OCTAVE_EVAL(octave_config_info('canonical_host_type'),canonical_host_type)

dnl grab SHLEXT from octave config
OCTAVE_EVAL(octave_config_info('SHLEXT'),SHLEXT)

AC_PROG_LN_S
AC_PROG_INSTALL
AC_PROG_RANLIB

dnl Use $(COPY_FLAGS) to set options for cp when installing .oct files.
COPY_FLAGS="-Rfp"
case "$canonical_host_type" in
    *-*-linux*)
        COPY_FLAGS="-fdp"
    ;;
esac
AC_SUBST(COPY_FLAGS)

dnl Use $(STRIP) in the makefile to strip executables.  If not found, 
dnl STRIP expands to ':', which in the makefile does nothing.
dnl Don't need this for .oct files since mkoctfile handles them directly
STRIP=${STRIP-strip}
AC_CHECK_PROG(STRIP,$STRIP,$STRIP,:)

dnl Strip on windows, don't strip on Mac OS/X or IRIX
dnl For the rest, you can force strip using MKOCTFILE="mkoctfile -s"
dnl or avoid strip using STRIP=: before ./configure
case "$canonical_host_type" in
    powerpc-apple-darwin*|*-sgi-*)
	STRIP=:
    ;;
    *-cygwin-*|*-mingw-*) 
	MKOCTFILE="$MKOCTFILE -s" 
    ;;
esac

dnl Things needed to link to X11 programs
dnl defines X_CFLAGS, X_LIBS
AC_SUBST(DEFHAVE_X)
AC_SUBST(X_LIBS)
AC_SUBST(X_CFLAGS)
AC_PATH_XTRA
if test "$no_x" = yes ; then
	DEFHAVE_X=
	XSTATUS="no (plot/g{input,text,zoom,rab} will not work)"
else
	DEFHAVE_X="HAVE_X=1"
	X_LIBS="$X_LIBS $X_PRE_LIBS -lX11 $X_EXTRA_LIBS"
	XSTATUS="yes"
fi

OCTAVE_CHECK_EXIST(autoload,[
	HAVE_AUTOLOAD="yes"
	OCTLINK=.octlink
	MKOCTLINK=$TOPDIR/admin/octlink.sh
],[
	HAVE_AUTOLOAD="no"
	OCTLINK=.oct
	MKOCTLINK=$LN_S
])
AC_SUBST(HAVE_AUTOLOAD)
AC_SUBST(OCTLINK)
AC_SUBST(MKOCTLINK)

OCTAVE_CHECK_EXIST(do_fortran_indexing,
	[HAVE_DO_FORTRAN_INDEXING="-DHAVE_DO_FORTRAN_INDEXING"],)
AC_SUBST(HAVE_DO_FORTRAN_INDEXING)

OCTAVE_CHECK_EXIST(propagate_empty_matrices,
	[PROPAGATE_EMPTY_MATRICES="-DHAVE_PROPAGATE_EMPTY_MATRICES"],)
AC_SUBST(HAVE_PROPAGATE_EMPTY_MATRICES)

OCTAVE_CHECK_EXIST(ok_to_lose_imaginary_part,
  [HAVE_OK_TO_LOSE_IMAGINARY_PART="-DHAVE_OK_TO_LOSE_IMAGINARY_PART"],)
AC_SUBST(HAVE_OK_TO_LOSE_IMAGINARY_PART)

dnl Test for N-dimensional Arrays
TRY_MKOCTFILE([for N-dim arrays],
[#include <octave/dim-vector.h>],
[HAVE_ND_ARRAYS="-DHAVE_ND_ARRAYS"],)
AC_SUBST(HAVE_ND_ARRAYS)

OCTAVE_CHECK_EXIST(class,[TYPEID_HAS_CLASS="-DTYPEID_HAS_CLASS"],)
AC_SUBST(TYPEID_HAS_CLASS)

dnl Test for load/save functions in class
TRY_MKOCTFILE([for load/save functions in class],
[#include <octave/ov-scalar.h>
int main (void) { octave_scalar a; a.load_ascii(std::cin); }],
[CLASS_HAS_LOAD_SAVE="-DCLASS_HAS_LOAD_SAVE"],)
AC_SUBST(CLASS_HAS_LOAD_SAVE)

TRY_MKOCTFILE([for Octave_map indexing],
[#include <octave/oct-map.h>
int main(void) { Octave_map a; a[["key"]]; }],
[HAVE_OCTAVE_MAP_INDEX="-DHAVE_OCTAVE_MAP_INDEX"],)
AC_SUBST(HAVE_OCTAVE_MAP_INDEX)

TRY_MKOCTFILE([for old Octave concatenation],
[#include <octave/dNDArray.h>
int main(void) { NDArray a(dim_vector(1,1)); Array<int> idx(2,0); a=concat(a,a,idx); }],
[HAVE_OCTAVE_CONCAT="-DHAVE_OLD_OCTAVE_CONCAT"],)

TRY_MKOCTFILE([for Octave concatenation],
[#include <octave/dNDArray.h>
int main(void) { NDArray a(dim_vector(1,1)); Array<int> idx(2,0); a=a.concat(a,idx); }],
[HAVE_OCTAVE_CONCAT="-DHAVE_OCTAVE_CONCAT"],)
AC_SUBST(HAVE_OCTAVE_CONCAT)

TRY_MKOCTFILE([for swap_8_bytes],
[#include <sys/types.h>
#include <octave/config.h>
#include <octave/byte-swap.h>
int main(void) {long long a = 1; swap_8_bytes (&a,1);}],,
[HAVE_SWAP_BYTES="-DHAVE_SWAP_BYTES"])
AC_SUBST(HAVE_SWAP_BYTES)

TRY_MKOCTFILE([for op_uplus],
[#include <octave/config.h>
#include <octave/ov.h>
int main(void) {int i = octave_value::op_uplus;}],
[HAVE_OCTAVE_UPLUS="-DHAVE_OCTAVE_UPLUS"],)
AC_SUBST(HAVE_OCTAVE_UPLUS)

dnl Test for the makeinfo program
AC_CHECK_PROG(MAKEINFO,makeinfo,makeinfo)
if [ test -n "$MAKEINFO" ]; then
	dnl Check whether the makeinfo command accepts the 
	dnl "--no-split" option
	touch conftest.texi
	AC_MSG_CHECKING([for makeinfo --no-split])
	ac_try="$MAKEINFO --no-split conftest.texi"
	if AC_TRY_EVAL(ac_try) ; then
		MAKEINFO="$MAKEINFO --no-split"
		AC_MSG_RESULT(yes)
	else
		AC_MSG_RESULT(no)
	fi
	rm -f conftest.*
fi

dnl Test for the texi2dvi program
AC_CHECK_PROG(TEXI2DVI,texi2dvi,texi2dvi)
if [ test -n "$TEXI2DVI" ]; then
	dnl Check whether the texi2dvi command accepts the 
	dnl "--clean" option
	cat > conftest.texi <<EOF
\input texinfo
@bye
EOF
	AC_MSG_CHECKING([that texi2dvi runs])
	ac_try="$TEXI2DVI conftest.texi > /dev/null"
	if AC_TRY_EVAL(ac_try) ; then
	    AC_MSG_RESULT(yes)
	    AC_MSG_CHECKING([for texi2dvi --clean])
	    ac_try="$TEXI2DVI --clean conftest.texi > /dev/null"
	    if AC_TRY_EVAL(ac_try) ; then
		TEXI2DVI="$TEXI2DVI --clean"
		AC_MSG_RESULT(yes)
	    else
		AC_MSG_RESULT(no)
	    fi
	else
	    TEXI2DVI=""
	    AC_MSG_RESULT(no)
	fi
	rm -f conftest.*
fi

dnl Test for the texi2html program
AC_CHECK_PROG(TEXI2HTML,texi2html,texi2html)
if [ test -n "$TEXI2HTML" ]; then
	STATUS="yes"
	dnl Check whether the texi2html command accepts the 
	dnl "-split_chapter -number" option
	touch conftest.texi
	AC_MSG_CHECKING([for texi2html --clean])
	ac_try="$TEXI2HTML -split_chapter -number conftest.texi"
	if AC_TRY_EVAL(ac_try) ; then
		TEXI2HTML="$TEXI2HTML -split_chapter -number"
		AC_MSG_RESULT(yes)
	else
		AC_MSG_RESULT(no)
	fi
	rm -f conftest.*
        dnl TeTex 3.0 on Suse is leaving a conftest directory
	rm -rf conftest
fi

dnl Test for the dvipdf program
AC_CHECK_PROG(DVIPDF,dvipdf,dvipdf)

dnl Test for the dvips program
AC_CHECK_PROG(DVIPS,dvips,dvips)

MKDOC=$TOPDIR/admin/mkdoc
AC_SUBST(MKDOC)

MKTEXI=$TOPDIR/admin/mktexi
AC_SUBST(MKTEXI)

CONFIGURE_OUTPUTS="Makeconf octinst.sh"
STATUS_MSG="
octave commands will install into the following directories:
   m-files:   $mpath
   oct-files: $opath
   binaries:  $xpath
alternatives:
   m-files:   $altmpath
   oct-files: $altopath

shell commands will install into the following directories:
   binaries:  $bindir
   man pages: $mandir
   libraries: $libdir
   headers:   $includedir

octave-forge is configured with
   octave:      $OCTAVE (version $OCTAVE_VERSION)
   mkoctfile:	$MKOCTFILE for Octave $subver
   X11 support:	$XSTATUS
   makeinfo:    $MAKEINFO
   texi2dvi:    $TEXI2DVI
   texi2html:   $TEXI2HTML
   mkdoc:       $MKDOC
   mktexi:      $MKTEXI
   dvips:       $DVIPS
   dvipdf:      $DVIPDF"

--- NEW FILE: gf.cc ---
/*

Copyright (C) 2003 David Bateman

This program 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, or (at your option)
any later version.

This program 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 Octave; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.

[...2365 lines suppressed...]
    for (int l = 0; l < nsym; l++)
      for (int i = 0; i < k; i++)
	msg(l,i) = code(l,i);
  } else {
    for (int l = 0; l < nsym; l++)
      for (int i=0; i < k; i++)
	msg(l,i) = code(l,nn-k+i);
  }

  retval(0) = octave_value(msg);
  retval(1) = octave_value(nerr);
  retval(2) = octave_value(code);
  return retval;
}

/*
;;; Local Variables: ***
;;; mode: C++ ***
;;; End: ***
*/

--- NEW FILE: galoisfield.h ---
/*

Copyright (C) 2003 David Bateman

This program 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, or (at your option) any
later version.

This program 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 this program; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

In addition to the terms of the GPL, you are permitted to link
this program with any Open Source program, as defined by the
Open Source Initiative (www.opensource.org)

*/

#if !defined (octave_galois_field_int_h)
#define octave_galois_field_int_h 1

#if defined (__GNUG__) && defined (USE_PRAGMA_INTERFACE_IMPLEMENTATION)
#pragma interface
#endif

#include <string>

#include "MArray.h"
#include "MArray2.h"

#include "mx-defs.h"
#include "mx-op-defs.h"

// Maximum value of m
#define __OCTAVE_GALOIS_MAX_M  16

// Maximum value of m. If you change the above, change here also
#define __OCTAVE_GALOIS_MAX_M_AS_STRING  "16"

// A0 flag -inf value
#define __OCTAVE_GALOIS_A0  (n)

// The default primitive polynomials for GF(2^(indx+1))
extern int default_galois_primpoly[];

class galois_field_node {
  friend class galois_field_list;
  friend class galois;

private:
  int m;
  int primpoly;
  int n;
  MArray<int> alpha_to;
  MArray<int> index_of;

  galois_field_node *next;
  galois_field_node *prev;

  int count;

public:
  galois_field_node (void);
  galois_field_node (const int& _m = 1, const int& _primpoly = 0);
  galois_field_node & operator = (const galois_field_node &t);
};

class galois_field_list {
private:
  galois_field_node *first;
  galois_field_node *last;

public:
  galois_field_list (void) : first (NULL), last (NULL) { }

  ~galois_field_list( void);

  galois_field_node * find_galois_field(const int& m, const int& primpoly);
  galois_field_node * create_galois_field(const int& m, const int& primpoly);
  int delete_galois_field(galois_field_node *field);

};

#endif

/*
;;; Local Variables: ***
;;; mode: C++ ***
;;; End: ***
*/

--- NEW FILE: op-gm-gm.cc ---
/*

Copyright (C) 2003 David Bateman

This program 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, or (at your option) any
later version.

This program 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 this program; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

In addition to the terms of the GPL, you are permitted to link
this program with any Open Source program, as defined by the
Open Source Initiative (www.opensource.org)

*/

#if defined (__GNUG__) && defined (USE_PRAGMA_INTERFACE_IMPLEMENTATION)
#pragma implementation
#endif

#include <iostream>
#include "galois.h"
#include "ov-galois.h"
#include "galois-ops.h"		// Must come after galois.h

// galois unary ops.

DEFUNOP_OP (not, galois, !)

DEFUNOP (uminus, galois)
{
  CAST_UNOP_ARG (const octave_galois&);

  // Unitary minus of Galois Field is itself!!
  return new octave_galois (v.galois_value());
}

#ifdef HAVE_OCTAVE_UPLUS
DEFUNOP (uplus, galois)
{
  CAST_UNOP_ARG (const octave_galois&);

  return new octave_galois (v.galois_value());
}
#endif

DEFUNOP (transpose, galois)
{
  CAST_UNOP_ARG (const octave_galois&);

  return new octave_galois (v.galois_value().transpose ());
}

// galois by galois ops.

DEFBINOP_OP_G (add, galois, galois, +)
DEFBINOP_OP_G (sub, galois, galois, -) 
DEFBINOP_OP_G (mul, galois, galois, *)
DEFBINOP_FN_G (div, galois, galois, xdiv)
DEFBINOP_FN_G (pow, galois, galois, pow)
DEFBINOP_FN_G (ldiv, galois, galois, xleftdiv)

DEFBINOP_FN (lt, galois, galois, mx_el_lt)
DEFBINOP_FN (le, galois, galois, mx_el_le)
DEFBINOP_FN (eq, galois, galois, mx_el_eq)
DEFBINOP_FN (ge, galois, galois, mx_el_ge)
DEFBINOP_FN (gt, galois, galois, mx_el_gt)
DEFBINOP_FN (ne, galois, galois, mx_el_ne)

DEFBINOP_FN_G (el_mul, galois, galois, product)
DEFBINOP_FN_G (el_div, galois, galois, quotient)
DEFBINOP_FN_G (el_pow, galois, galois, elem_pow)

DEFBINOP (el_ldiv, galois, galois)
{
  CAST_BINOP_ARGS (const octave_galois&, const octave_galois&);

  return new octave_galois (quotient (v2.galois_value (), v1.galois_value ()));
}

DEFBINOP_FN (el_and, galois, galois, mx_el_and)
DEFBINOP_FN (el_or, galois, galois, mx_el_or)

DEFCATOP_G_METHOD (gm_gm, galois, galois, concat)

DEFASSIGNOP_FN (assign, galois, galois, assign)

void
install_gm_gm_ops (void)
{
  INSTALL_UNOP (op_not, octave_galois, not);
  INSTALL_UNOP (op_uminus, octave_galois, uminus);
#ifdef HAVE_OCTAVE_UPLUS
  INSTALL_UNOP (op_uplus, octave_galois, uplus);
#endif
  INSTALL_UNOP (op_transpose, octave_galois, transpose);
  INSTALL_UNOP (op_hermitian, octave_galois, transpose);

  INSTALL_BINOP (op_add, octave_galois, octave_galois, add);
  INSTALL_BINOP (op_sub, octave_galois, octave_galois, sub);
  INSTALL_BINOP (op_mul, octave_galois, octave_galois, mul);
  INSTALL_BINOP (op_div, octave_galois, octave_galois, div);
  INSTALL_BINOP (op_pow, octave_galois, octave_galois, pow);
  INSTALL_BINOP (op_ldiv, octave_galois, octave_galois, ldiv);
  INSTALL_BINOP (op_lt, octave_galois, octave_galois, lt);
  INSTALL_BINOP (op_le, octave_galois, octave_galois, le);
  INSTALL_BINOP (op_eq, octave_galois, octave_galois, eq);
  INSTALL_BINOP (op_ge, octave_galois, octave_galois, ge);
  INSTALL_BINOP (op_gt, octave_galois, octave_galois, gt);
  INSTALL_BINOP (op_ne, octave_galois, octave_galois, ne);
  INSTALL_BINOP (op_el_mul, octave_galois, octave_galois, el_mul);
  INSTALL_BINOP (op_el_div, octave_galois, octave_galois, el_div);
  INSTALL_BINOP (op_el_pow, octave_galois, octave_galois, el_pow);
  INSTALL_BINOP (op_el_ldiv, octave_galois, octave_galois, el_ldiv);
  INSTALL_BINOP (op_el_and, octave_galois, octave_galois, el_and);
  INSTALL_BINOP (op_el_or, octave_galois, octave_galois, el_or);

  INSTALL_G_CATOP (octave_galois, octave_galois, gm_gm);

  INSTALL_ASSIGNOP (op_asn_eq, octave_galois, octave_galois, assign);
}

/*
;;; Local Variables: ***
;;; mode: C++ ***
;;; End: ***
*/

--- NEW FILE: Makeconf.in ---

## Makeconf is automatically generated from Makeconf.base and Makeconf.add
## in the various subdirectories.  To regenerate, use ./autogen.sh to
## create a new ./Makeconf.in, then use ./configure to generate a new
## Makeconf.

OCTAVE_FORGE = 1

SHELL = @SHELL@

canonical_host_type = @canonical_host_type@
prefix = @prefix@
exec_prefix = @exec_prefix@
bindir = @bindir@
mandir = @mandir@
libdir = @libdir@
datadir = @datadir@
infodir = @infodir@
includedir = @includedir@
INSTALL = @INSTALL@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_DATA = @INSTALL_DATA@
INSTALLOCT=octinst.sh

DESTDIR =

RANLIB = @RANLIB@
STRIP = @STRIP@
LN_S = @LN_S@
MKOCTLINK = @MKOCTLINK@
OCTLINK= @OCTLINK@

AWK = @AWK@

# Most octave programs will be compiled with $(MKOCTFILE).  Those which
# cannot use mkoctfile directly can request the flags that mkoctfile 
# would use as follows:
#    FLAG = $(shell $(MKOCTFILE) -p FLAG)
# The following flags are for compiling programs that are independent
# of Octave.  How confusing.
CC = @CC@
CFLAGS = @CFLAGS@
CPPFLAGS = @CPPFLAGS@
CPICFLAG = @CPICFLAG@
CXX = @CXX@
CXXFLAGS = @CXXFLAGS@
CXXPICFLAG = @CXXPICFLAG@
F77 = @F77@
FFLAGS = @FFLAGS@
FPICFLAG = @FPICFLAG@

OCTAVE = @OCTAVE@
OCTAVE_VERSION = @OCTAVE_VERSION@
MKOCTFILE = @MKOCTFILE@ -DHAVE_OCTAVE_$(ver) -v
SHLEXT = @SHLEXT@

@DEFHAVE_X@
X_CFLAGS = @X_CFLAGS@
X_LIBS = @X_LIBS@

ver = @ver@
MPATH = @mpath@
OPATH = @opath@
XPATH = @xpath@
ALTMPATH = @altmpath@
ALTOPATH = @altopath@

HAVE_DO_FORTRAN_INDEXING = @HAVE_DO_FORTRAN_INDEXING@
HAVE_PROPAGATE_EMPTY_MATRICES = @HAVE_PROPAGATE_EMPTY_MATRICES@
HAVE_OK_TO_LOSE_IMAGINARY_PART = @HAVE_OK_TO_LOSE_IMAGINARY_PART@
HAVE_ND_ARRAYS = @HAVE_ND_ARRAYS@
TYPEID_HAS_CLASS = @TYPEID_HAS_CLASS@
CLASS_HAS_LOAD_SAVE = @CLASS_HAS_LOAD_SAVE@
HAVE_OCTAVE_MAP_INDEX = @HAVE_OCTAVE_MAP_INDEX@
HAVE_OCTAVE_CONCAT = @HAVE_OCTAVE_CONCAT@
HAVE_SWAP_BYTES = @HAVE_SWAP_BYTES@
HAVE_OCTAVE_UPLUS = @HAVE_OCTAVE_UPLUS@

MAKEINFO = @MAKEINFO@
TEXI2DVI = @TEXI2DVI@
TEXI2HTML = @TEXI2HTML@
DVIPDF = @DVIPDF@
DVIPS = @DVIPS@

MKDOC = @MKDOC@
MKTEXI = @MKTEXI@

%.o: %.c ; $(MKOCTFILE) -c $<
%.o: %.f ; $(MKOCTFILE) -c $<
%.o: %.cc ; $(MKOCTFILE) -c $<
%.oct: %.cc ; $(MKOCTFILE) $<

--- NEW FILE: cyclpoly.cc ---
/*

Copyright (C) 2003 David Bateman

This program 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, or (at your option)
any later version.

This program 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 Octave; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.

In addition to the terms of the GPL, you are permitted to link
this program with any Open Source program, as defined by the
Open Source Initiative (www.opensource.org)

*/

#include <iostream>
#include <iomanip>
#include <sstream>
#include <octave/oct.h>
#include <octave/pager.h>

enum cyclic_poly_type
{
  CYCLIC_POLY_MIN=0,
  CYCLIC_POLY_MAX,
  CYCLIC_POLY_ALL,
  CYCLIC_POLY_L
};

// A simplified version of the filter function for specific lengths of a and b
// in the Galois field GF(2)
Array<int> filter_gf2 (const Array<int>& b, const Array<int>& a, 
			const Array<int>& x, const int& n) {

  int x_len = x.length ();
  Array<int> si (n, 0);
  Array<int> y (x_len, 0);

  for (int i=0; i < x_len; i++) {
    y(i) = si(0);
    if (b(0) && x(i))
      y(i) ^= 1;

    for (int j = 0; j < n - 1; j++) {
      si(j) = si(j+1);
      if (a(j+1) && y(i))
	si(j) ^= 1;
      if (b(j+1) && x(i))
	si(j) ^= 1;
    }
    si(n-1) = 0;
    if (a(n) && y(i))
      si(n-1) ^= 1;
    if (b(n) && x(i))
      si(n-1) ^= 1;
  }

  return y;
}

// Cyclic polynomial is irreducible. I.E. it divides into x^n-1 without remainder
// There must surely be an easier way of doing this as the polynomials are over
// GF(2).
static bool
do_is_cyclic_polynomial (const unsigned long long& a1, const int& n, const int& m)
{
  Array<int> a (n+1,0);
  Array<int> y (n+1, 0);
  Array<int> x (n-m+2, 0);
  y(0) = 1;
  y(n) = 1;
  x(0) = 1;
  for (int i=0; i < m+1; i++)
    a(i) = (a1 & (1UL <<  i) ? 1 : 0);

  Array<int> b = filter_gf2 (y, a, x, n);
  b.resize(n+1,0);
  Array<int> p (m+1,0);
  p(0) = 1;
  Array<int> q = filter_gf2 (a, p, b, m);

  for (int i=0; i < n+1; i++)
    if (y(i) ^ q(i))
      return false;

  return true;
}

DEFUN_DLD (cyclpoly, args, nargout,
  "-*- texinfo -*-\n"
"@deftypefn {Loadable Function} {@var{y} =} cyclpoly (@var{n},@var{k})\n"
"@deftypefnx {Loadable Function} {@var{y} =} cyclpoly (@var{n},@var{k},@var{opt})\n"
"@deftypefnx {Loadable Function} {@var{y} =} cyclpoly (@var{n},@var{k},@var{opt},@var{rep})\n"
"\n"
"This function returns the cyclic generator polynomials of the code\n"
"[@var{n},@var{k}]. By default the the polynomial with the smallest\n"
"weight is returned. However this behavior can be overridden with the\n"
"@var{opt} flag. Valid values of @var{opt} are:\n"
"\n"
"@table @asis\n"
"@item 'all'\n"
"Returns all of the polynomials of the code [@var{n},@var{k}]\n"
"@item 'min'\n"
"Returns the polynomial of minimum weight of the code [@var{n},@var{k}]\n"
"@item 'max'\n"
"Returns the polynomial of the maximum weight of the code [@var{n},@var{k}]\n"
"@item @var{l}\n"
"Returns the polynomials having exactly the weight @var{l}\n"
"@end table\n"
"\n"
"The polynomials are returns as row-vectors in the variable @var{y}. Each\n"
"row of @var{y} represents a polynomial with the least-significant term\n"
"first. The polynomials can be returned with an integer representation\n"
"if @var{rep} is 'integer'. The default behaviour is given if @var{rep}\n"
"is 'polynomial'.\n"
"@end deftypefn\n"
"@seealso{gf,isprimitive}")
{
  octave_value retval;
  int nargin = args.length ();
  bool polyrep = true;
  enum cyclic_poly_type type = CYCLIC_POLY_MIN;
  RowVector cyclic_polys;
  int l=0;

  if ((nargin < 2) || (nargin > 4)) {
    error("cyclpoly: incorrect number of arguments");
    return retval;
  }

  int n = args(0).int_value();
  int k = args(1).int_value();;

  if (n < 1) {
    error("cyclpoly: n must be 1 or greater");
    return retval;
  }

  if (n <= k) {
    error("cyclpoly: k must be less than n");
    return retval;
  }

  for (int i = 2; i < nargin; i++) {
    if (args(i).is_scalar_type ()) {
      l = args(i).int_value();
      type = CYCLIC_POLY_L;
    } else if (args(i).is_string ()) {
      std::string s_arg = args(i).string_value ();

      if (s_arg == "integer")
	polyrep = false;
      else if (s_arg == "polynomial")
	polyrep = true;
      else if (s_arg == "min")
	type = CYCLIC_POLY_MIN;
      else if (s_arg == "max")
	type = CYCLIC_POLY_MAX;
      else if (s_arg == "all")
	type = CYCLIC_POLY_ALL;
      else {
	error ("cyclpoly: invalid argument");
	return retval;
      }
    } else {
      error ("cyclpoly: incorrect argument type");
      return retval;
    }
  }

  int m = n - k;

  // Matlab code seems to think that 1+x+x^3 is of larger weight than
  // 1+x^2+x^3. So for matlab compatiability the list of polynomials
  // should be reversed by replacing "i+=2" with "i-=2" and visa-versa. 
  // Thats not going to happen!!!

  switch (type) {
  case CYCLIC_POLY_MIN:
    cyclic_polys.resize(1);
    for (unsigned long long i = (1UL<<m)+1; i < (1UL<<(1+m)); i+=2)
      if (do_is_cyclic_polynomial(i, n, m)) {
	cyclic_polys(0) = (double)i;
	break;
      }
    break;
  case CYCLIC_POLY_MAX:
    cyclic_polys.resize(1);
    for (unsigned long long i = (1UL<<(m+1))-1; i > (1UL<<m); i-=2)
      if (do_is_cyclic_polynomial(i, n, m)) {
	cyclic_polys(0) = (double)i;
	break;
      }
    break;
  case CYCLIC_POLY_ALL:
    for (unsigned long long i = (1UL<<m)+1; i < (1UL<<(1+m)); i+=2)
      if (do_is_cyclic_polynomial(i, n, m)) {
	cyclic_polys.resize(cyclic_polys.length()+1);
	cyclic_polys(cyclic_polys.length()-1) = (double)i;
      }
    break;
  case CYCLIC_POLY_L:
    for (unsigned long long i = ((unsigned long long)1<<m)+1; i < ((unsigned long long)1<<(1+m)); i+=2) {
      int li = 0;
      for (int j=0; j < m+1; j++)
	if (i & ((unsigned long long)1 << j))
	  li++;
      if (li == l) {
	if (do_is_cyclic_polynomial(i, n, m)) {
	  cyclic_polys.resize(cyclic_polys.length()+1);
	  cyclic_polys(cyclic_polys.length()-1) = (double)i;
	}
      }
    }
    break;
  default:
    error("cyclpoly: impossible");
    break;
  }

  if (cyclic_polys.length() == 0) {
    octave_stdout << 
      "cyclpoly: no generator polynomial statifies constraints" << std::endl;
    retval = octave_value(Matrix(0,0));
  } else {
    if (polyrep) {
      Matrix polys(cyclic_polys.length(),m+1, 0);
      for (int i = 0 ; i < cyclic_polys.length(); i++)
	for (int j = 0; j < m+1; j++)
	  if ((unsigned long long)cyclic_polys(i) & (1<<j))
	    polys(i,j) = 1;
      retval = octave_value (polys);
    } else
      retval = octave_value (cyclic_polys);
  }

  return retval;
}

/*
;;; Local Variables: ***
;;; mode: C++ ***
;;; End: ***
*/

--- NEW FILE: galois-ops.h ---
/*

Copyright (C) 2003 David Bateman

This program 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, or (at your option) any
later version.

This program 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 this program; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

In addition to the terms of the GPL, you are permitted to link
this program with any Open Source program, as defined by the
Open Source Initiative (www.opensource.org)

*/

#if !defined (galois_octave_ops_h)
#define galois_octave_ops_h 1

// Override the operator and function definition defines from Octave

#define DEFBINOP_OP_G(name, t1, t2, op) \
  BINOPDECL (name, a1, a2) \
  { \
    CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \
    return new octave_galois \
      (v1.t1 ## _value () op v2.t2 ## _value ()); \
  }

#define DEFBINOP_FN_G(name, t1, t2, f) \
  BINOPDECL (name, a1, a2) \
  { \
    CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \
    return new octave_galois (f (v1.t1 ## _value (), v2.t2 ## _value ())); \
  }

#define DEFBINOP_OP_B_S1(name, t1, t2, op) \
  BINOPDECL (name, a1, a2) \
  { \
    CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \
    return octave_value \
      (v1.matrix_value () op v2.t2 ##_value ()); \
  }

#define DEFBINOP_FN_B_S1(name, t1, t2, f) \
  BINOPDECL (name, a1, a2) \
  { \
    CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \
    return octave_value (f (v1.matrix_value (), v2.t2 ## _value ())); \
  }

#define DEFBINOP_OP_G_S1(name, t1, t2, op) \
  BINOPDECL (name, a1, a2) \
  { \
    CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \
    return new octave_galois \
      (v1.matrix_value () op v2.t2 ## _value ()); \
  }

#define DEFBINOP_FN_G_S1(name, t1, t2, f) \
  BINOPDECL (name, a1, a2) \
  { \
    CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \
    return new octave_galois (f (v1.matrix_value (), v2.t2 ## _value ())); \
  }

#define DEFBINOP_OP_B_S2(name, t1, t2, op) \
  BINOPDECL (name, a1, a2) \
  { \
    CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \
    return octave_value \
      (v1.t1 ## _value () op v2.matrix_value ()); \
  }

#define DEFBINOP_FN_B_S2(name, t1, t2, f) \
  BINOPDECL (name, a1, a2) \
  { \
    CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \
    return octave_value (f (v1.t1 ## _value (), v2.matrix_value ())); \
  }

#define DEFBINOP_OP_G_S2(name, t1, t2, op) \
  BINOPDECL (name, a1, a2) \
  { \
    CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \
    return new octave_galois \
      (v1.t1 ## _value () op v2.matrix_value ()); \
  }

#define DEFBINOP_FN_G_S2(name, t1, t2, f) \
  BINOPDECL (name, a1, a2) \
  { \
    CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \
    return new octave_galois (f (v1.t1 ## _value (), v2.matrix_value ())); \
  }

#ifdef HAVE_OCTAVE_CONCAT
#define DEFCATOP_G_FN(name, t1, t2, f) \
  CATOPDECL (name, a1, a2)	     \
  { \
    CAST_BINOP_ARGS (octave_ ## t1&, const octave_ ## t2&); \
    return new octave_galois (f (v1.t1 ## _value (), v2.t2 ## _value (), ra_idx)); \
  }

#define DEFCATOP_G_METHOD(name, t1, t2, f) \
  CATOPDECL (name, a1, a2)	     \
  { \
    CAST_BINOP_ARGS (octave_ ## t1&, const octave_ ## t2&); \
    return new octave_galois (v1.t1 ## _value (). f (v2.t2 ## _value (), ra_idx)); \
  }

#define INSTALL_G_CATOP(t1, t2, f) INSTALL_CATOP(t1, t2, f) 

#elif defined(HAVE_OLD_OCTAVE_CONCAT)

#define DEFCATOP_G_FN(name, t1, t2, f) \
  CATOPDECL (name, a1, a2)	     \
  { \
    CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \
    return new octave_galois (f (v1.t1 ## _value (), v2.t2 ## _value (), ra_idx)); \
  }

#define DEFCATOP_G_METHOD(name, t1, t2, f) \
  CATOPDECL (name, a1, a2)	     \
  { \
    CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \
    return new octave_galois (f (v1.t1 ## _value (), v2.t2 ## _value (), ra_idx)); \
  }

#define INSTALL_G_CATOP(t1, t2, f) INSTALL_CATOP(t1, t2, f) 
#else
#define DEFCATOP_G_FN(name, t1, t2, f) 
#define DEFCATOP_G_METHOD(name, t1, t2, f)
#define INSTALL_G_CATOP(t1, t2, f)
#endif

#endif

/*
;;; Local Variables: ***
;;; mode: C++ ***
;;; End: ***
*/

--- NEW FILE: syndtable.cc ---
/*

Copyright (C) 2003 David Bateman

This program 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, or (at your option)
any later version.

This program 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 Octave; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.

In addition to the terms of the GPL, you are permitted to link
this program with any Open Source program, as defined by the
Open Source Initiative (www.opensource.org)

*/

#include <iostream>
#include <iomanip>
#include <sstream>
#include <octave/oct.h>
#include <octave/pager.h>

#ifdef NEED_OCTAVE_QUIT
#define OCTAVE_QUIT do {} while (0)
#else
#include <octave/quit.h>
#endif

#define COL_MAJ(N) (N / (SIZEOF_INT << 3))
#define COL_MIN(N) (N % (SIZEOF_INT << 3))

Array2<int> get_errs (const int& nmin, const int& nmax, const int &nerrs)
{
  Array2<int> pos;
  int cols = COL_MAJ(nmax)+1;

  OCTAVE_QUIT;
  if (nerrs == 1) {
    pos.resize(nmax-nmin,cols,0);
    for (int i = nmin; i < nmax; i++) {
      pos(i-nmin,COL_MAJ(i)) = (1<<COL_MIN(i));
    } 
  } else {
    for (int i = nmin; i < nmax - nerrs + 1; i++) {
      Array2<int> new_pos = get_errs(i+1, nmax, nerrs-1);
      int l = pos.rows();
      pos.resize(l+new_pos.rows(),cols,0);
      for (int j=0; j<new_pos.rows(); j++) {
	for (int k=0; k<cols; k++)
	  pos(l+j,k) = new_pos(j,k);
	pos(l+j,COL_MAJ(i)) += (1<<COL_MIN(i));
      }
    }
  }
  return pos;
}

DEFUN_DLD (syndtable, args, nargout,
  "-*- texinfo -*-\n"
"@deftypefn {Loadable Function} {@var{t} =} syndtable (@var{h})\n"
"\n"
"Create the syndrome decoding table from the parity check matrix @var{h}.\n"
"Each row of the returned matrix @var{t} represents the error vector in\n"
"a recieved symbol for a certain syndrome. The row selected is determined\n"
"by a conversion of the syndrome to an integer representation, and using\n"
"this to reference each row of @var{t}.\n"
"@end deftypefn\n"
"@seealso{hammgen,cyclgen}")
{
  octave_value retval;
  int nargin = args.length();

  if (nargin != 1) {
    error ("syndtable: incorrect number of arguments");
    return retval;
  }

  if (!args(0).is_real_matrix()) {
    error ("syndtable: parity check matrix must be a real matrix");
    return retval;
  }

  Matrix h = args(0).matrix_value();
  int m = h.rows();
  int n = h.columns();
  unsigned int nrows = ((unsigned int)1 << m);

  // Could convert this to unsigned long long, but there isn't much point.
  // the syndrome table can already have 2^32 rows with n columns, which
  // is already unrealistically large. The result is DON'T use this with
  // large BCH codes!!!!
  if (m > (int)(sizeof(int) << 3)) {
    error("syndtable: codeword minus message length must be less than %d", 
	  (sizeof(int) << 3));
    return retval;
  }

  // Check that the data in h is valid in GF(2)
  for (int i = 0; i < m; i++)
    for (int j = 0; j < n; j++)
      if (((h(i,j) != 0) && (h(i,j) != 1)) || 
	  ((h(i,j) - (double)((int)h(i,j))) != 0)) {
	error ("syndtable: parity check matrix contains invalid data");
	return retval;
      }

  RowVector filled(nrows,0);
  Matrix table(nrows,n,0);
  unsigned int nfilled = nrows;
  int nerrs = 1;

  // The first row of the table is for no errors
  nfilled--;
  filled(0) = 1;

  while (nfilled != 0) {
    // Get all possible combinations of nerrs bit errors in n bits
    Array2<int> errpos = get_errs(0, n, nerrs);

    // Calculate the syndrome with the error vectors just calculated
    for (int j = 0;  j < errpos.rows(); j++) {
      int syndrome = 0;
      for (int i = 0; i < m; i++) {
	for (int k = 0;  k < n; k++)
	  syndrome ^= (errpos(j,COL_MAJ(k)) & 
		       ((unsigned int)h(i,k) << COL_MIN(k)) ? 
		       ((unsigned int)1<<(m-i-1)) : 0);
      }

      // Now use the syndrome as the rows indices to put the error vectors
      // in place
      if (((unsigned int)syndrome < nrows) && !filled(syndrome)) {
	filled(syndrome) = 1;
	nfilled--;
	for (int i = 0; i < n; i++) 
	  table(syndrome,i) = ((errpos(j,COL_MAJ(i)) & 
				((unsigned int)1 << COL_MIN(i))) != 0);
      }
    }

    nerrs++;
  }

  retval = octave_value(table);
  return retval;
}

--- NEW FILE: op-fil-gm.cc ---
/*

Copyright (C) 2003 David Bateman

This program 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, or (at your option) any
later version.

This program 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 this program; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

In addition to the terms of the GPL, you are permitted to link
this program with any Open Source program, as defined by the
Open Source Initiative (www.opensource.org)

*/

#ifndef HAVE_OCTAVE_29

#if defined (__GNUG__) && defined (USE_PRAGMA_INTERFACE_IMPLEMENTATION)
#pragma implementation
#endif

#include <iostream>
#include "galois.h"
#include "ov-galois.h"
#include <octave/ov-file.h>

// file by galois ops.

DEFBINOP (lshift, file, galois)
{
  CAST_BINOP_ARGS (const octave_file&, const octave_galois&);

  octave_stream oct_stream = v1.stream_value ();

  if (oct_stream)
    {
      std::ostream *osp = oct_stream.output_stream ();

      if (osp)
	{
	  std::ostream& os = *osp;

	  v2.print_raw (os);
	}
      else
	error ("invalid file specified for binary operator `<<'");
    }

  return octave_value (oct_stream, v1.stream_number ());
}

void
install_fil_gm_ops (void)
{
  INSTALL_BINOP (op_lshift, octave_file, octave_galois, lshift);
}

#else

void
install_fil_gm_ops (void)
{
}

#endif

/*
;;; Local Variables: ***
;;; mode: C++ ***
;;; End: ***
*/

--- NEW FILE: isprimitive.cc ---
/*

Copyright (C) 2003 David Bateman

This program 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, or (at your option)
any later version.

This program 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 Octave; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.

In addition to the terms of the GPL, you are permitted to link
this program with any Open Source program, as defined by the
Open Source Initiative (www.opensource.org)

*/

#include <iostream>
#include <iomanip>
#include <sstream>
#include <octave/oct.h>

static bool
do_isprimitive (const int& a, const int& m)
{
  // Fast return since primitive polynomial can't be even
  if (!(a & 1))
    return false;

  RowVector repr(1<<m,0);
  int mask = 1;
  int n = (1<<m) - 1;

  repr(0) = 1;
  for (int i=0; i<n; i++) {
    repr(mask) = 1;
    mask <<= 1;
    if (mask & (1<<m))
      mask ^= a;
  }

  if (mask != 1)
    return false;

  for (int i=0; i<n+1; i++)
    if (!repr(i))
      return false;

  return true;
}

DEFUN_DLD (isprimitive, args, nargout,
  "-*- texinfo -*-\n"
"@deftypefn {Loadable Function} {@var{y} =} isprimitive (@var{a})\n"
"\n"
"Returns 1 is the polynomial represented by @var{a} is a primitive\n"
"polynomial of GF(2). Otherwise it returns zero.\n"
"\n"
"@end deftypefn\n"
"@seealso{gf,primpoly}")
{
  octave_value retval;
  int nargin = args.length ();
  Matrix a = args(0).matrix_value();

  if ( nargin != 1 ) {
    error ("isprimitive: wrong number of arguments");
    return retval;
  }

  // If only 0/1 in a, assume that each row is a polynomial representation

  bool poly = true;
  for (int i=0; i<a.rows(); i++) {
    for (int j=0; j<a.columns(); j++) {
      if (((int)a(i,j) != 0) && ((int)a(i,j) != 1)) {
	poly = false;
	break;
      }
    }
    if (!poly) break;
  }

  if (poly) {
    if (a.columns() > 24) {
      error("isprimitive: order of the primitive polynomial must be less than 22");
      return retval;
    }

    Matrix b(a.rows(),1);

    for (int i=0; i<a.rows(); i++) {
      int tmp = (int)a(i,0);
      for (int j=1; j<a.columns(); j++)
	tmp = (tmp << 1) | (int)a(i,j);

      int m = 1;
      while (tmp > (1<<(m+1)))
	m++;

      b(i,0) = do_isprimitive(tmp, m);
    }
    retval = octave_value (b);
  } else {
    for (int i=0; i<a.rows(); i++)
      for (int j=0; j<a.columns(); j++)
	if (a(i,j) > (1<<23)) {
	  error("isprimitive: order of the primitive polynomial must be less than 22");
	  return retval;
	}

    Matrix b(a.rows(),a.columns());

    for (int i=0; i<a.rows(); i++) {
      for (int j=0; j<a.columns(); j++) {
	int m = 1;
	while (a(i,j) > (1<<(m+1)))
	  m++;

	b(i,j) = do_isprimitive((int)a(i,j), m);
      }
    }
    retval = octave_value (b);
  }

  return retval;
}

/*
;;; Local Variables: ***
;;; mode: C++ ***
;;; End: ***
*/

--- NEW FILE: Makeconf.base ---

## Makeconf is automatically generated from Makeconf.base and Makeconf.add
## in the various subdirectories.  To regenerate, use ./autogen.sh to
## create a new ./Makeconf.in, then use ./configure to generate a new
## Makeconf.

OCTAVE_FORGE = 1

SHELL = @SHELL@

canonical_host_type = @canonical_host_type@
prefix = @prefix@
exec_prefix = @exec_prefix@
bindir = @bindir@
mandir = @mandir@
libdir = @libdir@
datadir = @datadir@
infodir = @infodir@
includedir = @includedir@
INSTALL = @INSTALL@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_DATA = @INSTALL_DATA@
INSTALLOCT=octinst.sh

DESTDIR =

RANLIB = @RANLIB@
STRIP = @STRIP@
LN_S = @LN_S@
MKOCTLINK = @MKOCTLINK@
OCTLINK= @OCTLINK@

AWK = @AWK@

# Most octave programs will be compiled with $(MKOCTFILE).  Those which
# cannot use mkoctfile directly can request the flags that mkoctfile 
# would use as follows:
#    FLAG = $(shell $(MKOCTFILE) -p FLAG)
# The following flags are for compiling programs that are independent
# of Octave.  How confusing.
CC = @CC@
CFLAGS = @CFLAGS@
CPPFLAGS = @CPPFLAGS@
CPICFLAG = @CPICFLAG@
CXX = @CXX@
CXXFLAGS = @CXXFLAGS@
CXXPICFLAG = @CXXPICFLAG@
F77 = @F77@
FFLAGS = @FFLAGS@
FPICFLAG = @FPICFLAG@

OCTAVE = @OCTAVE@
OCTAVE_VERSION = @OCTAVE_VERSION@
MKOCTFILE = @MKOCTFILE@ -DHAVE_OCTAVE_$(ver) -v
SHLEXT = @SHLEXT@

@DEFHAVE_X@
X_CFLAGS = @X_CFLAGS@
X_LIBS = @X_LIBS@

ver = @ver@
MPATH = @mpath@
OPATH = @opath@
XPATH = @xpath@
ALTMPATH = @altmpath@
ALTOPATH = @altopath@

HAVE_DO_FORTRAN_INDEXING = @HAVE_DO_FORTRAN_INDEXING@
HAVE_PROPAGATE_EMPTY_MATRICES = @HAVE_PROPAGATE_EMPTY_MATRICES@
HAVE_OK_TO_LOSE_IMAGINARY_PART = @HAVE_OK_TO_LOSE_IMAGINARY_PART@
HAVE_ND_ARRAYS = @HAVE_ND_ARRAYS@
TYPEID_HAS_CLASS = @TYPEID_HAS_CLASS@
CLASS_HAS_LOAD_SAVE = @CLASS_HAS_LOAD_SAVE@
HAVE_OCTAVE_MAP_INDEX = @HAVE_OCTAVE_MAP_INDEX@
HAVE_OCTAVE_CONCAT = @HAVE_OCTAVE_CONCAT@
HAVE_SWAP_BYTES = @HAVE_SWAP_BYTES@
HAVE_OCTAVE_UPLUS = @HAVE_OCTAVE_UPLUS@

MAKEINFO = @MAKEINFO@
TEXI2DVI = @TEXI2DVI@
TEXI2HTML = @TEXI2HTML@
DVIPDF = @DVIPDF@
DVIPS = @DVIPS@

MKDOC = @MKDOC@
MKTEXI = @MKTEXI@

%.o: %.c ; $(MKOCTFILE) -c $<
%.o: %.f ; $(MKOCTFILE) -c $<
%.o: %.cc ; $(MKOCTFILE) -c $<
%.oct: %.cc ; $(MKOCTFILE) $<

--- NEW FILE: op-gm-m.cc ---
/*

Copyright (C) 2003 David Bateman

This program 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, or (at your option) any
later version.

This program 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 this program; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

In addition to the terms of the GPL, you are permitted to link
this program with any Open Source program, as defined by the
Open Source Initiative (www.opensource.org)

*/

#if defined (__GNUG__) && defined (USE_PRAGMA_INTERFACE_IMPLEMENTATION)
#pragma implementation
#endif

#include <iostream>
#include "galois.h"
#include "ov-galois.h"
#include "galois-ops.h"

// galois by matrix ops.

DEFBINOP_OP_G (add, galois, matrix, +)
DEFBINOP_OP_G (sub, galois, matrix, -)

DEFBINOP_OP_G (mul, galois, matrix, *)
DEFBINOP_FN_G (div, galois, matrix, xdiv)

DEFBINOPX (pow, galois, matrix)
{
  error ("for A^x, A must be square and x scalar");
  return octave_value ();
}

DEFBINOP_FN_G (ldiv, galois, matrix, xleftdiv)

DEFBINOP_FN (lt, galois, matrix, mx_el_lt)
DEFBINOP_FN (le, galois, matrix, mx_el_le)
DEFBINOP_FN (eq, galois, matrix, mx_el_eq)
DEFBINOP_FN (ge, galois, matrix, mx_el_ge)
DEFBINOP_FN (gt, galois, matrix, mx_el_gt)
DEFBINOP_FN (ne, galois, matrix, mx_el_ne)

DEFBINOP_FN_G (el_mul, galois, matrix, product)
DEFBINOP_FN_G (el_div, galois, matrix, quotient)
DEFBINOP_FN_G (el_pow, galois, matrix, elem_pow)

DEFBINOP (el_ldiv, galois, matrix)
{
  CAST_BINOP_ARGS (const octave_galois&, const octave_matrix&);

  return new octave_galois (quotient (v2.matrix_value (), v1.galois_value ()));
}

DEFBINOP_FN (el_and, galois, matrix, mx_el_and)
DEFBINOP_FN (el_or, galois, matrix, mx_el_or)

DEFCATOP_G_METHOD (gm_m, galois, matrix, concat)

// Need to create temporary Galois array so that matrix values are checked
DEFASSIGNOP (assign, galois, matrix) 
{
    CAST_BINOP_AR...

[truncated message content]

[Octave-cvsupdate] octave-forge/main/comm/src Makeconf.base, NONE, 1.1 Makeconf.in, NONE, 1.1 Makef

A collection of packages providing extra functionality for GNU Octave