deleted file mode 100644
--- a/src/Array-oc.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-
-Copyright (C) 1996, 1997 John W. Eaton
-
-This file is part of Octave.
-
-Octave 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.
-
-Octave 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.
-
-*/
-
-// Instantiate Arrays of octave_child objects.
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "Array.h"
-#include "Array.cc"
-
-#include "sighandlers.h"
-
-template class Array<octave_child>;
-
-/*
-;;; Local Variables: ***
-;;; mode: C++ ***
-;;; End: ***
-*/

deleted file mode 100644
--- a/src/Array-os.cc
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
-
-Copyright (C) 1996, 1997 John W. Eaton
-
-This file is part of Octave.
-
-Octave 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.
-
-Octave 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.
-
-*/
-
-// Instantiate Arrays of octave_stream objects.
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "Array.h"
-#include "Array.cc"
-
-#include "oct-stream.h"
-
-template class Array<scanf_format_elt*>;
-
-template class Array<printf_format_elt*>;
-
-template class Array<octave_stream*>;
-
-/*
-;;; Local Variables: ***
-;;; mode: C++ ***
-;;; End: ***
-*/

deleted file mode 100644
--- a/src/Array-tc.cc
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-
-Copyright (C) 1996, 1997 John W. Eaton
-
-This file is part of Octave.
-
-Octave 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.
-
-Octave 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.
-
-*/
-
-// Instantiate Arrays of octave_values.
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "Array.h"
-#include "Array.cc"
-
-#include "ov.h"
-
-extern template class Array<int>;
-extern template class Array2<int>;
-extern template class DiagArray2<int>;
-
-extern template class Array<double>;
-extern template class Array2<double>;
-extern template class DiagArray2<double>;
-
-extern template class Array<Complex>;
-extern template class Array2<Complex>;
-extern template class DiagArray2<Complex>;
-
-template class Array<octave_value>;
-
-/*
-;;; Local Variables: ***
-;;; mode: C++ ***
-;;; End: ***
-*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/balance.cc
@@ -0,0 +1,286 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+// Written by A. S. Hodel <scotte@eng.auburn.edu>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+
+#include "CmplxAEPBAL.h"
+#include "CmplxAEPBAL.h"
+#include "dbleAEPBAL.h"
+#include "dbleAEPBAL.h"
+#include "dbleGEPBAL.h"
+
+#include "defun-dld.h"
+#include "error.h"
+#include "gripes.h"
+#include "help.h"
+#include "oct-obj.h"
+#include "utils.h"
+
+DEFUN_DLD (balance, args, nargout,
+  "AA = balance (A [, OPT]) or [[DD,] AA] =  balance (A [, OPT])\n\
+\n\
+generalized eigenvalue problem:\n\
+\n\
+  [cc, dd, aa, bb] = balance (a, b [, opt])\n\
+\n\
+where OPT is an optional single character argument as follows: \n\
+\n\
+  N: no balancing; arguments copied, transformation(s) set to identity\n\
+  P: permute argument(s) to isolate eigenvalues where possible\n\
+  S: scale to improve accuracy of computed eigenvalues\n\
+  B: (default) permute and scale, in that order.  Rows/columns\n\
+     of a (and b) that are isolated by permutation are not scaled\n\
+\n\
+[DD, AA] = balance (A, OPT) returns aa = dd*a*dd,\n\
+\n\
+[CC, DD, AA, BB] = balance (A, B, OPT) returns AA (BB) = CC*A*DD (CC*B*DD)")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin < 1 || nargin > 3 || nargout < 0 || nargout > 4)
+    {
+      print_usage ("balance");
+      return retval;
+    }
+
+  string bal_job;
+  int my_nargin;		// # args w/o optional string arg
+
+  // Determine if balancing option is listed.  Set my_nargin to the
+  // number of matrix inputs.
+
+  if (args(nargin-1).is_string ())
+    {
+      bal_job = args(nargin-1).string_value ();
+      my_nargin = nargin-1;
+    }
+  else
+    {
+      bal_job = "B";
+      my_nargin = nargin;
+    }
+
+  octave_value arg_a = args(0);
+
+  int a_nr = arg_a.rows ();
+  int a_nc = arg_a.columns ();
+
+  // Check argument 1 dimensions.
+
+  int arg_is_empty = empty_arg ("balance", a_nr, a_nc);
+
+  if (arg_is_empty < 0)
+    return retval;
+  if (arg_is_empty > 0)
+    return octave_value_list (2, Matrix ());
+
+  if (a_nr != a_nc)
+    {
+      gripe_square_matrix_required ("balance");
+      return retval;
+    }
+
+  // Extract argument 1 parameter for both AEP and GEP.
+
+  Matrix aa;
+  ComplexMatrix caa;
+  if (arg_a.is_complex_type ())
+    caa = arg_a.complex_matrix_value ();
+  else
+    aa = arg_a.matrix_value ();
+
+  if (error_state)
+    return retval;
+
+  // Treat AEP/GEP cases.
+
+  switch (my_nargin)
+    {
+    case 1:
+      
+      // Algebraic eigenvalue problem.
+
+      if (arg_a.is_complex_type ())
+	{
+	  ComplexAEPBALANCE result (caa, bal_job);
+
+	  if (nargout == 0 || nargout == 1)
+	    retval(0) = result.balanced_matrix ();
+	  else
+	    {
+	      retval(1) = result.balanced_matrix ();
+	      retval(0) = result.balancing_matrix ();
+	    }
+	}
+      else
+	{
+	  AEPBALANCE result (aa, bal_job);
+
+	  if (nargout == 0 || nargout == 1)
+	    retval(0) = result.balanced_matrix ();
+	  else
+	    {
+	      retval(1) = result.balanced_matrix ();
+	      retval(0) = result.balancing_matrix ();
+	    }
+	}
+      break;
+
+    case 2:
+      {
+	// Generalized eigenvalue problem.
+
+	// 1st we have to check argument 2 dimensions and type...
+
+	octave_value arg_b = args(1);
+
+	int b_nr = arg_b.rows ();
+	int b_nc = arg_b.columns ();
+      
+	// Check argument 2 dimensions -- must match arg 1.
+
+	if (b_nr != b_nc || b_nr != a_nr)
+	  {
+	    gripe_nonconformant ();
+	    return retval;
+	  }
+      
+	// Now, extract the second matrix...
+	// Extract argument 1 parameter for both AEP and GEP.
+
+	Matrix bb;
+	ComplexMatrix cbb;
+	if (arg_b.is_complex_type ())
+	  cbb = arg_b.complex_matrix_value ();
+	else
+	  bb = arg_b.matrix_value ();
+
+	if (error_state)
+	  return retval;
+
+	// Both matrices loaded, now let's check what kind of arithmetic:
+
+	if (arg_a.is_complex_type () || arg_b.is_complex_type ())
+	  {
+	    if (arg_a.is_real_type ())
+	      caa = aa;
+
+	    if (arg_b.is_real_type ())
+	      cbb = bb;
+
+	    // Compute magnitudes of elements for balancing purposes.
+	    // Surely there's a function I can call someplace!
+
+	    for (int i = 0; i < a_nr; i++)
+	      for (int j = 0; j < a_nc; j++)
+		{
+		  aa (i, j) = abs (caa (i, j));
+		  bb (i, j) = abs (cbb (i, j));
+		}
+	  }
+
+	GEPBALANCE result (aa, bb, bal_job);
+
+	if (arg_a.is_complex_type () || arg_b.is_complex_type ())
+	  {
+	    caa = result.left_balancing_matrix () * caa
+	      * result.right_balancing_matrix ();
+
+	    cbb = result.left_balancing_matrix () * cbb
+	      * result.right_balancing_matrix ();
+
+	    switch (nargout)
+	      {
+	      case 0:
+	      case 1:
+		warning ("balance: should use two output arguments");
+		retval(0) = caa;
+		break;
+
+	      case 2:
+		retval(1) = cbb;
+		retval(0) = caa;
+		break;
+
+	      case 4:
+		retval(3) = cbb;
+		retval(2) = caa;
+		retval(1) = result.right_balancing_matrix ();
+		retval(0) = result.left_balancing_matrix ();
+		break;
+
+	      default:
+		error ("balance: invalid number of output arguments");
+		break;
+	      }
+	  }
+	else
+	  {
+	    switch (nargout)
+	      {
+	      case 0:
+	      case 1:
+		warning ("balance: should use two output arguments");
+		retval(0) = result.balanced_a_matrix ();
+		break;
+
+	      case 2:
+		retval(1) = result.balanced_b_matrix ();
+		retval(0) = result.balanced_a_matrix ();
+		break;
+
+	      case 4:
+		retval(3) = result.balanced_b_matrix ();
+		retval(2) = result.balanced_a_matrix ();
+		retval(1) = result.right_balancing_matrix ();
+		retval(0) = result.left_balancing_matrix ();
+		break;
+
+	      default:
+		error ("balance: invalid number of output arguments");
+		break;
+	      }
+	  }
+      }
+      break;
+
+    default:
+      error ("balance requires one (AEP) or two (GEP) numeric arguments");
+      break;
+    }
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/chol.cc
@@ -0,0 +1,103 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "CmplxCHOL.h"
+#include "dbleCHOL.h"
+
+#include "defun-dld.h"
+#include "error.h"
+#include "gripes.h"
+#include "help.h"
+#include "oct-obj.h"
+#include "utils.h"
+
+DEFUN_DLD (chol, args, nargout,
+  "R = chol (X): cholesky factorization")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin != 1 || nargout > 1)
+    {
+      print_usage ("chol");
+      return retval;
+    }
+
+  octave_value arg = args(0);
+    
+  int nr = arg.rows ();
+  int nc = arg.columns ();
+
+  int arg_is_empty = empty_arg ("chol", nr, nc);
+
+  if (arg_is_empty < 0)
+    return retval;
+  if (arg_is_empty > 0)
+    return Matrix ();
+
+  if (arg.is_real_type ())
+    {
+      Matrix m = arg.matrix_value ();
+
+      if (! error_state)
+	{
+	  int info;
+	  CHOL fact (m, info);
+	  if (info != 0)
+	    error ("chol: matrix not positive definite");
+	  else
+	    retval = fact.chol_matrix ();
+	}
+    }
+  else if (arg.is_complex_type ())
+    {
+      ComplexMatrix m = arg.complex_matrix_value ();
+
+      if (! error_state)
+	{
+	  int info;
+	  ComplexCHOL fact (m, info);
+	  if (info != 0)
+	    error ("chol: matrix not positive definite");
+	  else
+	    retval = fact.chol_matrix ();
+	}
+    }
+  else
+    {
+      gripe_wrong_type_arg ("chol", arg);
+    }
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/
+

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/colloc.cc
@@ -0,0 +1,141 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+
+#include "CollocWt.h"
+#include "lo-mappers.h"
+
+#include "defun-dld.h"
+#include "error.h"
+#include "help.h"
+#include "oct-obj.h"
+#include "utils.h"
+
+DEFUN_DLD (colloc, args, ,
+  "[R, A, B, Q] = colloc (N [, \"left\"] [, \"right\"]): collocation weights")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin < 1 || nargin > 3)
+    {
+      print_usage ("colloc");
+      return retval;
+    }
+
+  if (! args(0).is_scalar_type ())
+    {
+      error ("colloc: first argument must be a scalar");
+      return retval;
+    }
+
+  double tmp = args(0).double_value ();
+
+  if (error_state)
+    return retval;
+
+  if (xisnan (tmp))
+    {
+      error ("colloc: NaN is invalid as NCOL");
+      return retval;
+    }
+
+  int ncol = NINT (tmp);
+  if (ncol < 0)
+    {
+      error ("colloc: first argument must be non-negative");
+      return retval;
+    }
+
+  int ntot = ncol;
+  int left = 0;
+  int right = 0;
+
+  for (int i = 1; i < nargin; i++)
+    {
+      if (args(i).is_defined ())
+	{
+	  if (! args(i).is_string ())
+	    {
+	      error ("colloc: expecting string argument");
+	      return retval;
+	    }
+
+	  string s = args(i).string_value ();
+
+	  if ((s.length () == 1 && (s[0] == 'R' || s[0] == 'r'))
+	      || s == "right")
+	    {
+	      right = 1;
+	    }
+	  else if ((s.length () == 1 && (s[0] == 'L' || s[0] == 'l'))
+		   || s == "left")
+	    {
+	      left = 1;
+	    }
+	  else
+	    {
+	      error ("colloc: unrecognized argument");
+	      return retval;
+	    }
+	}
+      else
+	{
+	  error ("colloc: unexpected empty argument");
+	  return retval;
+	}
+    }
+
+  ntot += left + right;
+  if (ntot < 1)
+    {
+      error ("colloc: the total number of roots must be positive");
+      return retval;
+    }
+  
+  CollocWt wts (ncol, left, right);
+
+  ColumnVector r = wts.roots ();
+  Matrix A = wts.first ();
+  Matrix B = wts.second ();
+  ColumnVector q = wts.quad_weights ();
+
+  retval(3) = q;
+  retval(2) = B;
+  retval(1) = A;
+  retval(0) = r;
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/
+

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/dassl.cc
@@ -0,0 +1,377 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+
+#include <iostream.h>
+
+#include "DASSL.h"
+
+#include "defun-dld.h"
+#include "error.h"
+#include "gripes.h"
+#include "help.h"
+#include "oct-obj.h"
+#include "oct-sym.h"
+#include "pager.h"
+#include "utils.h"
+#include "variables.h"
+
+// Global pointer for user defined function required by dassl.
+static octave_symbol *dassl_fcn;
+
+static DASSL_options dassl_opts;
+
+ColumnVector
+dassl_user_function (const ColumnVector& x, const ColumnVector& xdot, double t)
+{
+  ColumnVector retval;
+
+  int nstates = x.capacity ();
+
+  assert (nstates == xdot.capacity ());
+
+  octave_value_list args;
+  args(2) = t;
+
+  if (nstates > 1)
+    {
+      Matrix m1 (nstates, 1);
+      Matrix m2 (nstates, 1);
+      for (int i = 0; i < nstates; i++)
+	{
+	  m1 (i, 0) = x (i);
+	  m2 (i, 0) = xdot (i);
+	}
+      octave_value state (m1);
+      octave_value deriv (m2);
+      args(1) = deriv;
+      args(0) = state;
+    }
+  else
+    {
+      double d1 = x (0);
+      double d2 = xdot (0);
+      octave_value state (d1);
+      octave_value deriv (d2);
+      args(1) = deriv;
+      args(0) = state;
+    }
+
+  if (dassl_fcn)
+    {
+      octave_value_list tmp = dassl_fcn->eval (1, args);
+
+      if (error_state)
+	{
+	  gripe_user_supplied_eval ("dassl");
+	  return retval;
+	}
+
+      if (tmp.length () > 0 && tmp(0).is_defined ())
+	{
+	  retval = tmp(0).vector_value ();
+
+	  if (error_state || retval.length () == 0)
+	    gripe_user_supplied_eval ("dassl");
+	}
+      else
+	gripe_user_supplied_eval ("dassl");
+    }
+
+  return retval;
+}
+
+DEFUN_DLD (dassl, args, ,
+  "dassl (\"function_name\", x_0, xdot_0, t_out)\n\
+dassl (F, X_0, XDOT_0, T_OUT, T_CRIT)\n\
+\n\
+The first argument is the name of the function to call to\n\
+compute the vector of residuals.  It must have the form\n\
+\n\
+  res = f (x, xdot, t)\n\
+\n\
+where x, xdot, and res are vectors, and t is a scalar.")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin < 4 || nargin > 5)
+    {
+      print_usage ("dassl");
+      return retval;
+    }
+
+  dassl_fcn = extract_function
+    (args(0), "dassl", "__dassl_fcn__",
+     "function res = __dassl_fcn__ (x, xdot, t) res = ",
+     "; endfunction");
+
+  if (! dassl_fcn)
+    return retval;
+
+  ColumnVector state = args(1).vector_value ();
+
+  if (error_state)
+    {
+      error ("dassl: expecting state vector as second argument");
+      return retval;
+    }
+
+  ColumnVector deriv = args(2).vector_value ();
+
+  if (error_state)
+    {
+      error ("dassl: expecting derivative vector as third argument");
+      return retval;
+    }
+
+  ColumnVector out_times = args(3).vector_value ();
+
+  if (error_state)
+    {
+      error ("dassl: expecting output time vector as fourth argument");
+      return retval;
+    }
+
+  ColumnVector crit_times;
+  int crit_times_set = 0;
+  if (nargin > 4)
+    {
+      crit_times = args(4).vector_value ();
+
+      if (error_state)
+	{
+	  error ("dassl: expecting critical time vector as fifth argument");
+	  return retval;
+	}
+
+      crit_times_set = 1;
+    }
+
+  if (state.capacity () != deriv.capacity ())
+    {
+      error ("dassl: x and xdot must have the same size");
+      return retval;
+    }
+
+  double tzero = out_times (0);
+
+  DAEFunc func (dassl_user_function);
+  DASSL dae (state, deriv, tzero, func);
+  dae.copy (dassl_opts);
+
+  Matrix output;
+  Matrix deriv_output;
+
+  if (crit_times_set)
+    output = dae.integrate (out_times, deriv_output, crit_times);
+  else
+    output = dae.integrate (out_times, deriv_output);
+
+  if (! error_state)
+    {
+      retval.resize (2);
+
+      retval(0) = output;
+      retval(1) = deriv_output;
+    }
+
+  return retval;
+}
+
+typedef void (DASSL_options::*d_set_opt_mf) (double);
+typedef double (DASSL_options::*d_get_opt_mf) (void);
+
+#define MAX_TOKENS 3
+
+struct DASSL_OPTIONS
+{
+  const char *keyword;
+  const char *kw_tok[MAX_TOKENS + 1];
+  int min_len[MAX_TOKENS + 1];
+  int min_toks_to_match;
+  d_set_opt_mf d_set_fcn;
+  d_get_opt_mf d_get_fcn;
+};
+
+static DASSL_OPTIONS dassl_option_table [] =
+{
+  { "absolute tolerance",
+    { "absolute", "tolerance", 0, 0, },
+    { 1, 0, 0, 0, }, 1,
+    DASSL_options::set_absolute_tolerance,
+    DASSL_options::absolute_tolerance, },
+
+  { "initial step size",
+    { "initial", "step", "size", 0, },
+    { 1, 0, 0, 0, }, 1,
+    DASSL_options::set_initial_step_size,
+    DASSL_options::initial_step_size, },
+
+  { "maximum step size",
+    { "maximum", "step", "size", 0, },
+    { 2, 0, 0, 0, }, 1,
+    DASSL_options::set_maximum_step_size,
+    DASSL_options::maximum_step_size, },
+
+  { "relative tolerance",
+    { "relative", "tolerance", 0, 0, },
+    { 1, 0, 0, 0, }, 1,
+    DASSL_options::set_relative_tolerance,
+    DASSL_options::relative_tolerance, },
+
+  { 0,
+    { 0, 0, 0, 0, },
+    { 0, 0, 0, 0, }, 0,
+    0, 0, },
+};
+
+static void
+print_dassl_option_list (ostream& os)
+{
+  print_usage ("dassl_options", 1);
+
+  os << "\n"
+     << "Options for dassl include:\n\n"
+     << "  keyword                                  value\n"
+     << "  -------                                  -----\n\n";
+
+  DASSL_OPTIONS *list = dassl_option_table;
+
+  const char *keyword;
+  while ((keyword = list->keyword) != 0)
+    {
+      os.form ("  %-40s ", keyword);
+
+      double val = (dassl_opts.*list->d_get_fcn) ();
+      if (val < 0.0)
+	os << "computed automatically";
+      else
+	os << val;
+
+      os << "\n";
+      list++;
+    }
+
+  os << "\n";
+}
+
+static void
+set_dassl_option (const string& keyword, double val)
+{
+  DASSL_OPTIONS *list = dassl_option_table;
+
+  while (list->keyword != 0)
+    {
+      if (keyword_almost_match (list->kw_tok, list->min_len, keyword,
+				list->min_toks_to_match, MAX_TOKENS))
+	{
+	  (dassl_opts.*list->d_set_fcn) (val);
+
+	  return;
+	}
+      list++;
+    }
+
+  warning ("dassl_options: no match for `%s'", keyword.c_str ());
+}
+
+static octave_value_list
+show_dassl_option (const string& keyword)
+{
+  octave_value retval;
+
+  DASSL_OPTIONS *list = dassl_option_table;
+
+  while (list->keyword != 0)
+    {
+      if (keyword_almost_match (list->kw_tok, list->min_len, keyword,
+				list->min_toks_to_match, MAX_TOKENS))
+	{
+	  double val = (dassl_opts.*list->d_get_fcn) ();
+	  if (val < 0.0)
+	    retval = "computed automatically";
+	  else
+	    retval = val;
+
+	  return retval;
+	}
+      list++;
+    }
+
+  warning ("dassl_options: no match for `%s'", keyword.c_str ());
+
+  return retval;
+}
+
+DEFUN_DLD (dassl_options, args, ,
+  "dassl_options (KEYWORD, VALUE)\n\
+\n\
+Set or show options for dassl.  Keywords may be abbreviated\n\
+to the shortest match.")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin == 0)
+    {
+      print_dassl_option_list (octave_stdout);
+      return retval;
+    }
+  else if (nargin == 1 || nargin == 2)
+    {
+      string keyword = args(0).string_value ();
+
+      if (! error_state)
+	{
+	  if (nargin == 1)
+	    return show_dassl_option (keyword);
+	  else
+	    {
+	      double val = args(1).double_value ();
+
+	      if (! error_state)
+		{
+		  set_dassl_option (keyword, val);
+		  return retval;
+		}
+	    }
+	}
+    }
+
+  print_usage ("dassl_options");
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/det.cc
@@ -0,0 +1,129 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "CmplxDET.h"
+#include "dbleDET.h"
+
+#include "defun-dld.h"
+#include "error.h"
+#include "gripes.h"
+#include "help.h"
+#include "oct-obj.h"
+#include "utils.h"
+
+DEFUN_DLD (det, args, ,
+  "det (X): determinant of a square matrix")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin != 1)
+    {
+      print_usage ("det");
+      return retval;
+    }
+
+  octave_value arg = args(0);
+    
+  int nr = arg.rows ();
+  int nc = arg.columns ();
+
+  if (nr == 0 && nc == 0)
+    {
+      retval = 1.0;
+      return retval;
+    }
+
+  int arg_is_empty = empty_arg ("det", nr, nc);
+  if (arg_is_empty < 0)
+    return retval;
+  if (arg_is_empty > 0)
+    return Matrix (1, 1, 1.0);
+
+  if (nr != nc)
+    {
+      gripe_square_matrix_required ("det");
+      return retval;
+    }
+
+  if (arg.is_real_type ())
+    {
+      Matrix m = arg.matrix_value ();
+
+      if (! error_state)
+	{
+	  int info;
+	  double rcond = 0.0;
+
+	  DET det = m.determinant (info, rcond);
+
+	  double d = 0.0;
+
+	  if (info == -1)
+	    warning ("det: matrix singular to machine precision, rcond = %g",
+		     rcond);
+	  else
+	    d = det.value ();
+
+	  retval = d;
+	}
+    }
+  else if (arg.is_complex_type ())
+    {
+      ComplexMatrix m = arg.complex_matrix_value ();
+
+      if (! error_state)
+	{
+	  int info;
+	  double rcond = 0.0;
+
+	  ComplexDET det = m.determinant (info, rcond);
+
+	  Complex c = 0.0;
+
+	  if (info == -1)
+	    warning ("det: matrix singular to machine precision, rcond = %g",
+		     rcond);
+	  else
+	    c = det.value ();
+
+	  retval = c;
+	}
+    }
+  else
+    {
+      gripe_wrong_type_arg ("det", arg);
+    }
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/eig.cc
@@ -0,0 +1,115 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "EIG.h"
+
+#include "defun-dld.h"
+#include "error.h"
+#include "gripes.h"
+#include "help.h"
+#include "oct-obj.h"
+#include "utils.h"
+
+DEFUN_DLD (eig, args, nargout,
+  "eig (X) or [V, D] = eig (X): compute eigenvalues and eigenvectors of X")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin != 1 || nargout > 2)
+    {
+      print_usage ("eig");
+      return retval;
+    }
+
+  octave_value arg = args(0);
+
+  int nr = arg.rows ();
+  int nc = arg.columns ();
+
+  int arg_is_empty = empty_arg ("eig", nr, nc);
+  if (arg_is_empty < 0)
+    return retval;
+  else if (arg_is_empty > 0)
+    return octave_value_list (2, Matrix ());
+
+  if (nr != nc)
+    {
+      gripe_square_matrix_required ("eig");
+      return retval;
+    }
+
+  Matrix tmp;
+  ComplexMatrix ctmp;
+  EIG result;
+
+  if (arg.is_real_type ())
+    {
+      tmp = arg.matrix_value ();
+
+      if (error_state)
+	return retval;
+      else
+	result = EIG (tmp);
+    }
+  else if (arg.is_complex_type ())
+    {
+      ctmp = arg.complex_matrix_value ();
+
+      if (error_state)
+	return retval;
+      else
+	result = EIG (ctmp);
+    }
+  else
+    {
+      gripe_wrong_type_arg ("eig", tmp);
+      return retval;
+    }
+
+  if (nargout == 0 || nargout == 1)
+    {
+      retval(0) = result.eigenvalues (), 1;
+    }
+  else
+    {
+      // Blame it on Matlab.
+
+      ComplexDiagMatrix d (result.eigenvalues ());
+
+      retval(1) = d;
+      retval(0) = result.eigenvectors ();
+    }
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/expm.cc
@@ -0,0 +1,97 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+// Written by A. S. Hodel <scotte@eng.auburn.edu>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "defun-dld.h"
+#include "error.h"
+#include "gripes.h"
+#include "help.h"
+#include "oct-obj.h"
+#include "utils.h"
+
+DEFUN_DLD (expm, args, ,
+  "expm (X): matrix exponential, e^A")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin != 1)
+    {
+      print_usage ("expm");
+      return retval;
+    }
+
+  octave_value arg = args(0);
+
+  int nr = arg.rows ();
+  int nc = arg.columns ();
+
+  int arg_is_empty = empty_arg ("expm", nr, nc);
+
+  if (arg_is_empty < 0)
+    return retval;
+  if (arg_is_empty > 0)
+    return Matrix ();
+
+  if (nr != nc)
+    {
+      gripe_square_matrix_required ("expm");
+      return retval;
+    }
+
+  if (arg.is_real_type ())
+    {
+      Matrix m = arg.matrix_value ();
+
+      if (error_state)
+	return retval;
+      else
+	retval = m.expm ();
+    }
+  else if (arg.is_complex_type ())
+    {
+      ComplexMatrix m = arg.complex_matrix_value ();
+
+      if (error_state)
+	return retval;
+      else
+	retval = m.expm ();
+    }
+  else
+    {
+      gripe_wrong_type_arg ("expm", arg);
+    }
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/fft.cc
@@ -0,0 +1,120 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "lo-mappers.h"
+
+#include "defun-dld.h"
+#include "error.h"
+#include "gripes.h"
+#include "help.h"
+#include "oct-obj.h"
+#include "utils.h"
+
+// This function should be merged with Fifft.
+
+DEFUN_DLD (fft, args, ,
+  "fft (X [, N]): fast fourier transform of a vector")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin < 1 || nargin > 2)
+    {
+      print_usage ("fft");
+      return retval;
+    }
+
+  octave_value arg = args(0);
+
+  int n_points = arg.rows ();
+  if (n_points == 1)
+    n_points = arg.columns ();
+
+  if (nargin == 2)
+    {
+      double dval = args(1).double_value ();
+      if (xisnan (dval))
+	error ("fft: NaN is invalid as the N_POINTS");
+      else
+	n_points = NINT (dval);
+    }
+
+  if (error_state)
+    return retval;
+
+  if (n_points < 0)
+    {
+      error ("fft: number of points must be greater than zero");
+      return retval;
+    }
+
+  int arg_is_empty = empty_arg ("fft", arg.rows (), arg.columns ());
+
+  if (arg_is_empty < 0)
+    return retval;
+  else if (arg_is_empty || n_points == 0)
+    return Matrix ();
+
+  if (arg.is_real_type ())
+    {
+      Matrix m = arg.matrix_value ();
+
+      if (! error_state)
+	{
+	  if (m.rows () == 1)
+	    m.resize (1, n_points, 0.0);
+	  else
+	    m.resize (n_points, m.columns (), 0.0);
+	  retval = m.fourier ();
+	}
+    }
+  else if (arg.is_complex_type ())
+    {
+      ComplexMatrix m = arg.complex_matrix_value ();
+
+      if (! error_state)
+	{
+	  if (m.rows () == 1)
+	    m.resize (1, n_points, 0.0);
+	  else
+	    m.resize (n_points, m.columns (), 0.0);
+	  retval = m.fourier ();
+	}
+    }
+  else
+    {
+      gripe_wrong_type_arg ("fft", arg);
+    }
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/fft2.cc
@@ -0,0 +1,126 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "lo-mappers.h"
+
+#include "defun-dld.h"
+#include "error.h"
+#include "gripes.h"
+#include "help.h"
+#include "oct-obj.h"
+#include "utils.h"
+
+// This function should be merged with Fifft2.
+
+DEFUN_DLD (fft2, args, ,
+  "fft2 (X [, N] [, M])\n\
+\n\
+two dimensional fast fourier transform of a vector")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin < 1 || nargin > 3)
+    {
+      print_usage ("fft2");
+      return retval;
+    }
+
+  octave_value arg = args(0);
+
+  int n_rows = arg.rows ();
+  if (nargin > 1)
+    {
+      double dval = args(1).double_value ();
+      if (xisnan (dval))
+	error ("fft2: NaN is invalid as N_ROWS");
+      else
+	n_rows = NINT (dval);
+    }
+
+  if (error_state)
+    return retval;
+
+  int n_cols = arg.columns ();
+  if (nargin > 2)
+    {
+      double dval = args(2).double_value ();
+      if (xisnan (dval))
+	error ("fft2: NaN is invalid as N_COLS");
+      else
+	n_cols = NINT (dval);
+    }
+
+  if (error_state)
+    return retval;
+
+  if (n_rows < 0 || n_cols < 0)
+    {
+      error ("fft2: number of points must be greater than zero");
+      return retval;
+    }
+
+  int arg_is_empty = empty_arg ("fft2", arg.rows (), arg.columns ());
+
+  if (arg_is_empty < 0)
+    return retval;
+  else if (arg_is_empty || n_rows == 0 || n_cols == 0)
+    return Matrix ();
+
+  if (arg.is_real_type ())
+    {
+      Matrix m = arg.matrix_value ();
+
+      if (! error_state)
+	{
+	  m.resize (n_rows, n_cols, 0.0);
+	  retval = m.fourier2d ();
+	}
+    }
+  else if (arg.is_complex_type ())
+    {
+      ComplexMatrix m = arg.complex_matrix_value ();
+
+      if (! error_state)
+	{
+	  m.resize (n_rows, n_cols, 0.0);
+	  retval = m.fourier2d ();
+	}
+    }
+  else
+    {
+      gripe_wrong_type_arg ("fft2", arg);
+    }
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/filter.cc
@@ -0,0 +1,295 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+// Based on Tony Richardson's filter.m.
+//
+// Originally translated to C++ by KH (Kurt.Hornik@ci.tuwien.ac.at)
+// with help from Fritz Leisch and Andreas Weingessel on Oct 20, 1994.
+//
+// Rewritten to use templates to handle both real and complex cases by
+// jwe, Wed Nov  1 19:15:29 1995.
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "defun-dld.h"
+#include "error.h"
+#include "oct-obj.h"
+#include "help.h"
+
+extern MArray<double>
+filter (MArray<double>&, MArray<double>&, MArray<double>&);
+
+extern MArray<Complex>
+filter (MArray<Complex>&, MArray<Complex>&, MArray<Complex>&);
+
+template <class T>
+MArray<T>
+filter (MArray<T>& b, MArray<T>& a, MArray<T>& x, MArray<T>& si)
+{
+  MArray<T> y;
+
+  int a_len  = a.length ();
+  int b_len  = b.length ();
+  int x_len  = x.length ();
+
+  int si_len = si.length ();
+
+  int ab_len = a_len > b_len ? a_len : b_len;
+
+  b.resize (ab_len, 0.0);
+
+  if (si.length () != ab_len - 1)
+    {
+      error ("filter: si must be a vector of length max (length (a), length (b)) - 1");
+      return y;
+    }
+
+  T norm = a (0);
+
+  if (norm == 0.0)
+    {
+      error ("filter: the first element of a must be non-zero");
+      return y;
+    }
+
+  y.resize (x_len, 0.0);
+
+  if (norm != 1.0)
+    b = b / norm;
+
+  if (a_len > 1)
+    {
+      a.resize (ab_len, 0.0);
+
+      if (norm != 1.0)
+	a = a / norm;
+
+      for (int i = 0; i < x_len; i++)
+	{
+	  y (i) = si (0) + b (0) * x (i);
+
+	  if (si_len > 1)
+	    {
+	      for (int j = 0; j < si_len - 1; j++)
+		si (j) = si (j+1) - a (j+1) * y (i)
+		  + b (j+1) * x (i);
+
+	      si (si_len-1) = b (si_len) * x (i)
+		- a (si_len) * y (i);
+	    }
+	  else
+	    si (0) = b (si_len) * x (i)
+	      - a (si_len) * y (i);
+	}
+    }
+  else if (si_len > 0)
+    {
+      for (int i = 0; i < x_len; i++)
+	{
+	  y (i) = si (0) + b (0) * x (i);
+
+	  if (si_len > 1)
+	    {
+	      for (int j = 0; j < si_len - 1; j++)
+		si (j) = si (j+1) + b (j+1) * x (i);
+
+	      si (si_len-1) = b (si_len) * x (i);
+	    }
+	  else
+	    si (0) = b (1) * x (i);
+	}
+    }
+  else
+    y = b (0) * x;
+
+  return y;
+}
+
+extern MArray<double>
+filter (MArray<double>&, MArray<double>&, MArray<double>&,
+	MArray<double>&);
+
+extern MArray<Complex>
+filter (MArray<Complex>&, MArray<Complex>&, MArray<Complex>&,
+	MArray<Complex>&);
+
+template <class T>
+MArray<T>
+filter (MArray<T>& b, MArray<T>& a, MArray<T>& x)
+{
+  int a_len = a.length ();
+  int b_len = b.length ();
+
+  int si_len = (a_len > b_len ? a_len : b_len) - 1;
+
+  MArray<T> si (si_len, T (0.0));
+
+  return filter (b, a, x, si);
+}
+
+DEFUN_DLD (filter, args, ,
+  "usage: [y [, sf]] = filter (b, a, x [, si])\n\
+\n\
+y = filter (b, a, x) returns the solution to the following linear,\n\
+time-invariant difference equation:\n\
+\n\
+  a[1] y[n] + ... + a[la] y[n-la+1] = b[1] x[n] + ... + b[lb] x[n-lb+1],\n\
+where la = length (a) and lb = length (b).\n\
+\n\
+[y, sf] = filter (b, a, x, si) sets the initial state of the system, si,\n\
+and returns the final state, sf.  The state vector is a column vector\n\
+whose length is equal to the length of the longest coefficient vector\n\
+minus one.  If si is not set, the initial state vector is set to all\n\
+zeros.\n\
+\n\
+The particular algorithm employed is known as a transposed Direct Form II\n\
+implementation.")
+{
+  octave_value_list retval;
+
+  int nargin  = args.length ();
+
+  if (nargin < 3 || nargin > 4)
+    {
+      print_usage ("filter");
+      return retval;
+    }
+
+  const char *errmsg = "filter: arguments must be vectors";
+
+  int x_is_vector = (args(2).rows () == 1 || args(2).columns () == 1);
+
+  int si_is_vector = (nargin == 4
+		      && (args(3).rows () == 1 || args(3).columns () == 1));
+
+  if (args(0).is_complex_type ()
+      || args(1).is_complex_type ()
+      || args(2).is_complex_type ()
+      || (nargin == 4 && args(3).is_complex_type ()))
+    {
+      ComplexColumnVector b = args(0).complex_vector_value ();
+      ComplexColumnVector a = args(1).complex_vector_value ();
+      ComplexColumnVector x = args(2).complex_vector_value ();
+
+      if (! error_state)
+	{
+	  if (nargin == 3)
+	    {
+	      ComplexColumnVector y (filter (b, a, x));
+
+	      if (x_is_vector)
+		retval (0) = octave_value (y, (args(2).columns () == 1));
+	      else
+		retval (0) = y;
+	    }
+	  else
+	    {
+	      ComplexColumnVector si = args(3).complex_vector_value ();
+
+	      if (! error_state)
+		{
+		  ComplexColumnVector y (filter (b, a, x, si));
+
+		  if (si_is_vector)
+		    retval (1) = octave_value (si, (args(3).columns () == 1));
+		  else
+		    retval (1) = si;
+
+		  if (x_is_vector)
+		    retval (0) = octave_value (y, (args(2).columns () == 1));
+		  else
+		    retval (0) = y;
+		}
+	      else
+		error (errmsg);
+	    }
+	}
+      else
+	error (errmsg);
+    }
+  else
+    {
+      ColumnVector b = args(0).vector_value ();
+      ColumnVector a = args(1).vector_value ();
+      ColumnVector x = args(2).vector_value ();
+
+      if (! error_state)
+	{
+	  if (nargin == 3)
+	    {
+	      ColumnVector y (filter (b, a, x));
+
+	      if (x_is_vector)
+		retval (0) = octave_value (y, (args(2).columns () == 1));
+	      else
+		retval (0) = y;
+	    }
+	  else
+	    {
+	      ColumnVector si = args(3).vector_value ();
+
+	      if (! error_state)
+		{
+		  ColumnVector y (filter (b, a, x, si));
+
+		  if (si_is_vector)
+		    retval (1) = octave_value (si, (args(3).columns () == 1));
+		  else
+		    retval (1) = si;
+
+		  if (x_is_vector)
+		    retval (0) = octave_value (y, (args(2).columns () == 1));
+		  else
+		    retval (0) = y;
+		}
+	      else
+		error (errmsg);
+	    }
+	}
+      else
+	error (errmsg);
+    }
+
+  return retval;
+}
+
+template MArray<double>
+filter (MArray<double>&, MArray<double>&, MArray<double>&,
+	MArray<double>&);
+
+template MArray<double>
+filter (MArray<double>&, MArray<double>&, MArray<double>&);
+
+template MArray<Complex>
+filter (MArray<Complex>&, MArray<Complex>&, MArray<Complex>&,
+	MArray<Complex>&);
+
+template MArray<Complex>
+filter (MArray<Complex>&, MArray<Complex>&, MArray <Complex>&);
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/  

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/find.cc
@@ -0,0 +1,201 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "defun-dld.h"
+#include "error.h"
+#include "gripes.h"
+#include "help.h"
+#include "oct-obj.h"
+
+static octave_value_list
+find_to_fortran_idx (const ColumnVector i_idx, const ColumnVector j_idx,
+		     const octave_value& val, int nr, int nargout)
+{
+  octave_value_list retval;
+
+  switch (nargout)
+    {
+    case 0:
+    case 1:
+      {
+	int count = i_idx.length ();
+	ColumnVector tmp (count);
+	for (int i = 0; i < count; i++)
+	  tmp (i) = nr * (j_idx (i) - 1.0) + i_idx (i);
+
+	// If the original argument was a row vector, force a row
+	// vector of indices to be returned.
+
+	retval(0) = octave_value (tmp, (nr != 1));
+      }
+      break;
+
+    case 3:
+      retval(2) = val;
+      // Fall through!
+
+    case 2:
+      retval(1) = octave_value (j_idx, 1);
+      retval(0) = octave_value (i_idx, 1);
+
+      // If you want this to work more like Matlab, use
+      //
+      //    retval(0) = octave_value (i_idx, (nr != 1));
+      //
+      // instead of the previous statement.
+
+      break;
+
+    default:
+      panic_impossible ();
+      break;
+    }
+
+  return retval;
+}
+
+static octave_value_list
+find_nonzero_elem_idx (const Matrix& m, int nargout)
+{
+  int count = 0;
+  int m_nr = m.rows ();
+  int m_nc = m.columns ();
+
+  int i, j;
+  for (j = 0; j < m_nc; j++)
+    for (i = 0; i < m_nr; i++)
+      if (m (i, j) != 0.0)
+	count++;
+
+  octave_value_list retval (((nargout == 0) ? 1 : nargout), Matrix ());
+
+  if (count == 0)
+    return retval;
+
+  ColumnVector i_idx (count);
+  ColumnVector j_idx (count);
+  ColumnVector v (count);
+
+  count = 0;
+  for (j = 0; j < m_nc; j++)
+    for (i = 0; i < m_nr; i++)
+      {
+	double d = m (i, j);
+	if (d != 0.0)
+	  {
+	    i_idx (count) = i + 1;
+	    j_idx (count) = j + 1;
+	    v (count) = d;
+	    count++;
+	  }
+      }
+
+  octave_value tmp (v, 1);
+  return find_to_fortran_idx (i_idx, j_idx, tmp, m_nr, nargout);
+}
+
+static octave_value_list
+find_nonzero_elem_idx (const ComplexMatrix& m, int nargout)
+{
+  int count = 0;
+  int m_nr = m.rows ();
+  int m_nc = m.columns ();
+
+  int i, j;
+  for (j = 0; j < m_nc; j++)
+    for (i = 0; i < m_nr; i++)
+      if (m (i, j) != 0.0)
+	count++;
+
+  octave_value_list retval (((nargout == 0) ? 1 : nargout), Matrix ());
+
+  if (count == 0)
+    return retval;
+
+  ColumnVector i_idx (count);
+  ColumnVector j_idx (count);
+  ComplexColumnVector v (count);
+
+  count = 0;
+  for (j = 0; j < m_nc; j++)
+    for (i = 0; i < m_nr; i++)
+      {
+	Complex c = m (i, j);
+	if (c != 0.0)
+	  {
+	    i_idx (count) = i + 1;
+	    j_idx (count) = j + 1;
+	    v (count) = c;
+	    count++;
+	  }
+      }
+
+  octave_value tmp (v, 1);
+  return find_to_fortran_idx (i_idx, j_idx, tmp, m_nr, nargout);
+}
+
+DEFUN_DLD (find, args, nargout,
+  "find (X) or [I, J, V] = find (X): Return indices of nonzero elements")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin != 1 || nargout > 3)
+    {
+      print_usage ("find");
+      return retval;
+    }
+
+  octave_value arg = args(0);
+
+  if (arg.is_real_type ())
+    {
+      Matrix m = arg.matrix_value ();
+
+      if (! error_state)
+	retval = find_nonzero_elem_idx (m, nargout);
+    }
+  else if (arg.is_complex_type ())
+    {
+      ComplexMatrix m = arg.complex_matrix_value ();
+
+      if (! error_state)
+	retval = find_nonzero_elem_idx (m, nargout);
+    }
+  else
+    {
+      gripe_wrong_type_arg ("find", arg);
+    }
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/fsolve.cc
@@ -0,0 +1,336 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+
+#include <iostream.h>
+
+#include "NLEqn.h"
+
+#include "defun-dld.h"
+#include "error.h"
+#include "gripes.h"
+#include "help.h"
+#include "oct-sym.h"
+#include "oct-obj.h"
+#include "pager.h"
+#include "utils.h"
+#include "variables.h"
+
+// Global pointer for user defined function required by hybrd1.
+static octave_symbol *fsolve_fcn;
+
+static NLEqn_options fsolve_opts;
+
+int
+hybrd_info_to_fsolve_info (int info)
+{
+  switch (info)
+    {
+    case -1:
+      info = -2;
+      break;
+
+    case 0:
+      info = -1;
+      break;
+
+    case 1:
+      break;
+
+    case 2:
+      info = 4;
+      break;
+
+    case 3:
+    case 4:
+    case 5:
+      info = 3;
+      break;
+
+    default:
+      panic_impossible ();
+      break;
+    }
+
+  return info;
+}
+
+ColumnVector
+fsolve_user_function (const ColumnVector& x)
+{
+  ColumnVector retval;
+
+  int n = x.capacity ();
+
+  octave_value_list args;
+  args.resize (1);
+
+  if (n > 1)
+    {
+      Matrix m (n, 1);
+      for (int i = 0; i < n; i++)
+	m (i, 0) = x (i);
+      octave_value vars (m);
+      args(0) = vars;
+    }
+  else
+    {
+      double d = x (0);
+      octave_value vars (d);
+      args(0) = vars;
+    }
+
+  if (fsolve_fcn)
+    {
+      octave_value_list tmp = fsolve_fcn->eval (1, args);
+      if (tmp.length () > 0 && tmp(0).is_defined ())
+	{
+	  retval = tmp(0).vector_value ();
+
+	  if (error_state || retval.length () <= 0)
+	    gripe_user_supplied_eval ("fsolve");
+	}
+      else
+	gripe_user_supplied_eval ("fsolve");
+    }
+
+  return retval;
+}
+
+DEFUN_DLD (fsolve, args, nargout,
+  "Solve nonlinear equations using Minpack.  Usage:\n\
+\n\
+  [X, INFO] = fsolve (F, X0)\n\
+\n\
+Where the first argument is the name of the  function to call to\n\
+compute the vector of function values.  It must have the form\n\
+\n\
+  y = f (x)\n\
+\n\
+where y and x are vectors.")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin != 2 || nargout > 3)
+    {
+      print_usage ("fsolve");
+      return retval;
+    }
+
+  fsolve_fcn = extract_function (args(0), "fsolve", "__fsolve_fcn__",
+				"function y = __fsolve_fcn__ (x) y = ",
+				"; endfunction");
+  if (! fsolve_fcn)
+    return retval;
+
+  ColumnVector x = args(1).vector_value ();
+
+  if (error_state)
+    {
+      error ("fsolve: expecting vector as second argument");
+      return retval;
+    }
+
+  if (nargin > 2)
+    warning ("fsolve: ignoring extra arguments");
+
+  if (nargout > 2)
+    warning ("fsolve: can't compute path output yet");
+
+  NLFunc foo_fcn (fsolve_user_function);
+  NLEqn foo (x, foo_fcn);
+  foo.set_options (fsolve_opts);
+
+  int info;
+  ColumnVector soln = foo.solve (info);
+
+  info = hybrd_info_to_fsolve_info (info);
+
+  retval.resize (nargout ? nargout : 1);
+  retval(0) = soln, 1;
+
+  if (nargout > 1)
+    retval(1) = static_cast<double> (info);
+
+  return retval;
+}
+
+typedef void (NLEqn_options::*d_set_opt_mf) (double);
+typedef double (NLEqn_options::*d_get_opt_mf) (void);
+
+#define MAX_TOKENS 1
+
+struct NLEQN_OPTIONS
+{
+  const char *keyword;
+  const char *kw_tok[MAX_TOKENS + 1];
+  int min_len[MAX_TOKENS + 1];
+  int min_toks_to_match;
+  d_set_opt_mf d_set_fcn;
+  d_get_opt_mf d_get_fcn;
+};
+
+static NLEQN_OPTIONS fsolve_option_table [] =
+{
+  { "tolerance",
+    { "tolerance", 0, },
+    { 1, 0, }, 1,
+    NLEqn_options::set_tolerance,
+    NLEqn_options::tolerance, },
+
+  { 0,
+    { 0, 0, },
+    { 0, 0, }, 0,
+    0, 0, },
+};
+
+static void
+print_fsolve_option_list (ostream& os)
+{
+  print_usage ("fsolve_options", 1);
+
+  os << "\n"
+     << "Options for fsolve include:\n\n"
+     << "  keyword                                  value\n"
+     << "  -------                                  -----\n\n";
+
+  NLEQN_OPTIONS *list = fsolve_option_table;
+
+  const char *keyword;
+  while ((keyword = list->keyword) != 0)
+    {
+      os.form ("  %-40s ", keyword);
+
+      double val = (fsolve_opts.*list->d_get_fcn) ();
+      if (val < 0.0)
+	os << "computed automatically";
+      else
+	os << val;
+
+      os << "\n";
+      list++;
+    }
+
+  os << "\n";
+}
+
+static void
+set_fsolve_option (const string& keyword, double val)
+{
+  NLEQN_OPTIONS *list = fsolve_option_table;
+
+  while (list->keyword != 0)
+    {
+      if (keyword_almost_match (list->kw_tok, list->min_len, keyword,
+				list->min_toks_to_match, MAX_TOKENS))
+	{
+	  (fsolve_opts.*list->d_set_fcn) (val);
+
+	  return;
+	}
+      list++;
+    }
+
+  warning ("fsolve_options: no match for `%s'", keyword.c_str ());
+}
+
+static octave_value_list
+show_fsolve_option (const string& keyword)
+{
+  octave_value retval;
+
+  NLEQN_OPTIONS *list = fsolve_option_table;
+
+  while (list->keyword != 0)
+    {
+      if (keyword_almost_match (list->kw_tok, list->min_len, keyword,
+				list->min_toks_to_match, MAX_TOKENS))
+	{
+	  double val = (fsolve_opts.*list->d_get_fcn) ();
+	  if (val < 0.0)
+	    retval = "computed automatically";
+	  else
+	    retval = val;
+
+	  return retval;
+	}
+      list++;
+    }
+
+  warning ("fsolve_options: no match for `%s'", keyword.c_str ());
+
+  return retval;
+}
+
+DEFUN_DLD (fsolve_options, args, ,
+  "fsolve_options (KEYWORD, VALUE)\n\
+\n\
+Set or show options for fsolve.  Keywords may be abbreviated\n\
+to the shortest match.")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin == 0)
+    {
+      print_fsolve_option_list (octave_stdout);
+      return retval;
+    }
+  else if (nargin == 1 || nargin == 2)
+    {
+      string keyword = args(0).string_value ();
+
+      if (! error_state)
+	{
+	  if (nargin == 1)
+	    return show_fsolve_option (keyword);
+	  else
+	    {
+	      double val = args(1).double_value ();
+
+	      if (! error_state)
+		{
+		  set_fsolve_option (keyword, val);
+		  return retval;
+		}
+	    }
+	}
+    }
+
+  print_usage ("fsolve_options");
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/fsqp.cc
@@ -0,0 +1,114 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "FSQP.h"
+
+#include "defun-dld.h"
+#include "error.h"
+#include "help.h"
+#include "oct-obj.h"
+
+#ifndef FSQP_MISSING
+
+// Global pointers for user defined functions required by fsqp.
+// static tree *fsqp_objective;
+// static tree *fsqp_constraints;
+
+double
+fsqp_objective_function (const ColumnVector&)
+{
+  return 0.0;
+}
+
+ColumnVector
+fsqp_constraint_function (const ColumnVector&)
+{
+  ColumnVector retval;
+  return retval;
+}
+
+#endif
+
+#if defined (FSQP_MISSING)
+DEFUN_DLD (fsqp, , ,
+  "This function requires FSQP, which is not freely\n\
+redistributable.  For more information, read the file\n\
+libcruft/fsqp/README.MISSING in the source distribution.")
+#else
+DEFUN_DLD (fsqp, , ,
+  "[X, PHI] = fsqp (X, PHI [, LB, UB] [, LB, A, UB] [, LB, G, UB])\n\
+\n\
+Groups of arguments surrounded in `[]' are optional, but\n\
+must appear in the same relative order shown above.")
+#endif
+{
+/*
+
+Handle all of the following:
+
+  1. fsqp (x, phi)
+  2. fsqp (x, phi, lb, ub)
+  3. fsqp (x, phi, lb, ub, llb, c, lub)
+  4. fsqp (x, phi, lb, ub, llb, c, lub, nllb, g, nlub)
+  5. fsqp (x, phi, lb, ub,              nllb, g, nlub)
+  6. fsqp (x, phi,         llb, c, lub, nllb, g, nlub)
+  7. fsqp (x, phi,         llb, c, lub)
+  8. fsqp (x, phi,                      nllb, g, nlub)
+
+*/
+
+  octave_value_list retval;
+
+  error ("fsqp: not implemented yet");
+
+  return retval;
+}
+
+#if defined (FSQP_MISSING)
+DEFUN_DLD (fsqp_options, , ,
+  "This function requires FSQP, which is not freely\n\
+redistributable.  For more information, read the file\n\
+libcruft/fsqp/README.MISSING in the source distribution.")
+#else
+DEFUN_DLD (fsqp_options, , ,
+  "fsqp_options (KEYWORD, VALUE)\n\
+\n\
+Set or show options for fsqp.  Keywords may be abbreviated\n\
+to the shortest match.")
+#endif
+{
+  octave_value_list retval;
+
+  error ("fsqp_options: not implemented yet");
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/getgrent.cc
@@ -0,0 +1,234 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#ifdef HAVE_GRP_H
+#include <grp.h>
+#endif
+
+#include "defun-dld.h"
+#include "error.h"
+#include "gripes.h"
+#include "help.h"
+#include "oct-map.h"
+#include "ov.h"
+#include "oct-obj.h"
+#include "utils.h"
+
+// Group file functions.  (Why not?)
+
+static octave_value
+mk_gr_map (struct group *gr)
+{
+  octave_value retval;
+
+  if (gr)
+    {
+      Octave_map m;
+
+      m ["name"] = gr->gr_name;
+#if defined (HAVE_GR_PASSWD)
+      m ["passwd"] = gr->gr_passwd;
+#else
+      m ["passwd"] = "";
+#endif
+      m ["gid"] = static_cast<double> (gr->gr_gid);
+
+      if (gr->gr_mem)
+	{
+	  // XXX FIXME XXX -- maybe there should be a string_vector
+	  // constructor that takes a NULL terminated list of C
+	  // strings.
+
+	  char **tmp = gr->gr_mem;
+
+	  int k = 0;
+	  while (*tmp++)
+	    k++;
+
+	  if (k > 0)
+	    {
+	      tmp = gr->gr_mem;
+
+	      string_vector members (k);
+
+	      for (int i = 0; i < k; i++)
+		members[i] = tmp[i];
+
+	      m ["mem"] = members;
+	    }
+	  else
+	    m ["mem"] = "";
+	}
+
+      retval = m;
+    }
+  else
+    retval = 0.0;
+
+  return retval;
+}
+
+DEFUN_DLD (getgrent, args, ,
+ "getgrent ()\n\
+\n\
+Read an entry from the group-file stream, opening it if necessary.")
+{
+  octave_value retval;
+
+  int nargin = args.length ();
+
+  if (nargin == 0)
+    {
+#ifdef HAVE_GETGRENT
+      retval = mk_gr_map (getgrent ());
+#else
+      gripe_not_supported ("getgrent");
+#endif
+    }
+  else
+    print_usage ("getgrent");
+
+  return retval;
+}
+
+DEFUN_DLD (getgrgid, args, ,
+  "getgrgid (GID)\n\
+\n\
+Search for a group entry with a matching group ID.")
+{
+  octave_value retval;
+
+  int nargin = args.length ();
+
+  if (nargin == 1)
+    {
+#ifdef HAVE_GETGRGID
+      double dval = args(0).double_value ();
+
+      if (! error_state)
+	{
+	  if (D_NINT (dval) == dval)
+	    {
+	      gid_t gid = static_cast<gid_t> (dval);
+
+	      retval = mk_gr_map (getgrgid (gid));
+	    }
+	  else
+	    error ("getgrgid: argument must be an integer");
+	}
+#else
+      gripe_not_supported ("getgrgid");
+#endif
+    }
+  else
+    print_usage ("getgrgid");
+
+  return retval;
+}
+
+DEFUN_DLD (getgrnam, args, ,
+  "getgrnam (NAME)\n\
+\n\
+Search for group entry with a matching group name.")
+{
+  octave_value retval;
+
+  int nargin = args.length ();
+
+  if (nargin == 1)
+    {
+#ifdef HAVE_GETGRNAM
+      string s = args(0).string_value ();
+
+      if (! error_state)
+	retval = mk_gr_map (getgrnam (s.c_str ()));
+#else
+      gripe_not_supported ("getgrnam");
+#endif
+    }
+  else
+    print_usage ("getgrnam");
+
+  return retval;
+}
+
+DEFUN_DLD (setgrent, args, ,
+  "setgrent ()\n\
+\n\
+Rewind the group-file stream.")
+{
+  octave_value retval;
+
+  int nargin = args.length ();
+
+  if (nargin == 0)
+    {
+#ifdef HAVE_SETGRENT
+      setgrent ();
+#else
+      gripe_not_supported ("setgrent");
+#endif
+    }
+  else
+    print_usage ("setgrent");
+
+  return retval;
+}
+
+DEFUN_DLD (endgrent, args, ,
+  "endgrent ()\n\
+\n\
+Close the group-file stream.")
+{
+  octave_value retval;
+
+  int nargin = args.length ();
+
+  if (nargin == 0)
+    {
+#ifdef HAVE_ENDGRENT
+      endgrent ();
+#else
+      gripe_not_supported ("endgrent");
+#endif
+    }
+  else
+    print_usage ("endgrent");
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/getpwent.cc
@@ -0,0 +1,207 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#ifdef HAVE_PWD_H
+#include <pwd.h>
+#endif
+
+#include "defun-dld.h"
+#include "error.h"
+#include "gripes.h"
+#include "help.h"
+#include "oct-map.h"
+#include "ov.h"
+#include "oct-obj.h"
+#include "utils.h"
+
+// Password file functions.  (Why not?)
+
+static octave_value
+mk_pw_map (struct passwd *pw)
+{
+  octave_value retval;
+
+  if (pw)
+    {
+      Octave_map m;
+
+      m ["name"] = pw->pw_name;
+      m ["passwd"] = pw->pw_passwd;
+      m ["uid"] = static_cast<double> (pw->pw_uid);
+      m ["gid"] = static_cast<double> (pw->pw_gid);
+      m ["gecos"] = pw->pw_gecos;
+      m ["dir"] = pw->pw_dir;
+      m ["shell"] = pw->pw_shell;
+
+      retval = m;
+    }
+  else
+    retval = 0.0;
+
+  return retval;
+}
+
+DEFUN_DLD (getpwent, args, ,
+ "getpwent ()\n\
+\n\
+Read an entry from the password-file stream, opening it if necessary.")
+{
+  octave_value retval;
+
+  int nargin = args.length ();
+
+  if (nargin == 0)
+    {
+#ifdef HAVE_GETPWENT
+      retval = mk_pw_map (getpwent ());
+#else
+      gripe_not_supported ("getpwent");
+#endif
+    }
+  else
+    print_usage ("getpwent");
+
+  return retval;
+}
+
+DEFUN_DLD (getpwuid, args, ,
+  "getpwuid (UID)\n\
+\n\
+Search for a password entry with a matching user ID.")
+{
+  octave_value retval;
+
+  int nargin = args.length ();
+
+  if (nargin == 1)
+    {
+#ifdef HAVE_GETPWUID
+      double dval = args(0).double_value ();
+
+      if (! error_state)
+	{
+	  if (D_NINT (dval) == dval)
+	    {
+	      uid_t uid = static_cast<uid_t> (dval);
+
+	      retval = mk_pw_map (getpwuid (uid));
+	    }
+	  else
+	    error ("getpwuid: argument must be an integer");
+	}
+#else
+      gripe_not_supported ("getpwuid");
+#endif
+    }
+  else
+    print_usage ("getpwuid");
+
+  return retval;
+}
+
+DEFUN_DLD (getpwnam, args, ,
+  "getpwnam (NAME)\n\
+\n\
+Search for password entry with a matching username.")
+{
+  octave_value retval;
+
+  int nargin = args.length ();
+
+  if (nargin == 1)
+    {
+#ifdef HAVE_GETPWNAM
+      string s = args(0).string_value ();
+
+      if (! error_state)
+	retval = mk_pw_map (getpwnam (s.c_str ()));
+#else
+      gripe_not_supported ("getpwnam");
+#endif
+    }
+  else
+    print_usage ("getpwnam");
+
+  return retval;
+}
+
+DEFUN_DLD (setpwent, args, ,
+  "setpwent ()\n\
+\n\
+Rewind the password-file stream.")
+{
+  octave_value retval;
+
+  int nargin = args.length ();
+
+  if (nargin == 0)
+    {
+#ifdef HAVE_SETPWENT
+      setpwent ();
+#else
+      gripe_not_supported ("setpwent");
+#endif
+    }
+  else
+    print_usage ("setpwent");
+
+  return retval;
+}
+
+DEFUN_DLD (endpwent, args, ,
+  "endpwent ()\n\
+\n\
+Close the password-file stream.")
+{
+  octave_value retval;
+
+  int nargin = args.length ();
+
+  if (nargin == 0)
+    {
+#ifdef HAVE_ENDPWENT
+      endpwent ();
+#else
+      gripe_not_supported ("endpwent");
+#endif
+    }
+  else
+    print_usage ("endpwent");
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/getrusage.cc
@@ -0,0 +1,168 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "systime.h"
+
+#ifdef HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#endif
+
+#if defined (HAVE_TIMES) && defined (HAVE_SYS_TIMES_H)
+
+#if defined (HAVE_SYS_PARAM_H)
+#include <sys/param.h>
+#endif
+#include <sys/times.h>
+
+#if !defined (HZ)
+#if defined (CLK_TCK)
+#define HZ CLK_TCK
+#elif defined (USG)
+#define HZ 100
+#else
+#define HZ 60
+#endif
+#endif
+
+#endif
+
+#include "defun-dld.h"
+#include "help.h"
+#include "oct-map.h"
+#include "sysdep.h"
+#include "ov.h"
+#include "oct-obj.h"
+#include "utils.h"
+
+#ifndef RUSAGE_SELF
+#define RUSAGE_SELF 0
+#endif
+
+// System resource functions.
+
+DEFUN_DLD (getrusage, , ,
+  "getrusage ()\n\
+\n\
+Return system resource statistics.")
+{
+  Octave_map m;
+  Octave_map tv_tmp;
+
+#if defined (HAVE_GETRUSAGE)
+
+  struct rusage ru;
+
+  getrusage (RUSAGE_SELF, &ru);
+
+  tv_tmp ["sec"] = static_cast<double> (ru.ru_utime.tv_sec);
+  tv_tmp ["usec"] = static_cast<double> (ru.ru_utime.tv_usec);
+  m ["utime"] = octave_value (tv_tmp);
+
+  tv_tmp ["sec"] = static_cast<double> (ru.ru_stime.tv_sec);
+  tv_tmp ["usec"] = static_cast<double> (ru.ru_stime.tv_usec);
+  m ["stime"] = octave_value (tv_tmp);
+
+#if ! defined (RUSAGE_TIMES_ONLY)
+  m ["maxrss"] = static_cast<double> (ru.ru_maxrss);
+  m ["ixrss"] = static_cast<double> (ru.ru_ixrss);
+  m ["idrss"] = static_cast<double> (ru.ru_idrss);
+  m ["isrss"] = static_cast<double> (ru.ru_isrss);
+  m ["minflt"] = static_cast<double> (ru.ru_minflt);
+  m ["majflt"] = static_cast<double> (ru.ru_majflt);
+  m ["nswap"] = static_cast<double> (ru.ru_nswap);
+  m ["inblock"] = static_cast<double> (ru.ru_inblock);
+  m ["oublock"] = static_cast<double> (ru.ru_oublock);
+  m ["msgsnd"] = static_cast<double> (ru.ru_msgsnd);
+  m ["msgrcv"] = static_cast<double> (ru.ru_msgrcv);
+  m ["nsignals"] = static_cast<double> (ru.ru_nsignals);
+  m ["nvcsw"] = static_cast<double> (ru.ru_nvcsw);
+  m ["nivcsw"] = static_cast<double> (ru.ru_nivcsw);
+#endif
+
+#else
+#if defined (HAVE_TIMES) && defined (HAVE_SYS_TIMES_H)
+
+  struct tms t;
+
+  times (&t);
+
+  unsigned long ticks;
+  unsigned long seconds;
+  unsigned long fraction;
+
+  ticks = t.tms_utime + t.tms_cutime;
+  fraction = ticks % HZ;
+  seconds = ticks / HZ;
+
+  tv_tmp ["sec"] = static_cast<double> (seconds);
+  tv_tmp ["usec"] = static_cast<double> (fraction * 1e6 / HZ);
+  m ["utime"] = octave_value (tv_tmp);
+
+  ticks = t.tms_stime + t.tms_cstime;
+  fraction = ticks % HZ;
+  seconds = ticks / HZ;
+
+  tv_tmp ["sec"] = static_cast<double> (seconds);
+  tv_tmp ["usec"] = static_cast<double> (fraction * 1e6 / HZ);
+  m ["stime"] = octave_value (tv_tmp);
+
+#else
+
+  tv_tmp ["sec"] = 0.0;
+  tv_tmp ["usec"] = 0.0;
+  m ["utime"] = octave_value (tv_tmp);
+
+  tv_tmp ["sec"] = 0.0;
+  tv_tmp ["usec"] = 0.0;
+  m ["stime"] = octave_value (tv_tmp);
+
+#endif
+
+  m ["maxrss"] = octave_NaN;
+  m ["ixrss"] = octave_NaN;
+  m ["idrss"] = octave_NaN;
+  m ["isrss"] = octave_NaN;
+  m ["minflt"] = octave_NaN;
+  m ["majflt"] = octave_NaN;
+  m ["nswap"] = octave_NaN;
+  m ["inblock"] = octave_NaN;
+  m ["oublock"] = octave_NaN;
+  m ["msgsnd"] = octave_NaN;
+  m ["msgrcv"] = octave_NaN;
+  m ["nsignals"] = octave_NaN;
+  m ["nvcsw"] = octave_NaN;
+  m ["nivcsw"] = octave_NaN;
+
+#endif
+
+  return octave_value (m);
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/src/DLD-FUNCTIONS/givens.cc
@@ -0,0 +1,122 @@
+/*
+
+Copyright (C) 1996, 1997 John W. Eaton
+
+This file is part of Octave.
+
+Octave 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.
+
+Octave 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.
+
+*/
+
+// Originally written by A. S. Hodel <scotte@eng.auburn.edu>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "defun-dld.h"
+#include "error.h"
+#include "help.h"
+#include "oct-obj.h"
+
+DEFUN_DLD (givens, args, nargout,
+  "G = givens (X, Y)\n\
+\n\
+compute orthogonal matrix G = [c s; -conj (s) c]\n\
+such that G [x; y] = [*; 0]  (x, y scalars)\n\
+\n\
+[c, s] = givens (x, y) returns the (c, s) values themselves.")
+{
+  octave_value_list retval;
+
+  int nargin = args.length ();
+
+  if (nargin != 2 || nargout > 2)
+    {
+      print_usage ("givens");
+      return retval;
+    }
+  else
+    {
+      if (args(0).is_complex_type () || args(1).is_complex_type ())
+	{
+	  Complex cx = args(0).complex_value ();
+	  Complex cy = args(1).complex_value ();
+
+	  if (! error_state)
+	    {
+	      ComplexMatrix result = Givens (cx, cy);
+
+	      if (! error_state)
+		{
+		  switch (nargout)
+		    {
+		    case 0:
+		    case 1:
+		      retval(0) = result;
+		      break;
+   
+		    case 2:
+		      retval(1) = result (0, 1);
+		      retval(0) = result (0, 0);
+		      break;
+
+		    default:
+		      error ("givens: invalid number of output arguments");
+		      break;
+		    }
+		}
+	    }
+	}
+      else
+	{
+	  double x = args(0).double_value ();
+	  double y = args(1).double_value ();
+
+	  if (! error_state)
+	    {
+	      Matrix result = Givens (x, y);
+
+	      if (! error_state)
+		{
+		  switch (nargout)
+		    {
+		    case 0:
+		    case 1:
+		      retval(0) = result;
+		      break;
+   
+		    case 2:
+		      retval(1) = result (0, 1);
+		      retval(0) = result (0, 0);
+		      break;
+
+		    default:
+		      error ("givens: invalid number of output arguments");
+		      break;
+		    }
+		}
+	    }
+	}
+    }
+
+  return retval;
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/