Release calc version 2.12.4.2

BUGS

@@ -1,8 +1,8 @@
 If you notice something wrong, strange or broken, try rereading:
 
    README.FIRST
-   README
+   HOWTO.INSTALL
-   BUGS (in particular the bottom problems or mis-features section)
+   BUGS (this file)
 
 If that does not help, cd to the calc source directory and try:
 
@@ -10,41 +10,48 @@ If that does not help, cd to the calc source directory and try:
 
 Look at the end of the output, it should say something like:
 
-    9999: passed all tests  /\../\
+    9998: passed all tests  /\../\
+    9999: Ending regression tests
 
 If it does not, then something is really broken!
 
 If you made and modifications to calc beyond the simple Makefile
 configuration, try backing them out and see if things get better.
 
-Check to see if the version of calc you are using is current.  Calc
+To be sure that your version of calc is up to date, check out:
-distributions may be obtained from the official calc repository:
 
-    ftp://ftp.uu.net/pub/calc
+	http://www.isthe.com/chongo/tech/comp/calc/calc-download.html
 
-If you are an alpha or beta tester, you may have a special pre-released
+The calc web site is located at:
-version that is more advanced than what is in the ftp archive.
+
+	http://www.isthe.com/chongo/tech/comp/calc/index.html
 
 =-=
 
 If you have tried all of the above and things still are not right,
-then it may be time to send in a bug report.  You can send bug reports to:
+then it may be time to send in a bug report.  You can send bug
+and bug fixes reports to:
 
-    calc-tester@postofc.corp.sgi.com
+    calc-bugs at asthe dot com
+
+    [[ NOTE: Replace 'at' with @, 'dot' is with . and remove the spaces ]]
+    [[ NOTE: The EMail address uses 'asthe', the web site URL uses 'isthe' ]]
+
+Your subject must contain the words:
+
+       calc bug report
+
+You may have additional words in your subject line.
 
 When you send your report, please include the following information:
 
     * a description of the problem
-
     * the version of calc you are using (if you cannot get calc
-      it to run, then send us the 4 #define lines from version.c)
+      to run, then send us the 4 #define lines from version.c)
-
     * if you modified calc from an official patch, send me the mods you made
-
     * the type of system you were using
-
     * the type of compiler you were using
-
+    * any compiler warnings or errors that you saw
     * cd to the calc source directory, and type:
 
 	make debug > debug.out 2>&1		(sh, ksh, bash users)
@@ -54,42 +61,96 @@ When you send your report, please include the following information:
 
 Stack traces from core dumps are useful to send as well.
 
-=-=
+Fell free to use the above address to send in big fixes (in the form
-
+of a context diff patch).
-The official calc repository is located in:
-
-    ftp://ftp.uu.net/pub/calc
-
-If you don't have ftp access to that site, or if your version is more
-recent than what has been released to the ftp archive, you may, as a
-last resort, send EMail to:
-
-    chongo@toad.com
-
-Indicate the version you have and that you would like a more up to date version.
 
 =-=
 
-Send any comments, suggestions and most importantly, fixes (in the form
+Known bugs:
-of a context diff patch) to:
 
-    calc-tester@postofc.corp.sgi.com
+    We are sure some more bugs exist.  When you find them, please let
+    us know!  See the above for details on how to report and were to
+    EMail your bug reports and hopefully patches to fix them.
 
 =-=
 
-Known problems or mis-features:
+Problems that have known work-a-rounds:
 
-    * In calc2.10.2t3, when scan() reads characters from stdin, they
+    * There is a bug in gcc v4.1.0 that causes calc to fail the regression
-      are not echoed.  This also happens with fgets(files(0)) and
+      test.  The work-a-round is to compile with gcc v4.1.1 or later.  This
-      fgetline(files(0)).  Reports indicate that this did not happen in
+      problems was observed on Fedora 5.
-      calc.2.10.1t20 but did in 2.10.2t0.
 
-    * Many of LIBRARY, LIMITS and SEE ALSO sections of help files
+=-=
-      for builtins are either inconsistent or missing information.
 
-    * The functions filepos2z() and z2filepos() do not work (or
+mis-features in calc:
-      worse do not compile) when FILEPOS is 64 bits long.
 
-    * There is some places in the source with obscure variable names
+    Some problems are not bugs but rarther mis-features / things that could
-      and not much in the way of comments.  We need some major cleanup
+    work better.  The following is a list of mis-features that should be
-      and documentation.
+    addressed and improved someday.
+
+    * When statement is of the form { ... }, the leading { MUST BE ON
+      THE SAME LINE as the if, for, while or do keyword.
+
+      This works as expected:
+
+	if (expr) {
+	    ...
+	}
+
+      However this WILL NOT WORK AS EXPECTED:
+
+	if (expr)
+	{
+	    ...
+	}
+
+      This needs to be changed.  See also "help statement", "help unexpected",
+      and "help todo".
+
+    * The chi.cal resource file does not work well with odd degrees
+      of freedom.  Can someone improve this algorithm?
+
+    * The intfile.cal resource file reads and writes big or little Endian
+      integers to/from files the hard way.  It does NOT use blkcpy.  The
+      following code:
+
+	i = (ord("\n") << 16) | (ord("i") << 8) | ord("H")
+	b = blk()
+	copy(i, b)
+	fd = fopen("file", "w")
+	copy(b, fd);
+	fclose(fd)
+
+      will write an extra NUL octet to the file.  Where as:
+
+	read intfile
+	i = (ord("\n") << 16) | (ord("i") << 8) | ord("H")
+	be2file(i, "file2")
+
+      will not.
+
+## Copyright (C) 1999-2007  Landon Curt Noll
+##
+## Calc is open software; you can redistribute it and/or modify it under
+## the terms of the version 2.1 of the GNU Lesser General Public License
+## as published by the Free Software Foundation.
+##
+## Calc 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 Lesser General
+## Public License for more details.
+##
+## A copy of version 2.1 of the GNU Lesser General Public License is
+## distributed with calc under the filename COPYING-LGPL.  You should have
+## received a copy with calc; if not, write to Free Software Foundation, Inc.
+## 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+##
+## @(#) $Revision: 30.1 $
+## @(#) $Id: BUGS,v 30.1 2007/03/16 11:09:46 chongo Exp $
+## @(#) $Source: /usr/local/src/cmd/calc/RCS/BUGS,v $
+##
+## Under source code control:	1994/03/18 14:06:13
+## File existed as early as:	1994
+##
+## chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+## Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/

COPYING

@@ -0,0 +1,225 @@
+		calc - arbitrary precision calculator
+
+
+This file is Copyrighted
+------------------------
+
+    This file is covered under the following Copyright:
+
+	Copyright (C) 1999-2008  Landon Curt Noll
+	All rights reserved.
+
+	Everyone is permitted to copy and distribute verbatim copies
+	of this license document, but changing it is not allowed.
+
+    # @(#) $Revision: 30.2 $
+    # @(#) $Id: COPYING,v 30.2 2008/10/24 10:46:52 chongo Exp $
+    # @(#) $Source: /usr/local/src/cmd/calc/RCS/COPYING,v $
+
+=-=
+
+Calc is covered by the GNU Lesser General Public License
+--------------------------------------------------------
+
+    Calc is open software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation version 2.1 of the License.
+
+    Calc is several binary link libraries, several modules, associated
+    interface definition files and scripts used to control its compilation
+    and installation.
+
+    Calc 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 Lesser General
+    Public License for more details.
+
+    A copy of the GNU Lesser General Public License is distributed with
+    calc under the filename:
+
+	    COPYING-LGPL
+
+    You may display this file by the calc command:	help copying
+
+    You may display the GNU Lesser General
+    Public License by the calc command:			help copying-lgpl
+
+    You should have received a copy of the version 2.1 GNU Lesser General
+    Public License with calc; if not, write to the following address:
+
+	    Free Software Foundation, Inc.
+	    51 Franklin Street
+	    Fifth Floor
+	    Boston, MA  02110-1301
+	    USA
+
+    The contact addresses for calc is as follows:
+
+	Web:	http://www.isthe.com/chongo/tech/comp/calc/email.html
+
+    To join the low volume calc mailing list.  Send a EMail message to:
+
+	calc-tester-request at asthe dot com
+
+    Your subject must contain the words:
+
+	calc mailing list subscription
+
+    You may have additional words in your subject line.
+
+    Your message body (not the subject) should consist of:
+
+	 subscribe calc-tester address
+	 end
+	 name your_full_name
+
+    where ``address'' is your EMail address and ``your_full_name'' is
+    your full name.
+
+    Feel free to follow the name line with additional EMail text as desired.
+
+=-=
+
+    Calc bug reports and calc bug fixes should be sent to:
+
+	calc-bugs at asthe dot com
+
+    [[ NOTE: Replace 'at' with @, 'dot' is with . and remove the spaces ]]
+    [[ NOTE: The EMail address uses 'asthe' and the web site URL uses 'isthe' ]]
+
+    Your subject must contain the words:
+
+	   calc bug report
+
+    You may have additional words in your subject line.
+
+=-=
+
+Calc's relationship to the GNU Lesser General Public License
+------------------------------------------------------------
+
+    In section 0 of the GNU Lesser General Public License, one finds
+    the following definition:
+
+	The "Library", below, refers to any such software library or
+	work which has been distributed under these terms.
+
+    Calc is distributed under the terms of the GNU Lesser
+    General Public License.
+
+    In the same section 0, one also find the following:
+
+	For a library, complete source code means all the source code
+	for all modules it contains, plus any associated interface
+	definition files, plus the scripts used to control compilation
+	and installation of the library.
+
+    There are at least two calc binary link libraries found in calc:
+
+	libcalc.a	libcustcalc.a
+
+    Clearly all files that go into the creation of those binary link
+    libraries are covered under the License.
+
+    The ``scripts used to control compilation and installation of the
+    of the library'' include:
+
+	* Makefiles
+	* source files created by the Makefiles
+	* source code used in the creation of intermediate source files
+
+     All of those files are covered under the License.
+
+     The ``associated interface definition files'' are those files that:
+
+	* show how the calc binary link libraries are used
+	* test the validity of the binary link libraries
+	* document routines found in the binary link libraries
+	* show how one can interactively use the binary link libraries
+
+     Calc provides an extensive set of files that perform the above
+     functions.
+
+	* files under the sample sub-directory
+	* files under the help sub-directory
+	* files under the lib sub-directory
+	* the main calc.c file
+
+     The ``complete source code'' includes ALL files shipped with calc,
+     except for the exception files explicitly listed in the ``Calc
+     copyrights and exception files'' section below.
+
+=-=
+
+Calc copyrights and exception files
+-----------------------------------
+
+    With the exception of the files listed below, Calc is covered under
+    the following GNU Lesser General Public License Copyrights:
+
+	Copyright (C) year  David I. Bell
+	Copyright (C) year  David I. Bell and Landon Curt Noll
+	Copyright (C) year  David I. Bell and Ernest Bowen
+	Copyright (C) year  David I. Bell, Landon Curt Noll and Ernest Bowen
+	Copyright (C) year  Landon Curt Noll
+	Copyright (C) year  Ernest Bowen and Landon Curt Noll
+	Copyright (C) year  Ernest Bowen
+	Copyright (C) year  Petteri Kettunen and Landon Curt Noll
+
+    These files are not covered under one of the Copyrights listed above:
+
+	    sha1.c		sha1.h		COPYING
+	    COPYING-LGPL	cal/qtime.cal	cal/screen.cal
+
+    The file COPYING-LGPL, which contains a copy of the version 2.1
+    GNU Lesser General Public License, is itself Copyrighted by the
+    Free Software Foundation, Inc.  Please note that the Free Software
+    Foundation, Inc. does NOT have a copyright over calc, only the
+    COPYING-LGPL that is supplied with calc.
+
+    This file, COPYING, is distributed under the Copyright found at the
+    top of this file.  It is important to note that you may distribute
+    verbatim copies of this file but you may not modify this file.
+
+    Some of these exception files are in the public domain.  Other files
+    are under the LGPL but have different authors that those listed above.
+
+    In all cases one may use and distribute these exception files freely.
+    And because one may freely distribute the LGPL covered files, the
+    entire calc source may be freely used and distributed.
+
+=-=
+
+General Copyleft and License info
+---------------------------------
+
+    For general information on Copylefts, see:
+
+	http://www.gnu.org/copyleft/
+
+    For information on GNU Lesser General Public Licenses, see:
+
+	http://www.gnu.org/copyleft/lesser.html
+	http://www.gnu.org/copyleft/lesser.txt
+
+=-=
+
+Why calc did not use the GNU General Public License
+---------------------------------------------------
+
+    It has been suggested that one should consider using the GNU General
+    Public License instead of the GNU Lesser General Public License:
+
+	http://www.gnu.org/philosophy/why-not-lgpl.html
+
+    As you can read in the above URL, there are times where a library
+    cannot give free software any particular advantage.	 One of those
+    times is when there is significantly similar versions available
+    that are not covered under a Copyleft such as the GNU General Public
+    License.
+
+    The reason why calc was placed under the GNU Lesser General Public
+    License is because for many years (1984 thru 1999), calc was offered
+    without any form of Copyleft.  At the time calc was placed under
+    the GNU Lesser General Public License, a number of systems and
+    distributions distributed calc without a Copyleft.

COPYING-LGPL

@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+

HOWTO.INSTALL

@@ -0,0 +1,215 @@
+Installing calc from the bzip2-ed tarball in 4 easy steps:
+
+    0)  If your platform supports i686 RPMs, you may want to go to:
+
+	    http://www.isthe.com/chongo/src/calc/
+
+	and use these RPMs:
+
+	    * calc*.i686.rpm
+		- all that is needed if you just want to use calc
+
+	    * calc-devel-*.i686.rpm
+	        - calc *.h header and *.a lib files for use in other programs
+
+	    * calc.*.src.rpm
+	        - calc source in RPM package form
+
+	The following 4 steps apply to calc source tree that comes from either:
+
+		bunzip2 -c calc-*.tar.bz2 | tar -xvf -
+
+	or from:
+
+		rpm -ivh calc-*.src.rpm
+		cd /var/tmp
+		bunzip2 -c /usr/src/redhat/SOURCES/calc-*.tar.bz2 | tar -xvf -
+
+    1)	Look at the makefile, and adjust it to suit your needs.
+
+	The top level Makefile and the custom/Makefile require a GNU
+	Make (such as gmake) or an equivalently advanced make.	On many
+	targets, the default make is sufficent.  On FreeBSD for example,
+	one must use gmake instead of make.
+
+	If your target system does not have GNU Make (or equivalent), then
+	you should try using the Makefile.simple and custom/Makefile.simple
+	files:
+
+	    mv Makefile Makefile.gmake
+	    cp Makefile.simple Makefile
+	    mv custom/Makefile custom/Makefile.gmake
+	    cp custom/Makefile.simple custom/Makefile
+
+	The Makefile, as shipped, is suitable for installation under
+	Linux and Un*x-like environments.  For the most part, the default
+	values should work.  If in doubt, follow the 'When in doubt'
+	suggestion.
+
+	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	! If you are building under Windoz or a Windoz-like environment !
+	! (such as Cygwin or DJGPP), read the README.WINDOWS file.      !
+	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+	You should determine if these Makefile variables are reasonable:
+
+	    INCDIR		Where the system include (.h) files are kept.
+	    BINDIR		Where to install calc binary files.
+	    LIBDIR		Where to install calc link library (*.a) files.
+	    CALC_SHAREDIR	Where to install calc help, .cal, startup, and
+	    			config files.
+
+	You may want to change the default installation locations for
+	these values, which are based on the 4 values listed above:
+
+	    HELPDIR            where the help directory is installed
+	    CALC_INCDIR        where the calc include files are installed
+	    CUSTOMCALDIR       where custom *.cal files are installed
+	    CUSTOMHELPDIR      where custom help files are installed
+	    CUSTOMINCDIR       where custom .h files are installed
+	    SCRIPTDIR          where calc shell scripts are installed
+
+	If you want to install calc files under a top level directory,
+	then set the T value:
+
+	    The calc install is performed under ${T}, the calc build is
+	    performed under /.	The purpose for ${T} is to allow someone
+	    to install calc somewhere other than into the system area.
+
+	    For example, if:
+
+	    	BINDIR= /usr/bin
+		LIBDIR= /usr/lib
+		CALC_SHAREDIR= /usr/share/calc
+
+	    and if:
+
+	    	T= /var/tmp/testing
+
+	    Then the installation locations will be:
+
+		calc binary files:	/var/tmp/testing/usr/bin
+		calc link library:	/var/tmp/testing/usr/lib
+		calc help, .cal ...:	/var/tmp/testing/usr/share/calc
+		... etc ...		/var/tmp/testing/...
+
+	    If ${T} is empty, calc is installed under /, which is the same
+	    top of tree for which it was built.  If ${T} is non-empty, then
+	    calc is installed under ${T}, as if one had to chroot under
+	    ${T} for calc to operate.
+
+	Look for the section that starts:
+
+	    ################
+	    # compiler set #
+	    ################
+
+	    Select a compiler set by commenting in the appropriate set
+	    of cc options.  As shipped the Makefile assumes a gcc-like
+	    environment such as Linux.  If a more appropriate cc set if
+	    found below, comment out the Linux set and comment in that
+	    set or edit the gcc set or the common cc set as needed.
+
+	You may want to change these Makrfile variables from their defaults:
+
+	    RANLIB
+
+		You may or may not need RANLIB when building libraries.
+		As shipped the Makefile assumes RANLIB is needed.
+		Comment the in/out the RANLIB value if ranlib does
+		not work or does not exist.
+
+	    CALCPAGER
+
+		You may want to change the default pager used by calc.
+		As shipped the Makefile assumes 'more'.  On your system
+		you may find 'less' to be a better pager.
+
+	    DEBUG
+
+	       Some compilers (to put it mildly) have bugs.  Sometimes the
+	       DEBUG Makefile variable causes the compiler / optimizer to
+	       produce bad code.  Other compilers do just fine.
+
+	       If possible try to use DEBUG=-O3 -g3 (maximum optimization
+	       and debug symbols).  If the calc test fails (see step 3),
+	       try lowering either the -O value and/or the -g3.  Also try
+	       using -Osomething without -g.
+
+	   Adjust other Makefile variables as needed.
+
+    2)	build calc:
+
+	The top level Makefile and the custom/Makefile require a GNU
+	Make (such as gmake) or an equivalently advanced make.	On many
+	targets, the default make is sufficent.  On FreeBSD for example,
+	one must use gmake instead of make.
+
+	If your target system does not have GNU Make (or equivalent), then
+	you should try using the Makefile.simple and custom/Makefile.simple
+	files:
+
+	    mv Makefile Makefile.gmake
+	    cp Makefile.simple Makefile
+	    mv custom/Makefile custom/Makefile.gmake
+	    cp custom/Makefile.simple custom/Makefile
+
+	make all
+
+	==> We are interested in any compiler warnings (and errors) that
+	    you may find.  See the BUGS file if you find any compiler
+	    warning or errors.
+
+	NOTE: You can force calc to build with only static libs:
+
+		make clobber
+		make calc-static-only BLD_TYPE=calc-static-only
+
+	      or force calc to build with only dynamic libs:
+
+		make clobber
+		make calc-dynamic-only BLD_TYPE=calc-dynamic-only
+
+    3)	test calc:
+
+	make check
+
+	==> If you run into problems, read the BUGS file and follow
+	    the instructions found in there.
+
+	NOTE: For a quiet check which only prints if something goes wrong:
+
+		make chk
+
+    4)	install calc:
+
+	make install
+
+We suggest that you might want to read the README file and look at
+the calc help subsystem.  See the README file for details.
+
+## Copyright (C) 1999-2007  Landon Curt Noll
+##
+## Calc is open software; you can redistribute it and/or modify it under
+## the terms of the version 2.1 of the GNU Lesser General Public License
+## as published by the Free Software Foundation.
+##
+## Calc 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 Lesser General
+## Public License for more details.
+##
+## A copy of version 2.1 of the GNU Lesser General Public License is
+## distributed with calc under the filename COPYING-LGPL.  You should have
+## received a copy with calc; if not, write to Free Software Foundation, Inc.
+## 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+##
+## @(#) $Revision: 30.6 $
+## @(#) $Id: HOWTO.INSTALL,v 30.6 2007/10/16 12:22:22 chongo Exp $
+## @(#) $Source: /usr/local/src/cmd/calc/RCS/HOWTO.INSTALL,v $
+##
+## Under source code control:	1999/09/27 20:48:44
+## File existed as early as:	1999
+##
+## chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+## Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/

LIBRARY

@@ -1,22 +1,28 @@
 	USING THE ARBITRARY PRECISION ROUTINES IN A C PROGRAM
 
-Part of the calc release consists of an arbitrary precision math library.
+Part of the calc release consists of an arbitrary precision math link library.
-This library is used by the calc program to perform its own calculations.
+This link library is used by the calc program to perform its own calculations.
 If you wish, you can ignore the calc program entirely and call the arbitrary
 precision math routines from your own C programs.
 
-The library is called libcalc.a, and provides routines to handle arbitrary
+The link library is called libcalc.a, and provides routines to handle arbitrary
 precision arithmetic with integers, rational numbers, or complex numbers.
 There are also many numeric functions such as factorial and gcd, along
 with some transcendental functions such as sin and exp.
 
+Take a look at the sample sub-directory.  It contains a few simple
+examples of how to use libcalc.a that might be helpful to look at
+after you have read this file.
+
 ------------------
 FIRST THINGS FIRST
 ------------------
 
-*******************************************************************************
+...............................................................................
-* You MUST call libcalc_call_me_first() prior to using libcalc lib functions! *
+.									      .
-*******************************************************************************
+. You MUST call libcalc_call_me_first() prior to using libcalc lib functions! .
+.									      .
+...............................................................................
 
 The function libcalc_call_me_first() takes no args and returns void.  You
 need call libcalc_call_me_first() only once.
@@ -37,80 +43,250 @@ to use more than one type of arithmetic, since qmath.h automatically includes
 zmath.h, and cmath.h automatically includes qmath.h.
 
 The prototypes for the available routines are listed in the above include
-files.  Some of these routines are meant for internal use, and so aren't
+files.	Some of these routines are meant for internal use, and so aren't
 convenient for outside use.  So you should read the source for a routine
 to see if it really does what you think it does.  I won't guarantee that
 obscure internal routines won't change or disappear in future releases!
 
-When calc is installed, all of the include files needed to build
+When calc is installed, all of libraries are installed into ${LIBDIR}.
-libcalc.a along with the library itself (and the lint library
+All of the calc header files are installed under ${INCDIRCALC}.
-llib-lcalc.ln, if made) are installed into ${LIBDIR}.
+
+If CALC_SRC is defined, then the calc header files will assume that
+they are in or under the current directory.  However, most external
+programs most likely will not be located under calc'c source tree.
+External programs most likely want to use the installed calc header
+files under ${INCDIRCALC}.  External programs most likely NOT want
+to define CALC_SRC.
+
+You need to include the following file to get the symbols and variables
+related to error handling:
+
+	lib_calc.h
 
 External programs may want to compile with:
 
-	-I${LIBDIR} -L${LIBDIR} -lcalc
+	-I${INCDIR} -L${LIBDIR} -lcalc
 
---------------
+If custom functions are also used, they may want to compile with:
-ERROR HANDLING
---------------
 
-Your program MUST provide a function called math_error.  This is called by
+	-I${INCDIR} -L${LIBDIR} -lcalc -lcustcalc
-the math routines on an error condition, such as malloc failures or a
-division by zero.  The routine is called in the manner of printf, with a
-format string and optional arguments.  (However, none of the low level math
-routines currently uses formatting, so if you are lazy you can simply use
-the first argument as a simple error string.)  For example, one of the
-error calls you might expect to receive is:
 
-	math_error("Division by zero");
+The CALC_SRC symbol should NOT be defined by default.  However if you are
+feeling pedantic you may want to force CALC_SRC to be undefined:
 
-Your program can handle errors in basically one of two ways.  Firstly, it
+	-UCALC_SRC
-can simply print the error message and then exit.  Secondly, you can make
-use of setjmp and longjmp in your program.  Use setjmp at some appropriate
-level in your program, and use longjmp in the math_error routine to return
-to that level and so recover from the error.  This is what the calc program
-does.
 
-For convenience, the library libcalc.a contains a math_error routine.
+as well.
-By default, this routine simply prints a message to stderr and then exits.
-By simply linking in this library, any calc errors will result in a
-error message on stderr followed by an exit.
 
-External programs that wish to use this math_error may want to compile with:
+-------------------
+MATH ERROR HANDLING
+-------------------
 
-	-I${LIBDIR} -L${LIBDIR} -lcalc
+The math_error() function is called by the math routines on an error
+condition, such as malloc failures, division by zero, or some form of
+an internal computation error.  The routine is called in the manner of
+printf, with a format string and optional arguments:
 
-If one sets up calc_jmp_buf, and then sets calc_jmp to non-zero then
+	    void math_error(char *fmt, ...);
-this routine will longjmp back (with the value of calc_jmp) instead.
-In addition, the last calc error message will be found in calc_error;
-this error is not printed to stderr.  The calc error message will
-not have a trailing newline.
 
-For example:
+Your program must handle math errors in one of three ways:
 
-    #include <setjmp.h>
+    1) Print the error message and then exit
 
-    extern jmp_buf calc_jmp_buf;
+	There is a math_error() function supplied with the calc library.
-    extern int calc_jmp;
+	By default, this routine simply prints a message to stderr and
-    extern char *calc_error;
+	then exits.  By simply linking in this link library, any calc
-    int error;
+	errors will result in a error message on stderr followed by
+	an exit.
 
-    ...
+    2) Use setjmp and longjmp in your program
+
+	Use setjmp at some appropriate level in your program, and let
+	the longjmp in math_error() return to that level and to allow you
+	to recover from the error.  This is what the calc program does.
+
+	If one sets up calc_matherr_jmpbuf, and then sets
+	calc_use_matherr_jmpbuf to non-zero then math_error() will
+	longjmp back with the return value of calc_use_matherr_jmpbuf.
+	In addition, the last calc error message will be found in
+	calc_err_msg; this error is not printed to stderr.  The calc
+	error message will not have a trailing newline.
+
+	For example:
+
+	    #include <setjmp.h>
+	    #include "lib_calc.h"
+
+	    int error;
+
+	    ...
+
+	    if ((error = setjmp(calc_matherr_jmpbuf)) != 0) {
+
+		    /* report the error */
+		    printf("Ouch: %s\n", calc_err_msg);
+
+		    /* reinitialize calc after the longjmp */
+		    reinitialize();
+	    }
+	    calc_use_matherr_jmpbuf = 1;
+
+	If calc_use_matherr_jmpbuf is non-zero, then the jmp_buf value
+	calc_matherr_jmpbuf must be initialized by the setjmp() function
+	or your program will crash.
+
+    3) Supply your own math_error function:
+
+	    void math_error(char *fmt, ...);
+
+	Your math_error() function may exit or transfer control to outside
+	of the calc library, but it must never return or calc will crash.
+
+External programs can obtain the appropriate calc symbols by compiling with:
+
+	-I${INCDIR} -L${LIBDIR} -lcalc
+
+-------------------------
+PARSE/SCAN ERROR HANDLING
+-------------------------
+
+The scanerror() function is called when calc encounters a parse/scan
+error.  For example, scanerror() is called when calc is given code
+with a syntax error.
+
+The variable, calc_print_scanerr_msg, controls if calc prints to stderr,
+any parse/scan errors.  By default, this variable it set to 1 and so
+parse/scan errors are printed to stderr.  By setting this value to zero,
+parse/scan errors are not printed:
+
+	#include "lib_calc.h"
+
+	/* do not print parse/scan errors to stderr */
+	calc_print_scanerr_msg = 0;
+
+The last calc math error or calc parse/scan error message is kept
+in the NUL terminated buffer:
+
+	char calc_err_msg[MAXERROR+1];
+
+The value of calc_print_scanerr_msg does not change the use
+of the calc_err_msg[] buffer.  Messages are stored in that
+buffer regardless of the calc_print_scanerr_msg value.
+
+The calc_print_scanerr_msg and the calc_err_msg[] buffer are declared
+lib_calc.h include file.  The initialized storage for these variables
+comes from the calc library.  The MAXERROR symbol is also declared in
+the lib_calc.h include file.
+
+Your program must handle parse/scan errors in one of two ways:
+
+    1) exit on error
+
+	If you do not setup the calc_scanerr_jmpbuf, then when calc
+	encounters a parse/scan error, a message will be printed to
+	stderr and calc will exit.
+
+    2) Use setjmp and longjmp in your program
+
+	Use setjmp at some appropriate level in your program, and let
+	the longjmp in scanerror() return to that level and to allow you
+	to recover from the error.  This is what the calc program does.
+
+	If one sets up calc_scanerr_jmpbuf, and then sets
+	calc_use_scanerr_jmpbuf to non-zero then scanerror() will longjmp
+	back with the return with a non-zero code.  In addition, the last
+	calc error message will be found in calc_err_msg[]; this error is
+	not printed to stderr.	The calc error message will not have a
+	trailing newline.
+
+	For example:
+
+	    #include <setjmp.h>
+	    #include "lib_calc.h"
+
+	    int scan_error;
+
+	    ...
+
+	    /* delay the printing of the parse/scan error */
+	    calc_use_scanerr_jmpbuf = 0;	/* this is optional */
+
+	    if ((scan_error = setjmp(calc_scanerr_jmpbuf)) != 0) {
+
+		    /* report the parse/scan */
+		    if (calc_use_scanerr_jmpbuf == 0) {
+			    printf("parse error: %s\n", calc_err_msg);
+	    	    }
+
+		    /* initialize calc after the longjmp */
+		    initialize();
+	    }
+	    calc_use_scanerr_jmpbuf = 1;
+
+	If calc_use_scanerr_jmpbuf is non-zero, then the jmp_buf value
+	calc_scanerr_jmpbuf must be initialized by the setjmp() function
+	or your program will crash.
+
+External programs can obtain the appropriate calc symbols by compiling with:
+
+	-I${INCDIR} -L${LIBDIR} -lcalc
+
+---------------------------
+PARSE/SCAN WARNING HANDLING
+---------------------------
+
+Calc parse/scan warning message are printed to stderr by the warning()
+function.  The routine is called in the manner of printf, with a format
+string and optional arguments:
+
+	void warning(char *fmt, ...);
+
+The variable, calc_print_scanwarn_msg, controls if calc prints to stderr,
+any parse/scan warnings.  By default, this variable it set to 1 and so
+parse/scan warnings are printed to stderr.  By setting this value to zero,
+parse/scan warnings are not printed:
+
+	#include "lib_calc.h"
+
+	/* do not print parse/scan warnings to stderr */
+	calc_print_scanwarn_msg = 0;
+
+The last calc calc parse/scan warning message is kept in the NUL
+terminated buffer:
+
+	char calc_warn_msg[MAXERROR+1];
+
+The value of calc_print_scanwarn_msg does not change the use
+of the calc_warn_msg[] buffer.  Messages are stored in that
+buffer regardless of the calc_print_scanwarn_msg value.
+
+Your program must handle parse/scan warnings in one of two ways:
+
+    1) print the warning to stderr and continue
+
+	The warning() from libcalc prints warning messages to
+	stderr and returns.  The flow of execution is not changed.
+	This is what calc does by default.
+
+    2) Supply your own warning function:
+
+	    void warning(char *fmt, ...);
+
+	Your warning function should simply return when it is finished.
+
+External programs can obtain the appropriate calc symbols by compiling with:
+
+	-I${INCDIR} -L${LIBDIR} -lcalc
 
-    if ((error = setjmp(calc_jmp_buf)) != 0) {
-	    /* handle error */
-	    printf("Ouch: %s\n", calc_error);
-    }
-    calc_jmp = 1;
 
 ---------------
 OUTPUT ROUTINES
 ---------------
 
-The output from the routines in the library normally goes to stdout.  You
+The output from the routines in the link library normally goes to stdout.
-can divert that output to either another FILE handle, or else to a string.
+You can divert that output to either another FILE handle, or else
-Read the routines in zio.c to see what is available.  Diversions can be
+to a string.  Read the routines in zio.c to see what is available.
-nested.
+Diversions can be nested.
 
 You use math_setfp to divert output to another FILE handle.  Calling
 math_setfp with stdout restores output to stdout.
@@ -132,7 +308,7 @@ output strings with space filling, output formatted strings like printf, and
 flush the output.  Output from these routines is diverted as described above.
 
 You can change the default output mode by calling math_setmode, and you can
-change the default number of digits printed by calling math_setdigits.  These
+change the default number of digits printed by calling math_setdigits.	These
 routines return the previous values.  The possible modes are described in
 zmath.h.
 
@@ -144,7 +320,7 @@ The arbitrary precision integer routines define a structure called a ZVALUE.
 This is defined in zmath.h.  A ZVALUE contains a pointer to an array of
 integers, the length of the array, and a sign flag.  The array is allocated
 using malloc, so you need to free this array when you are done with a
-ZVALUE.  To do this, you should call zfree with the ZVALUE as an argument
+ZVALUE.	 To do this, you should call zfree with the ZVALUE as an argument
 (or call freeh with the pointer as an argument) and never try to free the
 array yourself using free.  The reason for this is that sometimes the pointer
 points to one of two statically allocated arrays which should NOT be freed.
@@ -238,7 +414,7 @@ If the value is too large for ztofull(), ztoulong() or ztolong(), only
 the low order bits converted.
 
 There are two types of comparisons you can make on ZVALUEs.  This is whether
-or not they are equal, or the ordering on size of the numbers.  The zcmp
+or not they are equal, or the ordering on size of the numbers.	The zcmp
 function tests whether two ZVALUEs are equal, returning TRUE if they differ.
 The zrel function tests the relative sizes of two ZVALUEs, returning -1 if
 the first one is smaller, 0 if they are the same, and 1 if the first one
@@ -257,7 +433,7 @@ is always positive.  If the NUMBER is an integer, the denominator has the
 value 1.
 
 Unlike ZVALUEs, NUMBERs are passed using pointers, and pointers to them are
-returned by functions.  So the basic type for using fractions is not really
+returned by functions.	So the basic type for using fractions is not really
 (NUMBER), but is (NUMBER *).  NUMBERs are allocated using the qalloc routine.
 This returns a pointer to a number which has the value 1.  Because of the
 special property of a ZVALUE of 1, the numerator and denominator of this
@@ -273,7 +449,7 @@ A better way to create NUMBERs with particular values is to use the itoq,
 iitoq, or atoq functions.  Using itoq makes a long value into a NUMBER,
 using iitoq makes a pair of longs into the numerator and denominator of a
 NUMBER (reducing them first if needed), and atoq converts a string representing
-a number into the corresponding NUMBER.  The atoq function accepts input in
+a number into the corresponding NUMBER.	 The atoq function accepts input in
 integral, fractional, real, or exponential formats.  Examples of allocating
 numbers are:
 
@@ -284,7 +460,7 @@ numbers are:
 	q3 = atoq("456.78");
 
 Also unlike ZVALUEs, NUMBERs are quickly copied.  This is because they contain
-a link count, which is the number of pointers there are to the NUMBER.  The
+a link count, which is the number of pointers there are to the NUMBER.	The
 qlink macro is used to copy a pointer to a NUMBER, and simply increments
 the link count and returns the same pointer.  Since it is a macro, the
 argument should not be a function call, but a real pointer variable.  The
@@ -318,13 +494,13 @@ Examples of these are qnum to return the numerator, qden to return the
 denominator, qint to return the integer part of, qfrac to return the
 fractional part of, and qinv to invert a fraction.
 
-There are some transcendental functions in the library, such as sin and cos.
+There are some transcendental functions in the link library, such as sin
-These cannot be evaluated exactly as fractions.  Therefore, they accept
+and cos.  These cannot be evaluated exactly as fractions.  Therefore,
-another argument which tells how accurate you want the result.  This is an
+they accept another argument which tells how accurate you want the result.
-"epsilon" value, and the returned value will be within that quantity of
+This is an "epsilon" value, and the returned value will be within that
-the correct value.  This is usually an absolute difference, but for some
+quantity of the correct value.	This is usually an absolute difference,
-functions (such as exp), this is a relative difference.  For example, to
+but for some functions (such as exp), this is a relative difference.
-calculate sin(0.5) to 100 decimal places, you could do:
+For example, to calculate sin(0.5) to 100 decimal places, you could do:
 
 	NUMBER *q, *ans, *epsilon;
 
@@ -353,7 +529,7 @@ macros are:
 The comparisons for NUMBERs are similar to the ones for ZVALUEs.  You use the
 qcmp and qrel functions.
 
-There are four predefined values for fractions.  You should qlink them when
+There are four predefined values for fractions.	 You should qlink them when
 you want to use them.  These are _qzero_, _qone_, _qnegone_, and _qonehalf_.
 These have the values 0, 1, -1, and 1/2.  An example of using them is:
 
@@ -367,7 +543,7 @@ USING COMPLEX NUMBERS
 ---------------------
 
 The arbitrary precision complex arithmetic routines define a structure
-called COMPLEX.  This is defined in cmath.h.  This contains two NUMBERs
+called COMPLEX.	 This is defined in cmath.h.  This contains two NUMBERs
 for the real and imaginary parts of a complex number, and a count of the
 number of links there are to this COMPLEX number.
 
@@ -400,7 +576,7 @@ There is no direct routine to convert a string value into a COMPLEX value.
 But you can do this yourself by converting two strings into two NUMBERS,
 and then using the qqtoc routine.
 
-COMPLEX values are always returned from these routines.  To split out the
+COMPLEX values are always returned from these routines.	 To split out the
 real and imaginary parts into normal NUMBERs, you can simply qlink the
 two components, as shown in the following example:
 
@@ -413,7 +589,7 @@ two components, as shown in the following example:
 
 There are many macros for checking quick things about complex numbers,
 similar to the ZVALUE and NUMBER macros.  In addition, there are some
-only used for complex numbers.  Examples of macros are:
+only used for complex numbers.	Examples of macros are:
 
 	cisreal(c)	(number is real)
 	cisimag(c)	(number is pure imaginary)
@@ -431,6 +607,43 @@ only used for complex numbers.  Examples of macros are:
 There is only one comparison you can make for COMPLEX values, and that is
 for equality.  The ccmp function returns TRUE if two complex numbers differ.
 
-There are three predefined values for complex numbers.  You should clink
+There are three predefined values for complex numbers.	You should clink
-them when you want to use them.  They are _czero_, _cone_, and _conei_.
+them when you want to use them.	 They are _czero_, _cone_, and _conei_.
 These have the values 0, 1, and i.
+
+----------------
+LAST THINGS LAST
+----------------
+
+If you wish, when you are all doen you can call libcalc_call_me_last()
+to free a small amount of storage associated with the libcalc_call_me_first()
+call.  This is not required, but is does bring things to a closure.
+
+The function libcalc_call_me_last() takes no args and returns void.  You
+need call libcalc_call_me_last() only once.
+
+## Copyright (C) 1999  David I. Bell and Landon Curt Noll
+##
+## Calc is open software; you can redistribute it and/or modify it under
+## the terms of the version 2.1 of the GNU Lesser General Public License
+## as published by the Free Software Foundation.
+##
+## Calc 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 Lesser General
+## Public License for more details.
+##
+## A copy of version 2.1 of the GNU Lesser General Public License is
+## distributed with calc under the filename COPYING-LGPL.  You should have
+## received a copy with calc; if not, write to Free Software Foundation, Inc.
+## 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+##
+## @(#) $Revision: 30.1 $
+## @(#) $Id: LIBRARY,v 30.1 2007/03/16 11:09:46 chongo Exp $
+## @(#) $Source: /usr/local/src/cmd/calc/RCS/LIBRARY,v $
+##
+## Under source code control:	1993/07/30 19:44:49
+## File existed as early as:	1993
+##
+## chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+## Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/

README

@@ -1,68 +1,145 @@
-# Copyright (c) 1994 David I. Bell
+Dear calc user,
-# Permission is granted to use, distribute, or modify this source,
-# provided that this copyright notice remains intact.
-#
-# Arbitrary precision calculator.
 
-I am allowing this calculator to be freely distributed for personal uses.
+See the HOWTO.INSTALL file for information on how to build and install calc.
-Like all multi-precision programs, you should not depend absolutely on
-its results, since bugs in such programs can be insidious and only rarely
-show up.
 
--dbell-
+To be sure that your version of calc is up to date, check out:
 
-p.s. By Landon Curt Noll:
+	http://www.isthe.com/chongo/tech/comp/calc/calc-download.html
 
-Building calc in 3 easy steps:
+We are interested in any/all feedback on recent versions of calc.
+In particular we would like to hear about:
 
-    1) Look at the makefile, and adjust it to suit your needs.
+    * compiler warnings
+    * compile problems
+    * regression test problems (try: make check)
+    * special compile flags/options that you needed
+    * Makefile problems
+    * help file problems
+    * misc nits and typos
 
-       Here are some Makefile hints:
+We would like to offer a clean compile across a wide verity of platforms,
+so if you can test on several, so much the better!
 
-	   In the past, some people have had to adjust the VARARG or
+If you run into problems, see the BUGS file.
-	   TERMCONTROL because the Makefile cannot always guess
-	   correctly for certain systems.  You may need to play with
-	   these values if you experience problems.
-
-	   The default compiler used is 'cc'.  The default compiler flag
-	   is '-O'.  If you have gcc, or gcc v2 (or better) you should use
-	   that instead.   Some compilers allow for optimization beyond
-	   just -O (gcc v2 has -O2, mips cc has -O3).  You should select
-	   the best flag for speed optimization.  Calc can be cpu intensive
-	   so selecting a quality compiler and good optimization level can
-	   really pay off.
-
-    2) build calc:
-
-	make all
-
-    3) test calc:
-
-	make check
-
- ==>>>If you run into problems, follow the instructions in the BUGS file<<<==
 
 =-=
 
-For further reading:
+Calc is distributed with an extensive collection of help files that
+are accessible from the command line.  The following assume that you
+are running calc from the distribution directory or that you have
+installed calc.	 In these examples, the ">" is the calc prompt, not
+something that you type in.
 
-    LIBRARY
+For list of help topics:
-    	explains how programs can use libcalc.a to take advantage
+
-	of the calc multi-precision routines.
+    > help
+
+For overview of calc overview:
+
+    > help intro
+    > help overview
+    > help command
+    > help define
+    > help statement
+    > help variable
+    > help usage
+
+For list of builtin functions:
+
+    > help builtin
+
+C programmers should note some unexpected differences in the calc syntax:
+
+    > help unexpected
+
+Calc is shipped with a standard collection of calc resource files.
+For a list of calc standard resource files see:
+
+    > help resource
+
+=-=
+
+See the file:
 
     help/todo
-	current wish list for calc
+    help/wishlist
 
-    CHANGES
+or run:
-	recent changes to calc
 
-    BUGS
+    calc help todo
-	known bugs, mis-features and how to report problems
+    calc help wishlist
 
-    help/full
+for a wish/todo list.  Code contributions are welcome.
-	full set of calc documentation
 
 =-=
 
-David I. Bell    dbell@auug.org.au
+To join the calc-tester mailing list.  Send an EMail message to:
-chongo@toad.com	<Landon Curt Noll -- chongo@toad.com> /\../\
+
+    calc-tester-request at asthe dot com
+
+    [[ NOTE: Replace 'at' with @, 'dot' is with . and remove the spaces ]]
+    [[ NOTE: The EMail address uses 'asthe' and the web site URL uses 'isthe' ]]
+
+Your subject must contain the words:
+
+    calc mailing list subscription
+
+You may have additional words in your subject line.
+
+Your message body (not the subject) should consist of:
+
+     subscribe calc-tester address
+     end
+     name your_full_name
+
+where ``address'' is your EMail address and ``your_full_name'' is
+your full name.
+
+Feel free to follow the name line with additional EMail text as desired.
+
+=-=
+
+Send Calc bug and bug fixes to:
+
+    calc-bugs at asthe dot com
+
+    [[ NOTE: Replace 'at' with @, 'dot' is with . and remove the spaces ]]
+    [[ NOTE: The EMail address uses 'asthe' and the web site URL uses 'isthe' ]]
+
+but see the BUGS file first.
+
+Your subject must contain the words:
+
+       calc bug report
+
+You may have additional words in your subject line.
+
+The calc web site is located at:
+
+	http://www.isthe.com/chongo/tech/comp/calc/
+
+## Copyright (C) 1999  Landon Curt Noll
+##
+## Calc is open software; you can redistribute it and/or modify it under
+## the terms of the version 2.1 of the GNU Lesser General Public License
+## as published by the Free Software Foundation.
+##
+## Calc 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 Lesser General
+## Public License for more details.
+##
+## A copy of version 2.1 of the GNU Lesser General Public License is
+## distributed with calc under the filename COPYING-LGPL.  You should have
+## received a copy with calc; if not, write to Free Software Foundation, Inc.
+## 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+##
+## @(#) $Revision: 30.1 $
+## @(#) $Id: README,v 30.1 2007/03/16 11:09:46 chongo Exp $
+## @(#) $Source: /usr/local/src/cmd/calc/RCS/README,v $
+##
+## Under source code control:	1995/10/25 05:27:59
+## File existed as early as:	1995
+##
+## chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+## Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/

README.FIRST

@@ -1,52 +0,0 @@
-Dear alpha tester,
-
-Thanks for taking the time to try out this alpha version of calc!  We are
-interested in any/all feedback that you may have on this version.  In
-particular we would like to hear about:
-
-    * compile problems
-    * regression test problems (try: make check)
-    * compiler warnings
-    * special compile flags/options that you needed
-    * Makefile problems
-    * help file problems
-    * misc nits and typos
-
-We would like to offer a clean compile across a wide verity of platforms,
-so if you can test on several, so much the better!
-
-Calc distributions may be obtained from:
-
-	ftp://ftp.uu.net/pub/calc
-
-If you don't have ftp access to that site, or if you do not find a more
-recent version (you may have a special pre-released version that is
-more advanced than what is in the ftp archive) send EMail to:
-
-	chongo@toad.com
-
-Indicate the version you have and that you would like a more up
-to date version.
-
-=-=
-
-Misc items TODO before Beta release:
-
-    * improve the coverage in the 'SEE ALSO' help file lists
-
-    * where reasonable, be sure that regress.cal tests builtin functions
-
-    * add the Blum-Blum-Shub random() generator code
-
-    * add code to allow of the reading, writing and processing of binary data
-
-    * add shs, shs-1 and md5 hashing functions.  Use align32.h.
-
-    * add mod h*2^n+/-1 function for integers
-
-    * be sure that CHANGES is up to date,
-      look over the help/todo file and update as needed,
-      revisit issues in the BUGS file and
-      change this file  :-)
-
-    * clean the source code and document it better

README.WINDOWS

@@ -0,0 +1,153 @@
+Dear calc user on a Windoz based system,
+
+See the HOWTO.INSTALL file for information on how to build and install calc.
+See also the README file.
+
+NOTE: The main developers do not have access to a Windoz based platform.
+      While we will make an effort to not break calc Windoz based system,
+      our lack of a Windoz test environment will mean we will make mistakes
+      from time to time.  Hopefully Windowz users can overcome these mistakes.
+      Of course you are welcome to send us any patches that fix your
+      Windoz build environment.
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+=-= compiling with Cygwin =-=
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+An effort is being made to allow windows users to compile calc using the
+Cygwin project (http://sources.redhat.com/cygwin/) with the GCC compiler
+and Un*x tools for Windows.
+
+The major porting work for Cygwin was performed by Thomas Jones-Low
+(tjoneslo at softstart dot com).
+
+In March 2009, Michael Penk (mpenk at wuska dot com) reported success in
+installs under Cygwin:
+
+    On my fairly complete Cygwin installs, everything compiles,
+    checks, and installs correctly.  My Cygwin is configured
+    in a very standard way (out of the box, using all of Cygwin's
+    defaults).  The install worked on 5 different machines with
+    Cygwin on them: one XP home, one XP professional, and three
+    Vista professionals.
+
+Using the calc Makefile, he did the following:
+
+    make all target=Cygwin
+    make check
+    make install
+
+He also reports:
+
+    Of course, one should be logged in as an Administrator when
+    one builds and installs calc.
+
+He was compiling calc 2.12.4.0 with Cygwin version 1.5.25-15.
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+=-= If all else fails, for Cygwin =-=
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+Much earlier (2001?) Thomas Jones-Low (tjoneslo at softstart dot com)
+recommended that you generate by hand all of the header files that
+by the Makefile.  This has been done for you via the makefile rule:
+
+	make win32_hsrc
+
+which uses the Makefile variables in win32.mkdef to form these header
+files under win32 directory.
+
+You will find generated versions of these files located in the win32
+sub-directory.  These files may be appropriate for your Cygwin building
+needs.
+
+In particular:
+
+	Just copy the win32/*.[ch] files up into the top level calc
+	source directory, edit them (if needed) and build using the
+	Cygwin GCC compiler and Cygwin build environment.
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+=-= compiling under DJGPP =-=
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+You might want to try using the DJGPP system to compile calc.  See:
+
+	http://www.delorie.com/djgpp/
+
+for DJGPP details and availability.
+
+To compile with DJGPP, one needs to select a number of Makefile
+variable changes.  Eli Zaretskii <eliz at is dot elta dot co dot il>
+recommends the following settings:
+
+	TERMCONTROL= -DUSE_TERMIOS
+	BYTE_ORDER= -DLITTLE_ENDIAN
+	LONG_BITS= 32
+	HAVE_FPOS_POS= -DHAVE_NO_FPOS_POS
+	FPOS_BITS= 32
+	OFF_T_BITS= 32
+	DEV_BITS= 32
+	INODE_BITS= 32
+	HAVE_USTAT= -DHAVE_NO_USTAT
+	HAVE_GETSID= -DHAVE_NO_GETSID
+	HAVE_GETPGID= -DHAVE_NO_GETPGID
+	HAVE_GETTIME= -DHAVE_NO_GETTIME
+	HAVE_GETPRID= -DHAVE_NO_GETPRID
+	HAVE_URANDOM_H= NO
+	ALIGN32= -UMUST_ALIGN32
+	HAVE_MALLOC_H= YES
+	HAVE_STDLIB_H= YES
+	HAVE_STRING_H= YES
+	HAVE_TIMES_H= NO
+	HAVE_SYS_TIMES_H= YES
+	HAVE_TIME_H= YES
+	HAVE_SYS_TIME_H= YES
+	HAVE_UNISTD_H= YES
+	BINDIR= /dev/env/DJDIR/bin
+	INCDIR= /dev/env/DJDIR/include
+	LIBDIR= /dev/env/DJDIR/lib
+	MANDIR= /dev/env/DJDIR/man/man1
+	CATDIR= /dev/env/DJDIR/man/cat1
+	NROFF= groff
+	CALCPATH= .;./cal;~/.cal;${CALC_SHAREDIR};${CUSTOMCALDIR}
+	CALCRC= ${CALC_SHAREDIR}/startup;~/.calcrc;./.calcinit
+	CALCPAGER= less.exe -ci
+	DEBUG= -O2 -gstabs+ -DWINDOZ
+
+The 'Linux set' or 'gcc set' (see the Select your compiler type section)
+should work for DJGPP systems if you set the above Makefile variables.
+
+Look for Makefile comments of the form:
+
+	# Select ...something... for DJGPP.
+
+Follow those recommendations.  In cases where they conflict with
+the above Makefile list, follow the recommendation in the Makefile.
+
+
+## Copyright (C) 2002-2009  Landon Curt Noll and Thomas Jones-Low
+##
+## Calc is open software; you can redistribute it and/or modify it under
+## the terms of the version 2.1 of the GNU Lesser General Public License
+## as published by the Free Software Foundation.
+##
+## Calc 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 Lesser General
+## Public License for more details.
+##
+## A copy of version 2.1 of the GNU Lesser General Public License is
+## distributed with calc under the filename COPYING-LGPL.  You should have
+## received a copy with calc; if not, write to Free Software Foundation, Inc.
+## 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+##
+## @(#) $Revision: 30.2 $
+## @(#) $Id: README.WINDOWS,v 30.2 2009/03/14 02:29:31 chongo Exp $
+## @(#) $Source: /usr/local/src/cmd/calc/RCS/README.WINDOWS,v $
+##
+## Under source code control:	2001/02/25 14:00:05
+## File existed as early as:	2001
+##
+## chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+## Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/

addop.c

@@ -1,33 +1,60 @@
 /*
- * Copyright (c) 1995 David I. Bell
+ * addop - add opcodes to a function being compiled
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * Add opcodes to a function being compiled.
+ * Copyright (C) 1999-2007  David I. Bell and Ernest Bowen
+ *
+ * Primary author:  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: addop.c,v 30.1 2007/03/16 11:09:46 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/RCS/addop.c,v $
+ *
+ * Under source code control:	1990/02/15 01:48:10
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
 
+
+#include <stdio.h>
 #include "calc.h"
 #include "opcodes.h"
-#include "string.h"
+#include "str.h"
 #include "func.h"
 #include "token.h"
 #include "label.h"
 #include "symbol.h"
 
 
-#define	FUNCALLOCSIZE	20	/* reallocate size for functions */
+#define FUNCALLOCSIZE	20	/* reallocate size for functions */
-#define	OPCODEALLOCSIZE	100	/* reallocate size for opcodes in functions */
+#define OPCODEALLOCSIZE 100	/* reallocate size for opcodes in functions */
 
 
-static long maxopcodes;		/* number of opcodes available */
+STATIC unsigned long maxopcodes;/* number of opcodes available */
-static long newindex;		/* index of new function */
+STATIC long newindex;		/* index of new function */
-static long oldop;		/* previous opcode */
+STATIC char *newname;		/* name of new function */
-static long debugline;		/* line number of latest debug opcode */
+STATIC long oldop;		/* previous opcode */
-static long funccount;		/* number of functions */
+STATIC long oldoldop;		/* opcode before previous opcode */
-static long funcavail;		/* available number of functions */
+STATIC long debugline;		/* line number of latest debug opcode */
-static FUNC *functemplate;	/* function definition template */
+STATIC long funccount;		/* number of functions */
-static FUNC **functions;	/* table of functions */
+STATIC long funcavail;		/* available number of functions */
-static STRINGHEAD funcnames;	/* function names */
+STATIC FUNC *functemplate;	/* function definition template */
+STATIC FUNC **functions;	/* table of functions */
+STATIC STRINGHEAD funcnames;	/* function names */
 
 
 /*
@@ -59,22 +86,50 @@ initfunctions(void)
 void
 showfunctions(void)
 {
-	FUNC **fpp;		/* pointer into function table */
 	FUNC *fp;		/* current function */
+	long count;
+	long index;
 
-	if (funccount == 0) {
+	count = 0;
-		printf("No user functions defined.\n");
+	if (funccount > 0) {
-		return;
+		if (conf->resource_debug & RSCDBG_FUNC_INFO)
+			math_str("Index\tName        \tArgs\tOpcodes\n"
+				 "-----\t------     \t---- \t------\n");
+		else
+			math_str("Name\tArguments\n"
+				 "----\t---------\n");
+		for (index = 0; index < funccount; index++) {
+			fp = functions[index];
+			if (conf->resource_debug & RSCDBG_FUNC_INFO) {
+
+				math_fmt("%5ld\t%-12s\t", index,
+					namestr(&funcnames,index));
+				if (fp) {
+					count++;
+					math_fmt("%-5d\t%-5ld\n",
+					 fp->f_paramcount, fp->f_opcodecount);
+				} else {
+					math_str("null\t0\n");
+				}
+			} else {
+				if (fp == NULL)
+					continue;
+				count++;
+				math_fmt("%-12s\t%-2d\n", namestr(&funcnames,
+					index), fp->f_paramcount);
+			}
+		}
 	}
-	printf("Name Arguments\n");
+	if (conf->resource_debug & RSCDBG_FUNC_INFO) {
-	printf("---- ---------\n");
+		math_fmt("\nNumber non-null: %ld\n", count);
-	for (fpp = &functions[funccount - 1]; fpp >= functions; fpp--) {
+		math_fmt("Number null: %ld\n", funccount - count);
-		fp = *fpp;
+		math_fmt("Total number: %ld\n", funccount);
-		if (fp == NULL)
+	} else {
-			continue;
+		if (count > 0)
-		printf("%-12s %-2d\n", fp->f_name, fp->f_paramcount);
+			math_fmt("\nNumber: %ld\n", count);
+		else
+			math_str("No user functions defined\n");
 	}
-	printf("\n");
 }
 
 
@@ -107,11 +162,14 @@ beginfunc(char *name, BOOL newflag)
 	fp->f_localcount = 0;
 	fp->f_opcodecount = 0;
 	fp->f_savedvalue.v_type = V_NULL;
-	fp->f_name = namestr(&funcnames, newindex);
+	fp->f_savedvalue.v_subtype = V_NOSUBTYPE;
+	newname = namestr(&funcnames, newindex);
+	fp->f_name = newname;
 	curfunc = fp;
 	initlocals();
 	initlabels();
 	oldop = OP_NOP;
+	oldoldop = OP_NOP;
 	debugline = 0;
 	errorcount = 0;
 }
@@ -126,12 +184,19 @@ void
 endfunc(void)
 {
 	register FUNC *fp;		/* function just finished */
-	unsigned long size;		/* size of just created function */
+	size_t size;			/* size of just created function */
+	unsigned long index;
+
+	if (oldop != OP_RETURN) {
+		addop(OP_UNDEF);
+		addop(OP_RETURN);
+	}
 
 	checklabels();
+
 	if (errorcount) {
-		printf("\"%s\": %ld error%s\n", curfunc->f_name, errorcount,
+		scanerror(T_NULL,"Compilation of \"%s\" failed: %ld error(s)",
-			((errorcount == 1) ? "" : "s"));
+			 newname, errorcount);
 		return;
 	}
 	size = funcsize(curfunc->f_opcodecount);
@@ -143,21 +208,31 @@ endfunc(void)
 	memcpy((char *) fp, (char *) curfunc, size);
 	if (curfunc != functemplate)
 		free(curfunc);
-	if (conf->traceflags & TRACE_FNCODES) {
+	if (newname[0] != '*' && (conf->traceflags & TRACE_FNCODES)) {
 		dumpnames = TRUE;
 		for (size = 0; size < fp->f_opcodecount; ) {
-			printf("%ld: ", (long)size);
+			printf("%ld: ", (unsigned long)size);
 			size += dumpop(&fp->f_opcodes[size]);
 		}
 	}
+	if ((inputisterminal() && conf->resource_debug & RSCDBG_STDIN_FUNC) ||
+	    (!inputisterminal() && conf->resource_debug & RSCDBG_FILE_FUNC)) {
+		printf("%s(", newname);
+		for (index = 0; index <	 fp->f_paramcount; index++) {
+			if (index)
+				putchar(',');
+			printf("%s", paramname(index));
+		}
+		printf(") ");
+		if (functions[newindex])
+			printf("re");
+		printf("defined\n");
+	}
 	if (functions[newindex]) {
+		freenumbers(functions[newindex]);
 		free(functions[newindex]);
-		fprintf(stderr, "**** %s() has been redefined\n", fp->f_name);
 	}
 	functions[newindex] = fp;
-	objuncache();
-	if (inputisterminal())
-		printf("\"%s\" defined\n", fp->f_name);
 }
 
 
@@ -195,6 +270,100 @@ adduserfunc(char *name)
 	return index;
 }
 
+/*
+ * Remove user defined function
+ */
+void
+rmuserfunc(char *name)
+{
+	long index;		/* index of function */
+
+	index = findstr(&funcnames, name);
+	if (index < 0) {
+		warning("No function named \"%s\" to be undefined", name);
+		return;
+	}
+	if (functions[index] == NULL) {
+		warning("No defined function \"%s\" to be undefined", name);
+		return;
+	}
+	freenumbers(functions[index]);
+	free(functions[index]);
+	if ((inputisterminal() && conf->resource_debug & RSCDBG_STDIN_FUNC) ||
+	    (!inputisterminal() && conf->resource_debug & RSCDBG_FILE_FUNC))
+		printf("%s() undefined\n", name);
+	functions[index] = NULL;
+}
+
+
+/*
+ * Free memory used to store function and its constants
+ */
+void
+freefunc(FUNC *fp)
+{
+	long index;
+	unsigned long i;
+
+	if (fp == NULL)
+		return;
+	if (fp == curfunc) {
+		index = newindex;
+	} else {
+		for (index = 0; index < funccount; index++) {
+			if (functions[index] == fp)
+				break;
+		}
+		if (index == funccount) {
+			math_error("Bad call to freefunc!!!");
+			/*NOTREACHED*/
+		}
+	}
+	if (newname[0] != '*' && (conf->traceflags & TRACE_FNCODES)) {
+		printf("Freeing function \"%s\"\n",namestr(&funcnames,index));
+		dumpnames = FALSE;
+		for (i = 0; i < fp->f_opcodecount; ) {
+			printf("%ld: ", i);
+			i += dumpop(&fp->f_opcodes[i]);
+		}
+	}
+	freenumbers(fp);
+	if (fp != functemplate)
+		free(fp);
+}
+
+
+void
+rmalluserfunc(void)
+{
+	FUNC *fp;
+	long index;
+
+	for (index = 0; index < funccount; index++) {
+		fp = functions[index];
+		if (fp) {
+			freefunc(fp);
+			functions[index] = NULL;
+		}
+	}
+}
+
+
+/*
+ * get index of defined user function with specified name, or -1 if there
+ * is none or if it has been undefined
+ */
+long
+getuserfunc(char *name)
+{
+	long index;
+
+	index = findstr(&funcnames, name);
+	if (index >= 0 && functions[index] != NULL)
+		return index;
+	return -1L;
+}
+
 
 /*
  * Clear any optimization that may be done for the next opcode.
@@ -204,6 +373,7 @@ void
 clearopt(void)
 {
 	oldop = OP_NOP;
+	oldoldop = OP_NOP;
 	debugline = 0;
 }
 
@@ -214,7 +384,7 @@ clearopt(void)
 FUNC *
 findfunc(long index)
 {
-	if ((unsigned long) index >= funccount) {
+	if (index >= funccount) {
 		math_error("Undefined function");
 		/*NOTREACHED*/
 	}
@@ -253,10 +423,17 @@ void
 addop(long op)
 {
 	register FUNC *fp;		/* current function */
-	NUMBER *q;
+	NUMBER *q, *q1, *q2;
+	unsigned long count;
+	BOOL cut;
+	int diff;
 
 	fp = curfunc;
-	if ((fp->f_opcodecount + 5) >= maxopcodes) {
+	count = fp->f_opcodecount;
+	cut = TRUE;
+	diff = 2;
+	q = NULL;
+	if ((count + 5) >= maxopcodes) {
 		maxopcodes += OPCODEALLOCSIZE;
 		fp = (FUNC *) malloc(funcsize(maxopcodes));
 		if (fp == NULL) {
@@ -269,73 +446,172 @@ addop(long op)
 			free(curfunc);
 		curfunc = fp;
 	}
+
 	/*
 	 * Check the current opcode against the previous opcode and try to
 	 * slightly optimize the code depending on the various combinations.
 	 */
-	if (op == OP_GETVALUE) {
+	switch (op) {
+	case OP_GETVALUE:
 		switch (oldop) {
-
+		case OP_NUMBER:
-		case OP_NUMBER: case OP_ZERO: case OP_ONE: case OP_IMAGINARY:
+		case OP_ZERO:
-		case OP_GETEPSILON: case OP_SETEPSILON: case OP_STRING:
+		case OP_ONE:
-		case OP_UNDEF: case OP_GETCONFIG: case OP_SETCONFIG:
+		case OP_IMAGINARY:
+		case OP_GETEPSILON:
+		case OP_SETEPSILON:
+		case OP_STRING:
+		case OP_UNDEF:
+		case OP_GETCONFIG:
+		case OP_SETCONFIG:
 			return;
 		case OP_DUPLICATE:
-			fp->f_opcodes[fp->f_opcodecount - 1] = OP_DUPVALUE;
+			diff = 1;
 			oldop = OP_DUPVALUE;
-			return;
+			break;
 		case OP_FIADDR:
-			fp->f_opcodes[fp->f_opcodecount - 1] = OP_FIVALUE;
+			diff = 1;
 			oldop = OP_FIVALUE;
-			return;
+			break;
 		case OP_GLOBALADDR:
-			fp->f_opcodes[fp->f_opcodecount - 2] = OP_GLOBALVALUE;
+			diff = 1 + PTR_SIZE;
 			oldop = OP_GLOBALVALUE;
-			return;
+			break;
 		case OP_LOCALADDR:
-			fp->f_opcodes[fp->f_opcodecount - 2] = OP_LOCALVALUE;
 			oldop = OP_LOCALVALUE;
-			return;
+			break;
 		case OP_PARAMADDR:
-			fp->f_opcodes[fp->f_opcodecount - 2] = OP_PARAMVALUE;
 			oldop = OP_PARAMVALUE;
-			return;
+			break;
 		case OP_ELEMADDR:
-			fp->f_opcodes[fp->f_opcodecount - 2] = OP_ELEMVALUE;
 			oldop = OP_ELEMVALUE;
+			break;
+		default:
+			cut = FALSE;
+
+		}
+		if (cut) {
+			fp->f_opcodes[count - diff] = oldop;
+			return;
+		}
+		break;
+	case OP_POP:
+		switch (oldop) {
+		case OP_ASSIGN:
+			fp->f_opcodes[count-1] = OP_ASSIGNPOP;
+			oldop = OP_ASSIGNPOP;
+			return;
+		case OP_NUMBER:
+		case OP_IMAGINARY:
+			q = constvalue(fp->f_opcodes[count-1]);
+			qfree(q);
+			break;
+		case OP_STRING:
+			sfree(findstring((long)fp->f_opcodes[count-1]));
+			break;
+		case OP_LOCALADDR:
+		case OP_PARAMADDR:
+			break;
+		case OP_GLOBALADDR:
+			diff = 1 + PTR_SIZE;
+			break;
+		case OP_UNDEF:
+			fp->f_opcodecount -= 1;
+			oldop = OP_NOP;
+			oldoldop = OP_NOP;
+			return;
+		default:
+			cut = FALSE;
+		}
+		if (cut) {
+			fp->f_opcodecount -= diff;
+			oldop = OP_NOP;
+			oldoldop = OP_NOP;
+			warning("Constant before comma operator");
+			return;
+		}
+		break;
+	case OP_NEGATE:
+		if (oldop == OP_NUMBER) {
+			q = constvalue(fp->f_opcodes[count-1]);
+			fp->f_opcodes[count-1] = addqconstant(qneg(q));
+			qfree(q);
 			return;
 		}
 	}
-	if ((op == OP_NEGATE) && (oldop == OP_NUMBER)) {
+	if (oldop == OP_NUMBER) {
-		q = constvalue(fp->f_opcodes[fp->f_opcodecount - 1]);
+		if (oldoldop == OP_NUMBER) {
-		fp->f_opcodes[fp->f_opcodecount - 1] = addqconstant(qneg(q));
+			q1 = constvalue(fp->f_opcodes[count - 3]);
-		oldop = OP_NUMBER;
+			q2 = constvalue(fp->f_opcodes[count - 1]);
-		return;
+			switch (op) {
-	}
+			case OP_DIV:
-	if ((op == OP_POWER) && (oldop == OP_NUMBER)) {
+				if (qiszero(q2)) {
-		if (qcmpi(constvalue(fp->f_opcodes[fp->f_opcodecount - 1]), 2L) == 0) {
+					cut = FALSE;
-			fp->f_opcodecount--;
+					break;
-			fp->f_opcodes[fp->f_opcodecount - 1] = OP_SQUARE;
+				}
-			oldop = OP_SQUARE;
+				q = qqdiv(q1,q2);
-			return;
+				break;
+			case OP_MUL:
+				q = qmul(q1,q2);
+				break;
+			case OP_ADD:
+				q = qqadd(q1,q2);
+				break;
+			case OP_SUB:
+				q = qsub(q1,q2);
+				break;
+			case OP_POWER:
+				if (qisfrac(q2) || qisneg(q2))
+					cut = FALSE;
+				else
+					q = qpowi(q1,q2);
+				break;
+			default:
+				cut = FALSE;
+			}
+			if (cut) {
+				qfree(q1);
+				qfree(q2);
+				fp->f_opcodes[count - 3] = addqconstant(q);
+				fp->f_opcodecount -= 2;
+				oldoldop = OP_NOP;
+				return;
+			}
+		} else if (op != OP_NUMBER) {
+			q = constvalue(fp->f_opcodes[count - 1]);
+			if (op == OP_POWER) {
+				if (qcmpi(q, 2L) == 0) {
+					fp->f_opcodecount--;
+					fp->f_opcodes[count - 2] = OP_SQUARE;
+					qfree(q);
+					oldop = OP_SQUARE;
+					return;
+				}
+				if (qcmpi(q, 4L) == 0) {
+					fp->f_opcodes[count - 2] = OP_SQUARE;
+					fp->f_opcodes[count - 1] = OP_SQUARE;
+					qfree(q);
+					oldop = OP_SQUARE;
+					return;
+				}
+			}
+			if (qiszero(q)) {
+				qfree(q);
+				fp->f_opcodes[count - 2] = OP_ZERO;
+				fp->f_opcodecount--;
+			} else if (qisone(q)) {
+				qfree(q);
+				fp->f_opcodes[count - 2] = OP_ONE;
+				fp->f_opcodecount--;
+			}
 		}
-		if (qcmpi(constvalue(fp->f_opcodes[fp->f_opcodecount - 1]), 4L) == 0) {
-			fp->f_opcodes[fp->f_opcodecount - 2] = OP_SQUARE;
-			fp->f_opcodes[fp->f_opcodecount - 1] = OP_SQUARE;
-			oldop = OP_SQUARE;
-			return;
-		}
-	}
-	if ((op == OP_POP) && (oldop == OP_ASSIGN)) {	/* optimize */
-		fp->f_opcodes[fp->f_opcodecount - 1] = OP_ASSIGNPOP;
-		oldop = OP_ASSIGNPOP;
-		return;
 	}
 	/*
 	 * No optimization possible, so store the opcode.
 	 */
 	fp->f_opcodes[fp->f_opcodecount] = op;
 	fp->f_opcodecount++;
+	oldoldop = oldop;
 	oldop = op;
 }
 
@@ -347,24 +623,7 @@ addop(long op)
 void
 addopone(long op, long arg)
 {
-	NUMBER *q;
+	if (op == OP_DEBUG) {
-
-	switch (op) {
-	case OP_NUMBER:
-		q = constvalue(arg);
-		if (q == NULL)
-			break;
-		if (qiszero(q)) {
-			addop(OP_ZERO);
-			return;
-		}
-		if (qisone(q)) {
-			addop(OP_ONE);
-			return;
-		}
-		break;
-
-	case OP_DEBUG:
 		if ((conf->traceflags & TRACE_NODEBUG) || (arg == debugline))
 			return;
 		debugline = arg;
@@ -372,7 +631,6 @@ addopone(long op, long arg)
 			curfunc->f_opcodes[curfunc->f_opcodecount - 1] = arg;
 			return;
 		}
-		break;
 	}
 	addop(op);
 	curfunc->f_opcodes[curfunc->f_opcodecount] = arg;
@@ -444,5 +702,3 @@ addoplabel(long op, LABEL *label)
 	addop(op);
 	uselabel(label);
 }
-
-/* END CODE */

align32.c

@@ -1,23 +1,34 @@
 /*
  * align32 - determine if 32 bit accesses must be aligned
  *
- * This file was written by:
+ * Copyright (C) 1999  Landon Curt Noll
  *
- *	 Landon Curt Noll  (chongo@toad.com)	chongo <was here> /\../\
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
  *
- * This code has been placed in the public domain.  Please do not
+ * Calc is distributed in the hope that it will be useful, but WITHOUT
- * copyright this code.
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU Lesser General
+ * Public License for more details.
  *
- * LANDON CURT NOLL DISCLAIMS ALL WARRANTIES WITH  REGARD  TO
+ * A copy of version 2.1 of the GNU Lesser General Public License is
- * THIS  SOFTWARE,  INCLUDING  ALL IMPLIED WARRANTIES OF MER-
+ * distributed with calc under the filename COPYING-LGPL.  You should have
- * CHANTABILITY AND FITNESS.  IN NO EVENT SHALL  LANDON  CURT
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
- * NOLL  BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM  LOSS  OF
+ *
- * USE,  DATA  OR  PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * @(#) $Revision: 30.1 $
- * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR  IN
+ * @(#) $Id: align32.c,v 30.1 2007/03/16 11:09:46 chongo Exp $
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ * @(#) $Source: /usr/local/src/cmd/calc/RCS/align32.c,v $
+ *
+ * Under source code control:	1995/11/23 05:18:06
+ * File existed as early as:	1995
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
 
+
 #include <stdio.h>
 #include <signal.h>
 #include "longbits.h"
@@ -30,7 +41,7 @@
 static void buserr(void);	/* catch alignment errors */
 
 
-MAIN
+int
 main(void)
 {
 	char byte[2*sizeof(USB32)];	/* mis-alignment buffer */
@@ -58,7 +69,8 @@ main(void)
 	   '/', '/');
 
 #endif
-	exit(0);
+	/* exit(0); */
+	return 0;
 }
 
 
@@ -66,7 +78,7 @@ main(void)
  * buserr - catch an alignment error
  *
  * given:
- *      arg             to keep ANSI C happy
+ *	arg		to keep ANSI C happy
  */
 /*ARGSUSED*/
 static void

alloc.h

@@ -1,54 +1,73 @@
 /*
- * Copyright (c) 1995 David I. Bell
+ * alloc - storage allocation and storage debug macros
- * Permission is granted to use, distribute, or modify this source,
+ *
- * provided that this copyright notice remains intact.
+ * Copyright (C) 1999-2007  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.2 $
+ * @(#) $Id: alloc.h,v 30.2 2008/04/15 21:17:57 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/RCS/alloc.h,v $
+ *
+ * Under source code control:	1990/02/15 01:48:29
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 
-#if !defined(ALLOC_H)
+#if !defined(__ALLOC_H__)
-#define ALLOC_H
+#define __ALLOC_H__
 
-#include "have_malloc.h"
-#include "have_newstr.h"
-#include "have_string.h"
 
-#ifdef HAVE_MALLOC_H
+#if defined(CALC_SRC)	/* if we are building from the calc source tree */
-# include <malloc.h>
+# include "have_newstr.h"
+# include "have_string.h"
+# include "have_memmv.h"
 #else
-# if defined(__STDC__) && __STDC__ != 0
+# include <calc/have_newstr.h>
-   extern void *malloc();
+# include <calc/have_string.h>
-   extern void *realloc();
+# include <calc/have_memmv.h>
-   extern void free();
-# else
-   extern char *malloc();
-   extern char *realloc();
-   extern void free();
-# endif
 #endif
 
 #ifdef HAVE_STRING_H
 # include <string.h>
 
 #else
+#if defined(_WIN32) && defined(NOTCYGWIN)
+#include <stdio.h>
+#endif
 
 # if defined(HAVE_NEWSTR)
-extern void *memcpy();
+E_FUNC void *memcpy();
-extern void *memset();
+E_FUNC void *memset();
-#  if defined(__STDC__) && __STDC__ != 0
+#if defined(FORCE_STDC) || (defined(__STDC__) && __STDC__ != 0) || defined(__cplusplus)
-extern size_t strlen();
+E_FUNC size_t strlen();
 #  else
-extern long strlen();	/* should be size_t, but old systems don't have it */
+E_FUNC long strlen();
 #  endif
 # else /* HAVE_NEWSTR */
-extern void bcopy();
+E_FUNC void bcopy();
-extern void bfill();
+E_FUNC void bfill();
-extern char *index();
+E_FUNC char *index();
 # endif /* HAVE_NEWSTR */
-extern char *strchr();
+E_FUNC char *strchr();
-extern char *strcpy();
+E_FUNC char *strcpy();
-extern char *strncpy();
+E_FUNC char *strncpy();
-extern char *strcat();
+E_FUNC char *strcat();
-extern int strcmp();
+E_FUNC int strcmp();
 
 #endif
 
@@ -61,4 +80,14 @@ extern int strcmp();
 #define strchr(s, c) index(s, c)
 #endif /* HAVE_NEWSTR */
 
-#endif /* !ALLOC_H */
+#if !defined(HAVE_MEMMOVE)
+# undef MEMMOVE_SIZE_T
+#if defined(FORCE_STDC) || (defined(__STDC__) && __STDC__ != 0) || defined(__cplusplus)
+#  define MEMMOVE_SIZE_T size_t
+# else
+#  define MEMMOVE_SIZE_T long
+# endif
+E_FUNC void *memmove(void *s1, CONST void *s2, MEMMOVE_SIZE_T n);
+#endif
+
+#endif /* !__ALLOC_H__ */

assocfunc.c

@@ -1,8 +1,33 @@
 /*
- * Copyright (c) 1995 David I. Bell
+ * assocfunc - association table routines
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
+ * Copyright (C) 1999-2007  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: assocfunc.c,v 30.1 2007/03/16 11:09:46 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/RCS/assocfunc.c,v $
+ *
+ * Under source code control:	1993/07/20 23:04:27
+ * File existed as early as:	1993
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
  * Association table routines.
  * An association table is a type of value which can be "indexed" by
  * one or more arbitrary values.  Each element in the table is thus an
@@ -11,19 +36,20 @@
  * quick access.
  */
 
+
 #include "value.h"
 
 
-#define	MINHASHSIZE	31	/* minimum size of hash tables */
+#define MINHASHSIZE	31	/* minimum size of hash tables */
-#define	GROWHASHSIZE	50	/* approximate growth for hash tables */
+#define GROWHASHSIZE	50	/* approximate growth for hash tables */
-#define	CHAINLENGTH	10	/* desired number of elements on a hash chain */
+#define CHAINLENGTH	10	/* desired number of elements on a hash chain */
-#define	ELEMSIZE(n)	(sizeof(ASSOCELEM) + (sizeof(VALUE) * ((n) - 1)))
+#define ELEMSIZE(n)	(sizeof(ASSOCELEM) + (sizeof(VALUE) * ((n) - 1)))
 
 
-static ASSOCELEM *elemindex(ASSOC *ap, long index);
+S_FUNC ASSOCELEM *elemindex(ASSOC *ap, long index);
-static BOOL compareindices(VALUE *v1, VALUE *v2, long dim);
+S_FUNC BOOL compareindices(VALUE *v1, VALUE *v2, long dim);
-static void resize(ASSOC *ap, long newsize);
+S_FUNC void resize(ASSOC *ap, long newsize);
-static void assoc_elemfree(ASSOCELEM *ep);
+S_FUNC void assoc_elemfree(ASSOCELEM *ep);
 
 
 /*
@@ -43,12 +69,12 @@ associndex(ASSOC *ap, BOOL create, long dim, VALUE *indices)
 {
 	ASSOCELEM **listhead;
 	ASSOCELEM *ep;
-	static VALUE val;
+	STATIC VALUE val;
 	QCKHASH hash;
 	int i;
 
-	if (dim <= 0) {
+	if (dim < 0) {
-		math_error("No dimensions for indexing association");
+		math_error("Negative dimension for indexing association");
 		/*NOTREACHED*/
 	}
 
@@ -57,7 +83,7 @@ associndex(ASSOC *ap, BOOL create, long dim, VALUE *indices)
 	 * so that we can first select the correct hash chain, and
 	 * also so we can quickly compare each element for a match.
 	 */
-	hash = (QCKHASH)0;
+	hash = FNV1_32_BASIS;
 	for (i = 0; i < dim; i++)
 		hash = hashvalue(&indices[i], hash);
 
@@ -80,6 +106,7 @@ associndex(ASSOC *ap, BOOL create, long dim, VALUE *indices)
 	 */
 	if (!create) {
 		val.v_type = V_NULL;
+		val.v_subtype = V_NOSUBTYPE;
 		return &val;
 	}
 
@@ -91,6 +118,7 @@ associndex(ASSOC *ap, BOOL create, long dim, VALUE *indices)
 	ep->e_dim = dim;
 	ep->e_hash = hash;
 	ep->e_value.v_type = V_NULL;
+	ep->e_value.v_subtype = V_NOSUBTYPE;
 	for (i = 0; i < dim; i++)
 		copyvalue(&indices[i], &ep->e_indices[i]);
 	ep->e_next = *listhead;
@@ -105,47 +133,62 @@ associndex(ASSOC *ap, BOOL create, long dim, VALUE *indices)
 
 /*
  * Search an association for the specified value starting at the
- * specified index.  Returns the element number (zero based) of the
+ * specified index.  Returns 0 and stores index if value found,
- * found value, or -1 if the value was not found.
+ * otherwise returns 1.
  */
-long
+int
-assocsearch(ASSOC *ap, VALUE *vp, long index)
+assocsearch(ASSOC *ap, VALUE *vp, long i, long j, ZVALUE *index)
 {
 	ASSOCELEM *ep;
 
-	if (index < 0)
+	if (i < 0 || j > ap->a_count) {
-		index = 0;
+		math_error("This should not happen in assocsearch");
-	while (TRUE) {
+		/*NOTREACHED*/
-		ep = elemindex(ap, index);
-		if (ep == NULL)
-			return -1;
-		if (!comparevalue(&ep->e_value, vp))
-			return index;
-		index++;
 	}
+	while (i < j) {
+		ep = elemindex(ap, i);
+		if (ep == NULL) {
+			math_error("This should not happen in assocsearch");
+			/*NOTREACHED*/
+		}
+		if (acceptvalue(&ep->e_value, vp)) {
+			utoz(i, index);
+			return 0;
+		}
+		i++;
+	}
+	return 1;
 }
 
 
 /*
  * Search an association backwards for the specified value starting at the
- * specified index.  Returns the element number (zero based) of the
+ * specified index.  Returns 0 and stores the index if the value is
- * found value, or -1 if the value was not found.
+ * found; otherwise returns 1.
  */
-long
+int
-assocrsearch(ASSOC *ap, VALUE *vp, long index)
+assocrsearch(ASSOC *ap, VALUE *vp, long i, long j, ZVALUE *index)
 {
 	ASSOCELEM *ep;
 
-	if (index >= ap->a_count)
+	if (i < 0 || j > ap->a_count) {
-		index = ap->a_count - 1;
+		math_error("This should not happen in assocsearch");
-	while (TRUE) {
+		/*NOTREACHED*/
-		ep = elemindex(ap, index);
-		if (ep == NULL)
-			return -1;
-		if (!comparevalue(&ep->e_value, vp))
-			return index;
-		index--;
 	}
+	j--;
+	while (j >= i) {
+		ep = elemindex(ap, j);
+		if (ep == NULL) {
+			math_error("This should not happen in assocsearch");
+			/*NOTREACHED*/
+		}
+		if (acceptvalue(&ep->e_value, vp)) {
+			utoz(j, index);
+			return 0;
+		}
+		j--;
+	}
+	return 1;
 }
 
 
@@ -157,7 +200,7 @@ assocrsearch(ASSOC *ap, VALUE *vp, long index)
  *	ap		association to index into
  *	index		index of desired element
  */
-static ASSOCELEM *
+S_FUNC ASSOCELEM *
 elemindex(ASSOC *ap, long index)
 {
 	ASSOCELEM *ep;
@@ -200,6 +243,27 @@ assocfindex(ASSOC *ap, long index)
 }
 
 
+/*
+ * Returns the list of indices for an association element with specified
+ * double-bracket index.
+ */
+LIST *
+associndices(ASSOC *ap, long index)
+{
+	ASSOCELEM *ep;
+	LIST *lp;
+	int i;
+
+	ep = elemindex(ap, index);
+	if (ep == NULL)
+		return NULL;
+	lp = listalloc();
+	for (i = 0; i < ep->e_dim; i++)
+		insertlistlast(lp, &ep->e_indices[i]);
+	return lp;
+}
+
+
 /*
  * Compare two associations to see if they are identical.
  * Returns TRUE if they are different.
@@ -228,8 +292,7 @@ assoccmp(ASSOC *ap1, ASSOC *ap2)
 			hash = ep1->e_hash;
 			dim = ep1->e_dim;
 			for (ep2 = ap2->a_table[hash % size2]; ;
-				ep2 = ep2->e_next)
+				ep2 = ep2->e_next) {
-			{
 				if (ep2 == NULL)
 					return TRUE;
 				if (ep2->e_hash != hash)
@@ -266,8 +329,7 @@ assoccopy(ASSOC *oldap)
 
 	for (oldhi = 0; oldhi < oldap->a_size; oldhi++) {
 		for (oldep = oldap->a_table[oldhi]; oldep;
-			oldep = oldep->e_next)
+			oldep = oldep->e_next) {
-		{
 			ep = (ASSOCELEM *) malloc(ELEMSIZE(oldep->e_dim));
 			if (ep == NULL) {
 				math_error("Cannot allocate association element");
@@ -276,6 +338,7 @@ assoccopy(ASSOC *oldap)
 			ep->e_dim = oldep->e_dim;
 			ep->e_hash = oldep->e_hash;
 			ep->e_value.v_type = V_NULL;
+			ep->e_value.v_subtype = V_NOSUBTYPE;
 			for (i = 0; i < ep->e_dim; i++)
 				copyvalue(&oldep->e_indices[i], &ep->e_indices[i]);
 			copyvalue(&oldep->e_value, &ep->e_value);
@@ -293,7 +356,7 @@ assoccopy(ASSOC *oldap)
  * This is only actually done if the growth from the previous size is
  * enough to make this worthwhile.
  */
-static void
+S_FUNC void
 resize(ASSOC *ap, long newsize)
 {
 	ASSOCELEM **oldtable;
@@ -337,7 +400,7 @@ resize(ASSOC *ap, long newsize)
 /*
  * Free an association element, along with any contained values.
  */
-static void
+S_FUNC void
 assoc_elemfree(ASSOCELEM *ep)
 {
 	int i;
@@ -431,8 +494,7 @@ assocprint(ASSOC *ap, long max_print)
 		((ap->a_count == 1) ? "" : "s"));
 
 	for (index = 0; ((index < max_print) && (index < ap->a_count));
-		index++)
+		index++) {
-	{
 		ep = elemindex(ap, index);
 		if (ep == NULL)
 			continue;
@@ -458,7 +520,7 @@ assocprint(ASSOC *ap, long max_print)
  * Compare two lists of index values to see if they are identical.
  * Returns TRUE if they are the same.
  */
-static BOOL
+S_FUNC BOOL
 compareindices(VALUE *v1, VALUE *v2, long dim)
 {
 	int i;
@@ -473,5 +535,3 @@ compareindices(VALUE *v1, VALUE *v2, long dim)
 
 	return TRUE;
 }
-
-/* END CODE */

blkcpy.h

@@ -0,0 +1,62 @@
+/*
+ * blkcpy - general values and related routines used by the calculator
+ *
+ * Copyright (C) 1999-2007  Landon Curt Noll and Ernest Bowen
+ *
+ * Primary author:  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: blkcpy.h,v 30.1 2007/03/16 11:09:46 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/RCS/blkcpy.h,v $
+ *
+ * Under source code control:	1997/04/18 20:41:25
+ * File existed as early as:	1997
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+#if !defined(__BLKCPY_H__)
+#define __BLKCPY_H__
+
+/*
+ * the main copy gateway function
+ */
+E_FUNC int copystod(VALUE *, long, long, VALUE *, long);
+
+/*
+ * specific copy functions
+ */
+E_FUNC int copyblk2blk(BLOCK *, long, long, BLOCK *, long, BOOL);
+E_FUNC int copyblk2file(BLOCK *, long, long, FILEID, long);
+E_FUNC int copyblk2mat(BLOCK *, long, long, MATRIX *, long);
+E_FUNC int copyblk2num(BLOCK *, long, long, NUMBER *, long, NUMBER **);
+E_FUNC int copyblk2str(BLOCK *, long, long, STRING *, long);
+E_FUNC int copyfile2blk(FILEID, long, long, BLOCK *, long, BOOL);
+E_FUNC int copylist2list(LIST *, long, long, LIST *, long);
+E_FUNC int copylist2mat(LIST *, long, long, MATRIX *, long);
+E_FUNC int copymat2blk(MATRIX *, long, long, BLOCK *, long, BOOL);
+E_FUNC int copymat2list(MATRIX *, long, long, LIST *, long);
+E_FUNC int copymat2mat(MATRIX *, long, long, MATRIX *, long);
+E_FUNC int copynum2blk(NUMBER *, long, long, BLOCK *, long, BOOL);
+E_FUNC int copyostr2blk(char *, long, long, BLOCK *, long, BOOL);
+E_FUNC int copyostr2str(char *, long, long, STRING *, long);
+E_FUNC int copystr2blk(STRING *, long, long, BLOCK *, long, BOOL);
+E_FUNC int copystr2file(STRING *, long, long, FILEID, long);
+E_FUNC int copystr2str(STRING *, long, long, STRING *, long);
+
+#endif /* !__BLKCPY_H__ */

block.c

@@ -0,0 +1,747 @@
+/*
+ * block - fixed, dynamic, fifo and circular memory blocks
+ *
+ * Copyright (C) 1999-2007  Landon Curt Noll and Ernest Bowen
+ *
+ * Primary author:  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: block.c,v 30.1 2007/03/16 11:09:46 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/RCS/block.c,v $
+ *
+ * Under source code control:	1997/02/27 00:29:40
+ * File existed as early as:	1997
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+#include <stdio.h>
+#include "value.h"
+#include "zmath.h"
+#include "config.h"
+#include "block.h"
+#include "nametype.h"
+#include "str.h"
+#include "calcerr.h"
+
+#define NBLOCKCHUNK 16
+
+STATIC long nblockcount = 0;
+STATIC long maxnblockcount = 0;
+STATIC STRINGHEAD nblocknames;
+STATIC NBLOCK **nblocks;
+
+
+/* forward declarations */
+S_FUNC void blkchk(BLOCK*);
+
+
+/*
+ * blkalloc - allocate a block
+ *
+ * given:
+ *	len	- initial memory length of the block
+ *	type	- BLK_TYPE_XYZ
+ *	chunk	- allocation chunk size
+ *
+ * returns:
+ *	pointer to a newly allocated BLOCK
+ */
+BLOCK *
+blkalloc(int len, int chunk)
+{
+	BLOCK *nblk;	/* new block allocated */
+
+	/*
+	 * firewall
+	 */
+	if (len < 0)
+		len = 0;
+	if (chunk <= 0)
+		chunk = BLK_CHUNKSIZE;
+
+	/*
+	 * allocate BLOCK
+	 */
+	nblk = (BLOCK *)malloc(sizeof(BLOCK));
+	if (nblk == NULL) {
+		math_error("cannot allocate block");
+		/*NOTREACHED*/
+	}
+
+	/*
+	 * initialize BLOCK
+	 */
+	nblk->blkchunk = chunk;
+	nblk->maxsize = ((len+chunk)/chunk)*chunk;
+	nblk->data = (USB8*)malloc(nblk->maxsize);
+	if (nblk->data == NULL) {
+		math_error("cannot allocate block data storage");
+		/*NOTREACHED*/
+	}
+	memset(nblk->data, 0, nblk->maxsize);
+	nblk->datalen = len;
+
+	/*
+	 * return BLOCK
+	 */
+	if (conf->calc_debug & CALCDBG_BLOCK) {
+		blkchk(nblk);
+	}
+	return nblk;
+}
+
+
+/*
+ * blk_free - free a block
+ *
+ * NOTE: THIS IS NOT THE CALC blktrunc() BUILTIN FUNCTION!!  This
+ * is what is called to free block storage.
+ *
+ * given:
+ *	blk	- the block to free
+ */
+void
+blk_free(BLOCK *blk)
+{
+	/* free if non-NULL */
+	if (blk != NULL) {
+
+		/* free data storage */
+		if (blk->data != NULL) {
+			free(blk->data);
+		}
+
+		/* free the block */
+		free(blk);
+	}
+	return;
+}
+
+
+/*
+ * blkchk - check the sanity of a block
+ *
+ * These checks should never fail if calc is working correctly.	 During
+ * debug time, we plan to call this function often.  Once we are satisfied,
+ * we will normally call this code only in a few places.
+ *
+ * If "calc_debug" has the bit corresponding to CALCDBG_BLOCK set, this
+ * function is called during execution of the following builtins:
+ *
+ *	alloc(), realloc(), free()
+ *
+ * given:
+ *	blk	- the BLOCK to check
+ *
+ * returns:
+ *	if all is ok, otherwise math_error() is called and this
+ *	function does not return
+ */
+S_FUNC void
+blkchk(BLOCK *blk)
+{
+
+	/*
+	 * firewall - general sanity check
+	 */
+	if ((conf->calc_debug & CALCDBG_BLOCK) == 0) {
+		/* do nothing when debugging is disabled */
+		return;
+	}
+	if (blk == NULL) {
+		math_error("internal: blk ptr is NULL");
+		/*NOTREACHED*/
+	}
+
+	/*
+	 * pointers must not be NULL
+	 */
+	if (blk->data == NULL) {
+		math_error("internal: blk->data ptr is NULL");
+		/*NOTREACHED*/
+	}
+
+	/*
+	 * check data lengths
+	 */
+	if (blk->datalen < 0) {
+		math_error("internal: blk->datalen < 0");
+		/*NOTREACHED*/
+	}
+
+	/*
+	 * check the datalen and datalen2 values
+	 */
+	if (blk->datalen < 0) {
+		math_error("internal: blk->datalen < 0");
+		/*NOTREACHED*/
+	}
+	return;
+}
+
+
+/*
+ * blkrealloc - reallocate a block
+ *
+ * Reallocation of a block can change several aspects of a block.
+ *
+ *	It can change the much data it holds or can hold.
+ *
+ *	It can change the memory footprint (in terms of
+ *	how much storage is malloced for current or future use).
+ *
+ *	It can change the chunk size used to grow malloced size
+ *	as the data size grows.
+ *
+ * Each of the len and chunksize may be kept the same.
+ *
+ * given:
+ *	blk	- old BLOCK to reallocate
+ *	newlen	- how much data the block holds
+ *	newchunk - allocation chunk size (<0 ==> no change, 0 == default)
+ */
+BLOCK *
+blkrealloc(BLOCK *blk, int newlen, int newchunk)
+{
+	USB8 *nblk;	/* realloced storage */
+	int newmax;	/* new maximum stoage size */
+
+	/*
+	 * firewall
+	 */
+	if (conf->calc_debug & CALCDBG_BLOCK) {
+		blkchk(blk);
+	}
+
+	/*
+	 * process args
+	 */
+	/* newlen < 0 means do not change the length */
+	if (newlen < 0) {
+		newlen = blk->datalen;
+	}
+	/* newchunk <= 0 means do not change the chunk size */
+	if (newchunk < 0) {
+		newchunk = blk->blkchunk;
+	} else if (newchunk == 0) {
+		newchunk = BLK_CHUNKSIZE;
+	}
+
+	/*
+	 * reallocate storage if we have a different allocation size
+	 */
+	newmax = ((newlen+newchunk)/newchunk)*newchunk;
+	if (newmax != blk->maxsize) {
+
+		/* reallocate new storage */
+		nblk = (USB8*)realloc(blk->data, newmax);
+		if (nblk == NULL) {
+			math_error("cannot reallocate block storage");
+			/*NOTREACHED*/
+		}
+
+		/* clear any new storage */
+		if (newmax > blk->maxsize) {
+			memset(nblk+blk->maxsize, 0, (newmax-blk->maxsize));
+		}
+		blk->maxsize = newmax;
+
+		/* restore the data pointers */
+		blk->data = nblk;
+	}
+
+	/*
+	 * deal the case of a newlen == 0 early and return
+	 */
+	if (newlen == 0) {
+
+		/*
+		 * setup the empty buffer
+		 *
+		 * We know that newtype is not circular since we force
+		 * newlen to be at least 1 (because circular blocks
+		 * always have at least one unused octet).
+		 */
+		if (blk->datalen < blk->maxsize) {
+			memset(blk->data, 0, blk->datalen);
+		} else {
+			memset(blk->data, 0, blk->maxsize);
+		}
+		blk->datalen = 0;
+		if (conf->calc_debug & CALCDBG_BLOCK) {
+			blkchk(blk);
+		}
+		return blk;
+	}
+
+	/*
+	 * Set the data length
+	 *
+	 * We also know that the new block is not empty since we have
+	 * already dealth with that case above.
+	 *
+	 * After this section of code, limit and datalen will be
+	 * correct in terms of the new type.
+	 */
+	if (newlen > blk->datalen) {
+
+		/* there is new storage, clear it */
+		memset(blk->data + blk->datalen, 0, newlen-blk->datalen);
+		/* growing storage for blocks grows the data */
+		blk->datalen = newlen;
+
+	} else if (newlen <= blk->datalen) {
+
+		/* the block will be full */
+		blk->datalen = newlen;
+	}
+
+	/*
+	 * return realloced type
+	 */
+	if (conf->calc_debug & CALCDBG_BLOCK) {
+		blkchk(blk);
+	}
+	return blk;
+}
+
+
+/*
+ * blktrunc - truncate a BLOCK down to a minimal fixed block
+ *
+ * NOTE: THIS IS NOT THE INTERNAL CALC FREE FUNCTION!!	This
+ * is what blktrunc() builtin calls to reduce storage of a block
+ * down to an absolute minimum.
+ *
+ * This actually forms a zero length fixed block with a chunk of 1.
+ *
+ * given:
+ *	blk	- the BLOCK to shrink
+ *
+ * returns:
+ *	pointer to a newly allocated BLOCK
+ */
+void
+blktrunc(BLOCK *blk)
+{
+	/*
+	 * firewall
+	 */
+	if (conf->calc_debug & CALCDBG_BLOCK) {
+		blkchk(blk);
+	}
+
+	/*
+	 * free the old storage
+	 */
+	free(blk->data);
+
+	/*
+	 * setup as a zero length fixed block
+	 */
+	blk->blkchunk = 1;
+	blk->maxsize = 1;
+	blk->datalen = 0;
+	blk->data = (USB8*)malloc(1);
+	if (blk->data == NULL) {
+		math_error("cannot allocate truncated block storage");
+		/*NOTREACHED*/
+	}
+	blk->data[0] = (USB8)0;
+	if (conf->calc_debug & CALCDBG_BLOCK) {
+		blkchk(blk);
+	}
+	return;
+}
+
+
+/*
+ * blk_copy - copy a block
+ *
+ * given:
+ *	blk	- the block to copy
+ *
+ * returns:
+ *	pointer to copy of blk
+ */
+BLOCK *
+blk_copy(BLOCK *blk)
+{
+	BLOCK *nblk;		/* copy of blk */
+
+	/*
+	 * malloc new block
+	 */
+	nblk = (BLOCK *)malloc(sizeof(BLOCK));
+	if (nblk == NULL) {
+		math_error("blk_copy: cannot malloc BLOCK");
+		/*NOTREACHED*/
+	}
+
+	/*
+	 * duplicate most of the block
+	 */
+	*nblk = *blk;
+
+	/*
+	 * duplicate block data
+	 */
+	nblk->data = (USB8 *)malloc(blk->maxsize);
+	if (nblk->data == NULL) {
+		math_error("blk_copy: cannot duplicate block data");
+		/*NOTREACHED*/
+	}
+	memcpy(nblk->data, blk->data, blk->maxsize);
+	return nblk;
+}
+
+
+/*
+ * blk_cmp - compare blocks
+ *
+ * given:
+ *	a	first BLOCK
+ *	b	second BLOCK
+ *
+ * returns:
+ *	TRUE => BLOCKs are different
+ *	FALSE => BLOCKs are the same
+ */
+int
+blk_cmp(BLOCK *a, BLOCK *b)
+{
+	/*
+	 * firewall and quick check
+	 */
+	if (a == b) {
+		/* pointers to the same object */
+		return FALSE;
+	}
+	if (a == NULL || b == NULL) {
+		/* one pointer is NULL, so they differ */
+		return TRUE;
+	}
+
+	/*
+	 * compare lengths
+	 */
+	if (a->datalen != b->datalen) {
+		/* different lengths are different */
+		return TRUE;
+	}
+
+	/*
+	 * compare the section
+	 *
+	 * We have the same lengths and types, so compare the data sections.
+	 */
+	if (memcmp(a->data, b->data, a->datalen) != 0) {
+		/* different sections are different */
+		return TRUE;
+	}
+
+	/*
+	 * the blocks are the same
+	 */
+	return FALSE;
+}
+
+
+/*
+ * Print chunksize, maxsize, datalen on line line and if datalen > 0,
+ * up to * 30 octets on the following line, with ... if datalen exceeds 30.
+ */
+/*ARGSUSED*/
+void
+blk_print(BLOCK *blk)
+{
+	long i;
+	BOOL havetail;
+	USB8 *ptr;
+
+	/* XXX - should use the config parameters for better print control */
+
+	printf("chunksize = %d, maxsize = %d, datalen = %d\n\t",
+		(int)blk->blkchunk, (int)blk->maxsize, (int)blk->datalen);
+	i = blk->datalen;
+	havetail = (i > 30);
+	if (havetail)
+		i = 30;
+	ptr = blk->data;
+	while (i-- > 0)
+		printf("%02x", *ptr++);
+	if (havetail)
+		printf("...");
+}
+
+
+/*
+ * Routine to print id and name of a named block and details of its
+ * block component.
+ */
+void
+nblock_print(NBLOCK *nblk)
+{
+	BLOCK *blk;
+
+	/* XXX - use the config parameters for better print control */
+
+	blk = nblk->blk;
+	printf("block %d: %s\n\t", nblk->id, nblk->name);
+	if (blk->data == NULL) {
+		printf("chunksize = %d, maxsize = %d, datalen = %d\n\t",
+		(int)blk->blkchunk, (int)blk->maxsize, (int)blk->datalen);
+		printf("NULL");
+	} else {
+		blk_print(blk);
+	}
+}
+
+
+/*
+ * realloc a named block specified by its id.  The new datalen and
+ * chunksize are specified by len >= 0 and chunk > 0.  If len < 0
+ * or chunk <= 0, these values used are the current datalen and
+ * chunksize, so there is no point in calling this unless len >= 0
+ * and/or chunk > 0.
+ * No reallocation occurs if the new maxsize is equal to the old maxsize.
+ */
+NBLOCK *
+reallocnblock(int id, int len, int chunk)
+{
+	BLOCK *blk;
+	int newsize;
+	int oldsize;
+	USB8* newdata;
+
+	/* Fire wall */
+	if (id < 0 || id >= nblockcount) {
+		math_error("Bad id in call to reallocnblock");
+		/*NOTREACHED*/
+	}
+
+	blk = nblocks[id]->blk;
+	if (len < 0)
+		len = blk->datalen;
+	if (chunk < 0)
+		chunk = blk->blkchunk;
+	else if (chunk == 0)
+		chunk = BLK_CHUNKSIZE;
+	newsize = (1 + len/chunk) * chunk;
+	oldsize = blk->maxsize;
+	newdata = blk->data;
+	if (newdata == NULL) {
+		newdata = malloc(newsize);
+		if (newdata == NULL) {
+			math_error("Allocation failed");
+			/*NOTREACHED*/
+		}
+	} else if (newsize != oldsize) {
+		newdata = realloc(blk->data, newsize);
+		if (newdata == NULL) {
+			math_error("Reallocation failed");
+			/*NOTREACHED*/
+		}
+	}
+	memset(newdata + len, 0, newsize - len);
+
+	blk->maxsize = newsize;
+	blk->datalen = len;
+	blk->blkchunk = chunk;
+	blk->data = newdata;
+	return nblocks[id];
+}
+
+
+/*
+ * Create and return a new namedblock with specified name, len and
+ * chunksize.
+ */
+NBLOCK *
+createnblock(char *name, int len, int chunk)
+{
+	NBLOCK *res;
+	char *newname;
+
+	if (nblockcount >= maxnblockcount) {
+		if (maxnblockcount <= 0) {
+			maxnblockcount = NBLOCKCHUNK;
+			nblocks = (NBLOCK **)malloc(NBLOCKCHUNK *
+						    sizeof(NBLOCK *));
+			if (nblocks == NULL) {
+				maxnblockcount = 0;
+				math_error("unable to malloc new named blocks");
+				/*NOTREACHED*/
+			}
+		} else {
+			maxnblockcount += NBLOCKCHUNK;
+			nblocks = (NBLOCK **)realloc(nblocks, maxnblockcount *
+						     sizeof(NBLOCK *));
+			if (nblocks == NULL) {
+				maxnblockcount = 0;
+				math_error("cannot malloc more named blocks");
+				/*NOTREACHED*/
+			}
+		}
+	}
+	if (nblockcount == 0)
+		initstr(&nblocknames);
+	if (findstr(&nblocknames, name) >= 0) {
+		math_error("Named block already exists!!!");
+		/*NOTREACHED*/
+	}
+	newname = addstr(&nblocknames, name);
+	if (newname == NULL) {
+		math_error("Block name allocation failed");
+		/*NOTREACHED*/
+	}
+
+	res = (NBLOCK *) malloc(sizeof(NBLOCK));
+	if (res == NULL) {
+		math_error("Named block allocation failed");
+		/*NOTREACHED*/
+	}
+
+	nblocks[nblockcount] = res;
+	res->name = newname;
+	res->subtype = V_NOSUBTYPE;
+	res->id = nblockcount++;
+	res->blk = blkalloc(len, chunk);
+	return res;
+}
+
+
+/*
+ * find a named block
+ */
+int
+findnblockid(char * name)
+{
+	return findstr(&nblocknames, name);
+}
+
+
+/*
+ * free data block for named block with specified id
+ */
+int
+removenblock(int id)
+{
+	NBLOCK *nblk;
+
+	if (id < 0 || id >= nblockcount)
+		return E_BLKFREE3;
+	nblk = nblocks[id];
+	if (nblk->blk->data == NULL)
+		return 0;
+	if (nblk->subtype & V_NOREALLOC)
+		return E_BLKFREE5;
+	free(nblk->blk->data);
+	nblk->blk->data = NULL;
+	nblk->blk->maxsize = 0;
+	nblk->blk->datalen = 0;
+	return 0;
+}
+
+
+/*
+ * count number of current unfreed named blocks
+ */
+int
+countnblocks(void)
+{
+	int n;
+	int id;
+
+	for (n = 0, id = 0; id < nblockcount; id++) {
+		if (nblocks[id]->blk->data != NULL)
+			n++;
+	}
+	return n;
+}
+
+
+/*
+ * display id and name for each unfreed named block
+ */
+void
+shownblocks(void)
+{
+	int id;
+
+	if (countnblocks() == 0) {
+		printf("No unfreed named blocks\n\n");
+		return;
+	}
+	printf(" id   name\n");
+	printf("----  -----\n");
+	for (id = 0; id < nblockcount; id++) {
+		if (nblocks[id]->blk->data != NULL)
+			printf("%3d   %s\n", id, nblocks[id]->name);
+	}
+	printf("\n");
+}
+
+
+/*
+ * Return pointer to nblock with specified id, NULL if never created.
+ * The memory for the nblock found may have been freed.
+ */
+NBLOCK *
+findnblock(int id)
+{
+	if (id < 0 || id >= nblockcount)
+		return NULL;
+	return nblocks[id];
+}
+
+
+/*
+ * Create a new block with specified newlen and new chunksize and copy
+ * min(newlen, oldlen) octets to the new block.	 The old block is
+ * not changed.
+ */
+BLOCK *
+copyrealloc(BLOCK *blk, int newlen, int newchunk)
+{
+	BLOCK * newblk;
+	int oldlen;
+
+	oldlen = blk->datalen;
+
+	if (newlen < 0)			/* retain length */
+		newlen = oldlen;
+
+	if (newchunk < 0)		/* retain chunksize */
+		newchunk = blk->blkchunk;
+	else if (newchunk == 0)		/* use default chunksize */
+		newchunk = BLK_CHUNKSIZE;
+
+
+	newblk = blkalloc(newlen, newchunk);
+
+	if (newlen < oldlen)
+		oldlen = newlen;
+
+	if (newlen > 0)
+		memcpy(newblk->data, blk->data, oldlen);
+
+	return newblk;
+}

block.h

@@ -0,0 +1,225 @@
+/*
+ * block - fixed, dynamic, fifo and circular memory blocks
+ *
+ * Copyright (C) 1999-2007  Landon Curt Noll and Ernest Bowen
+ *
+ * Primary author:  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: block.h,v 30.1 2007/03/16 11:09:46 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/RCS/block.h,v $
+ *
+ * Under source code control:	1997/02/21 05:03:39
+ * File existed as early as:	1997
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+#if !defined(__BLOCK_H__)
+#define __BLOCK_H__
+
+
+/*
+ * block - the basic block structure
+ *
+ * A block comes is one of several types.  At the moment, only fixed
+ * types are defined.
+ *
+ ***
+ *
+ * Block functions and operations:
+ *
+ *	x[i]
+ *		(i-1)th octet
+ *
+ *	blk(len [, blkchunk])
+ *		unnamed block
+ *		len > 0
+ *		blkchunk defaults to BLK_CHUNKSIZE
+ *
+ *	blk(name, [len [, blkchunk]])
+ *		named block
+ *		len > 0
+ *		blkchunk defaults to BLK_CHUNKSIZE
+ *
+ *	blkfree(x)
+ *		Reduce storage down to 0 octetes.
+ *
+ *	size(x)
+ *		The length of data stored in the block.
+ *
+ *	sizeof(x) == blk->maxsize
+ *		Allocation size in memory
+ *
+ *	isblk(x)
+ *		returns 0 is x is not a BLOCK, 1 if x is an
+ *		unnamed block, 2 if x is a named BLOCK
+ *
+ *	blkread(x, size, count, fd [, offset])
+ *	blkwrite(x, size, count, fd [, offset])
+ *		returns number of items written
+ *		offset is restricted in value by block type
+ *
+ *	blkset(x, val, length [, offset])
+ *		only the lower octet of val is used
+ *		offset is restricted in value by block type
+ *
+ *	blkchr(x, val, length [, offset])
+ *		only the lower octet of val is used
+ *		offset is restricted in value by block type
+ *
+ *	blkcpy(dest, src, length [, dest_offset [, src_offset]])
+ *		0 <= length <= blksize(x)
+ *		offset's are restricted in value by block type
+ *		dest may not == src
+ *
+ *	blkmove(dest, src, length [, dest_offset [, src_offset]])
+ *		0 <= length <= blksize(x)
+ *		offset's are restricted in value by block type
+ *		overlapping moves are handeled correctly
+ *
+ *	blkccpy(dest, src, stopval, length [, dest_offset [, src_offset]])
+ *		0 <= length <= blksize(x)
+ *		offset's are restricted in value by block type
+ *
+ *	blkcmp(dest, src, length [, dest_offset [, src_offset]])
+ *		0 <= length <= blksize(x)
+ *		offset's are restricted in value by block type
+ *
+ *	blkswap(x, a, b)
+ *		swaps groups of 'a' octets within each 'b' octets
+ *		b == a is a noop
+ *		b = a*k for some integer k >= 1
+ *
+ *	scatter(src, dest1, dest2 [, dest3 ] ...)
+ *		copy sucessive octets from src into dest1, dest2, ...
+ *		    restarting with dest1 after end of list
+ *		stops at end of src
+ *
+ *	gather(dest, src1, src2 [, src3 ] ...)
+ *		copy first octet from src1, src2, ...
+ *		copy next octet from src1, src2, ...
+ *		...
+ *		copy last octet from src1, src2, ...
+ *		copy 0 when there is no more data from a given source
+ *
+ *	blkseek(x, offset, {"in","out"})
+ *		some seeks may not be allowed by block type
+ *
+ *	config("blkmaxprint", count)
+ *		number of octets of a block to print, 0 means all
+ *
+ *	config("blkverbose", boolean)
+ *		TRUE => print all lines, FALSE => skip dup lines
+ *
+ *	config("blkbase", "base")
+ *		output block base = { "hex", "octal", "char", "binary", "raw" }
+ *		    binary is base 2, raw is just octet values
+ *
+ *	config("blkfmt", "style")
+ *		style of output = {
+ *		    "line",	lines in blkbase with no spaces between octets
+ *		    "string",	as one long line with no spaces between octets
+ *		    "od_style", position, spaces between octets
+ *		    "hd_style"} position, spaces between octets, chars on end
+ */
+struct block {
+	LEN blkchunk;	/* allocation chunk size */
+	LEN maxsize;	/* octets actually malloced for this block */
+	LEN datalen;	/* octets of data held this block */
+	USB8 *data;	/* pointer to the 1st octet of the allocated data */
+};
+typedef struct block BLOCK;
+
+
+struct nblock {
+	char *name;
+	int subtype;
+	int id;
+	BLOCK *blk;
+};
+typedef struct nblock NBLOCK;
+
+
+/*
+ * block debug
+ */
+EXTERN int blk_debug;	/* 0 => debug off */
+
+
+/*
+ * block defaults
+ */
+#define BLK_CHUNKSIZE 256	/* default allocation chunk size for blocks */
+
+#define BLK_DEF_MAXPRINT 256	/* default octets to print */
+
+#define BLK_BASE_HEX 0		/* output octets in a block in hex */
+#define BLK_BASE_OCT 1		/* output octets in a block in octal */
+#define BLK_BASE_CHAR 2		/* output octets in a block in characters */
+#define BLK_BASE_BINARY 3	/* output octets in a block in base 2 chars */
+#define BLK_BASE_RAW 4		/* output octets in a block in raw binary */
+
+#define BLK_FMT_HD_STYLE 0	/* output in base with chars on end of line */
+#define BLK_FMT_LINE 1		/* output is lines of up to 79 chars */
+#define BLK_FMT_STRING 2	/* output is one long string */
+#define BLK_FMT_OD_STYLE 3	/* output in base with chars */
+
+
+/*
+ * block macros
+ */
+/* length of data stored in a block */
+#define blklen(blk) ((blk)->datalen)
+
+/* block footpint in memory */
+#define blksizeof(blk) ((blk)->maxsize)
+
+/* block allocation chunk size */
+#define blkchunk(blk) ((blk)->blkchunk)
+
+
+/*
+ * OCTET - what the INDEXADDR produces from a blk[offset]
+ */
+typedef USB8 OCTET;
+
+
+/*
+ * external functions
+ */
+E_FUNC BLOCK *blkalloc(int, int);
+E_FUNC void blk_free(BLOCK*);
+E_FUNC BLOCK *blkrealloc(BLOCK*, int, int);
+E_FUNC void blktrunc(BLOCK*);
+E_FUNC BLOCK *blk_copy(BLOCK*);
+E_FUNC int blk_cmp(BLOCK*, BLOCK*);
+E_FUNC void blk_print(BLOCK*);
+E_FUNC void nblock_print(NBLOCK *);
+E_FUNC NBLOCK *createnblock(char *, int, int);
+E_FUNC NBLOCK *reallocnblock(int, int, int);
+E_FUNC int removenblock(int);
+E_FUNC int findnblockid(char *);
+E_FUNC NBLOCK *findnblock(int);
+E_FUNC BLOCK *copyrealloc(BLOCK*, int, int);
+E_FUNC int countnblocks(void);
+E_FUNC void shownblocks(void);
+
+
+#endif /* !__BLOCK_H__ */

byteswap.c

@@ -1,25 +1,34 @@
 /*
- * Copyright (c) 1995 by Landon Curt Noll.  All Rights Reserved.
+ * byteswap - byte swapping routines
  *
- * Permission to use, copy, modify, and distribute this software and
+ * Copyright (C) 1999  Landon Curt Noll
- * its documentation for any purpose and without fee is hereby granted,
- * provided that the above copyright, this permission notice and text
- * this comment, and the disclaimer below appear in all of the following:
  *
- *	supporting documentation
+ * Calc is open software; you can redistribute it and/or modify it under
- *	source copies
+ * the terms of the version 2.1 of the GNU Lesser General Public License
- *	source works derived from this source
+ * as published by the Free Software Foundation.
- *	binaries derived from this source or from derived source
  *
- * LANDON CURT NOLL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * Calc is distributed in the hope that it will be useful, but WITHOUT
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * EVENT SHALL LANDON CURT NOLL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU Lesser General
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
+ * Public License for more details.
- * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *
- * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * A copy of version 2.1 of the GNU Lesser General Public License is
- * PERFORMANCE OF THIS SOFTWARE.
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: byteswap.c,v 30.1 2007/03/16 11:09:46 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/RCS/byteswap.c,v $
+ *
+ * Under source code control:	1995/10/11 04:44:01
+ * File existed as early as:	1995
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
 
+
 #include "cmath.h"
 #include "byteswap.h"
 
@@ -28,9 +37,9 @@
  * swap_b8_in_HALFs - swap 8 and if needed, 16 bits in an array of HALFs
  *
  * given:
- *      dest    - pointer to where the swapped src wil be put or
+ *	dest	- pointer to where the swapped src wil be put or
  *		  NULL to allocate the storage
- *	src     - pointer to a HALF array to swap
+ *	src	- pointer to a HALF array to swap
  *	len	- length of the src HALF array
  *
  * returns:
@@ -39,6 +48,7 @@
 HALF *
 swap_b8_in_HALFs(HALF *dest, HALF *src, LEN len)
 {
+	HALF *ret;
 	LEN i;
 
 	/*
@@ -47,6 +57,7 @@ swap_b8_in_HALFs(HALF *dest, HALF *src, LEN len)
 	if (dest == NULL) {
 		dest = alloc(len);
 	}
+	ret = dest;
 
 	/*
 	 * swap the array
@@ -58,7 +69,7 @@ swap_b8_in_HALFs(HALF *dest, HALF *src, LEN len)
 	/*
 	 * return the result
 	 */
-	return dest;
+	return ret;
 }
 
 
@@ -261,9 +272,9 @@ swap_b8_in_COMPLEX(COMPLEX *dest, COMPLEX *src, BOOL all)
  * swap_b16_in_HALFs - swap 16 bits in an array of HALFs
  *
  * given:
- *      dest    - pointer to where the swapped src wil be put or
+ *	dest	- pointer to where the swapped src wil be put or
  *		  NULL to allocate the storage
- *	src     - pointer to a HALF array to swap
+ *	src	- pointer to a HALF array to swap
  *	len	- length of the src HALF array
  *
  * returns:
@@ -272,6 +283,7 @@ swap_b8_in_COMPLEX(COMPLEX *dest, COMPLEX *src, BOOL all)
 HALF *
 swap_b16_in_HALFs(HALF *dest, HALF *src, LEN len)
 {
+	HALF *ret;
 	LEN i;
 
 	/*
@@ -280,6 +292,7 @@ swap_b16_in_HALFs(HALF *dest, HALF *src, LEN len)
 	if (dest == NULL) {
 		dest = alloc(len);
 	}
+	ret = dest;
 
 	/*
 	 * swap the array
@@ -291,7 +304,7 @@ swap_b16_in_HALFs(HALF *dest, HALF *src, LEN len)
 	/*
 	 * return the result
 	 */
-	return dest;
+	return ret;
 }
 
 

byteswap.h

@@ -1,29 +1,43 @@
 /*
- * Copyright (c) 1995 by Landon Curt Noll.  All Rights Reserved.
+ * byteswap - byte swapping macros
  *
- * Permission to use, copy, modify, and distribute this software and
+ * Copyright (C) 1999  Landon Curt Noll
- * its documentation for any purpose and without fee is hereby granted,
- * provided that the above copyright, this permission notice and text
- * this comment, and the disclaimer below appear in all of the following:
  *
- *	supporting documentation
+ * Calc is open software; you can redistribute it and/or modify it under
- *	source copies
+ * the terms of the version 2.1 of the GNU Lesser General Public License
- *	source works derived from this source
+ * as published by the Free Software Foundation.
- *	binaries derived from this source or from derived source
  *
- * LANDON CURT NOLL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * Calc is distributed in the hope that it will be useful, but WITHOUT
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * EVENT SHALL LANDON CURT NOLL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU Lesser General
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
+ * Public License for more details.
- * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *
- * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * A copy of version 2.1 of the GNU Lesser General Public License is
- * PERFORMANCE OF THIS SOFTWARE.
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: byteswap.h,v 30.1 2007/03/16 11:09:46 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/RCS/byteswap.h,v $
+ *
+ * Under source code control:	1995/10/11 04:44:01
+ * File existed as early as:	1995
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
 
-#if !defined(BYTESWAP_H)
-#define BYTESWAP_H
 
-#include "longbits.h"
+#if !defined(__BYTESWAP_H__)
+#define __BYTESWAP_H__
+
+
+#if defined(CALC_SRC)	/* if we are building from the calc source tree */
+# include "longbits.h"
+#else
+# include <calc/longbits.h>
+#endif
 
 
 /*
@@ -163,4 +177,5 @@
 
 #endif /* LONG_BITS == 64 */
 
-#endif /* !BYTESWAP_H */
+
+#endif /* !__BYTESWAP_H__ */

cal/Makefile

@@ -0,0 +1,324 @@
+#!/bin/make
+#
+# cal - makefile for calc standard resource files
+#
+# Copyright (C) 1999-2006  Landon Curt Noll
+#
+# Calc is open software; you can redistribute it and/or modify it under
+# the terms of the version 2.1 of the GNU Lesser General Public License
+# as published by the Free Software Foundation.
+#
+# Calc 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 Lesser General
+# Public License for more details.
+#
+# A copy of version 2.1 of the GNU Lesser General Public License is
+# distributed with calc under the filename COPYING-LGPL.  You should have
+# received a copy with calc; if not, write to Free Software Foundation, Inc.
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+# @(#) $Revision: 30.4 $
+# @(#) $Id: Makefile,v 30.4 2010/09/02 06:01:39 chongo Exp $
+# @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/Makefile,v $
+#
+# Under source code control:	1991/07/21 05:00:54
+# File existed as early as:	1991
+#
+# chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+# Share and enjoy!  :-) http://www.isthe.com/chongo/tech/comp/calc/
+#
+# calculator by David I. Bell with help/mods from others
+# Makefile by Landon Curt Noll
+
+# required vars
+#
+SHELL= /bin/sh
+
+####
+# Normally, the upper level makefile will set these values.  We provide
+# a default here just in case you want to build from this directory.
+####
+
+# Normally certain files depend on the Makefile.  If the Makefile is
+# changed, then certain steps should be redone.  If MAKE_FILE is
+# set to Makefile, then these files will depend on Makefile.  If
+# MAKE_FILE is empty, then they wont.
+#
+# If in doubt, set MAKE_FILE to Makefile
+#
+MAKE_FILE= Makefile
+
+# Controlling file makefile basename (without the path)
+#
+# This is the basename same of the makefile that may/does/will drive
+# this makefile.
+#
+# If in doubt, set TOP_MAKE_FILE to Makefile
+#
+TOP_MAKE_FILE= Makefile
+
+# Where the system include (.h) files are kept
+#
+# For DJGPP, select:
+#
+#	INCDIR= /dev/env/DJDIR/include
+#
+# If in doubt, set:
+#
+#	INCDIR= /usr/include
+#
+
+#INCDIR= /usr/local/include
+#INCDIR= /dev/env/DJDIR/include
+INCDIR= /usr/include
+
+# where to install calc realted things
+#
+# ${BINDIR}		where to install calc binary files
+# ${LIBDIR}		where calc link library (*.a) files are installed
+# ${CALC_SHAREDIR}	where to install calc help, .cal, startup, config files
+#
+# NOTE: The install rule prepends installation paths with ${T}, which
+#	by default is empty.  If ${T} is non-empty, then installation
+#	locations will be relative to the ${T} directory.
+#
+# For DJGPP, select:
+#
+#	BINDIR= /dev/env/DJDIR/bin
+#	LIBDIR= /dev/env/DJDIR/lib
+#	CALC_SHAREDIR= /dev/env/DJDIR/share/calc
+#
+# If in doubt, set:
+#
+#	BINDIR= /usr/bin
+#	LIBDIR= /usr/lib
+#	CALC_SHAREDIR= /usr/share/calc
+#
+#BINDIR= /usr/local/bin
+#BINDIR= /dev/env/DJDIR/bin
+BINDIR= /usr/bin
+
+#LIBDIR= /usr/local/lib
+#LIBDIR= /dev/env/DJDIR/lib
+LIBDIR= /usr/lib
+
+#CALC_SHAREDIR= /usr/local/lib/calc
+#CALC_SHAREDIR= /dev/env/DJDIR/share/calc
+CALC_SHAREDIR= /usr/share/calc
+
+# By default, these values are based CALC_SHAREDIR, INCDIR, BINDIR
+# ---------------------------------------------------------------
+# ${HELPDIR}		where the help directory is installed
+# ${CALC_INCDIR}	where the calc include files are installed
+# ${SCRIPTDIR}		where calc shell scripts are installed
+#
+# NOTE: The install rule prepends installation paths with ${T}, which
+#	by default is empty.  If ${T} is non-empty, then installation
+#	locations will be relative to the ${T} directory.
+#
+# If in doubt, set:
+#
+#	HELPDIR= ${CALC_SHAREDIR}/help
+#	CALC_INCDIR= ${INCDIR}/calc
+#	SCRIPTDIR= ${BINDIR}/cscript
+#
+HELPDIR= ${CALC_SHAREDIR}/help
+CALC_INCDIR= ${INCDIR}/calc
+SCRIPTDIR= ${BINDIR}/cscript
+
+# T - top level directory under which calc will be installed
+#
+# The calc install is performed under ${T}, the calc build is
+# performed under /.	The purpose for ${T} is to allow someone
+# to install calc somewhere other than into the system area.
+#
+# For example, if:
+#
+#     BINDIR= /usr/bin
+#     LIBDIR= /usr/lib
+#     CALC_SHAREDIR= /usr/share/calc
+#
+# and if:
+#
+#     T= /var/tmp/testing
+#
+# Then the installation locations will be:
+#
+#     calc binary files:	/var/tmp/testing/usr/bin
+#     calc link library:	/var/tmp/testing/usr/lib
+#     calc help, .cal ...:	/var/tmp/testing/usr/share/calc
+#     ... etc ...		/var/tmp/testing/...
+#
+# If ${T} is empty, calc is installed under /, which is the same
+# top of tree for which it was built.  If ${T} is non-empty, then
+# calc is installed under ${T}, as if one had to chroot under
+# ${T} for calc to operate.
+#
+# If in doubt, use T=
+#
+T=
+
+# Makefile debug
+#
+# Q=@	do not echo internal makefile actions (quiet mode)
+# Q=	echo internal makefile actions (debug / verbose mode)
+#
+#Q=
+Q=@
+
+# standard tools
+#
+CHMOD= chmod
+CMP= cmp
+RM= rm
+MKDIR= mkdir
+RMDIR= rmdir
+CP= cp
+MV= mv
+CO= co
+TRUE= true
+TOUCH= touch
+
+# The calc files to install
+#
+CALC_FILES= README bigprime.cal deg.cal ellip.cal lucas.cal lucas_chk.cal \
+	lucas_tbl.cal mersenne.cal mod.cal pell.cal pi.cal pix.cal \
+	pollard.cal poly.cal psqrt.cal quat.cal regress.cal solve.cal \
+	sumsq.cal surd.cal unitfrac.cal varargs.cal chrem.cal mfactor.cal \
+	bindings randmprime.cal test1700.cal randrun.cal linear.cal \
+	randbitrun.cal bernoulli.cal test2300.cal test2600.cal \
+	test2700.cal test3100.cal test3300.cal test3400.cal prompt.cal \
+	test3500.cal seedrandom.cal test4000.cal test4100.cal test4600.cal \
+	beer.cal hello.cal test5100.cal test5200.cal randombitrun.cal \
+	randomrun.cal repeat.cal xx_print.cal natnumset.cal qtime.cal \
+	test8400.cal test8500.cal test8600.cal chi.cal intfile.cal screen.cal \
+	dotest.cal set8700.cal set8700.line alg_config.cal sumtimes.cal \
+	dms.cal hms.cal
+
+# These files are found (but not built) in the distribution
+#
+DISTLIST= ${CALC_FILES} ${MAKE_FILE}
+
+# These files are used to make (but not built) a calc .a link library
+#
+CALCLIBLIST=
+
+all: ${CALC_FILES} ${MAKE_FILE} .all
+
+# used by the upper level Makefile to determine of we have done all
+#
+.all:
+	${RM} -f .all
+	${TOUCH} .all
+
+##
+#
+# File list generation.	 You can ignore this section.
+#
+#
+# We will form the names of source files as if they were in a
+# sub-directory called calc/cal.
+#
+# NOTE: Due to bogus shells found on one common system we must have
+#	an non-emoty else clause for every if condition.  *sigh*
+#
+##
+
+distlist: ${DISTLIST}
+	${Q} for i in ${DISTLIST} /dev/null; do \
+	    if [ X"$$i" != X"/dev/null" ]; then \
+		echo cal/$$i; \
+	    fi; \
+	done
+
+distdir:
+	${Q} echo cal
+
+calcliblist:
+	${Q} for i in ${CALCLIBLIST} /dev/null; do \
+	    if [ X"$$i" != X"/dev/null" ]; then \
+		echo cal/$$i; \
+	    fi; \
+	done
+
+##
+#
+# rpm rules
+#
+##
+
+echo_inst_files:
+	${Q} for i in ${CALC_FILES} /dev/null; do \
+	    if [ X"$$i" != X"/dev/null" ]; then \
+		echo __file__ ${CALC_SHAREDIR}/$$i; \
+	    fi; \
+	done
+
+##
+#
+# Utility rules
+#
+##
+
+clean:
+
+clobber: clean
+	${RM} -f .all
+
+# install everything
+#
+# NOTE: Keep the uninstall rule in reverse order to the install rule
+#
+install: all
+	-${Q} if [ ! -d ${T}${CALC_SHAREDIR} ]; then \
+	    echo ${MKDIR} ${T}${CALC_SHAREDIR}; \
+	    ${MKDIR} ${T}${CALC_SHAREDIR}; \
+	    if [ ! -d "${T}${CALC_SHAREDIR}" ]; then \
+		echo ${MKDIR} -p "${T}${CALC_SHAREDIR}"; \
+		${MKDIR} -p "${T}${CALC_SHAREDIR}"; \
+	    fi; \
+	    echo ${CHMOD} 0755 ${T}${CALC_SHAREDIR}; \
+	    ${CHMOD} 0755 ${T}${CALC_SHAREDIR}; \
+	else \
+	    ${TRUE}; \
+	fi
+	${Q} for i in ${CALC_FILES} /dev/null; do \
+	    if [ "$$i" = "/dev/null" ]; then \
+		continue; \
+	    fi; \
+	    if ${CMP} -s $$i ${T}${CALC_SHAREDIR}/$$i; then \
+		${TRUE}; \
+	    else \
+		${RM} -f ${T}${CALC_SHAREDIR}/$$i.new; \
+		${CP} -f $$i ${T}${CALC_SHAREDIR}/$$i.new; \
+		${CHMOD} 0444 ${T}${CALC_SHAREDIR}/$$i.new; \
+		${MV} -f ${T}${CALC_SHAREDIR}/$$i.new ${T}${CALC_SHAREDIR}/$$i; \
+		echo "installed ${T}${CALC_SHAREDIR}/$$i"; \
+	    fi; \
+	done
+
+# Try to remove everything that was installed
+#
+# NOTE: Keep the uninstall rule in reverse order to the install rule
+#
+uninstall:
+	-${Q} for i in ${CALC_FILES} /dev/null; do \
+	    if [ "$$i" = "/dev/null" ]; then \
+		continue; \
+	    fi; \
+	    if [ -f "${T}${CALC_SHAREDIR}/$$i" ]; then \
+	    	${RM} -f "${T}${CALC_SHAREDIR}/$$i"; \
+		if [ -f "${T}${CALC_SHAREDIR}/$$i" ]; then \
+		   echo "cannot uninstall ${T}${CALC_SHAREDIR}/$$i"; \
+		else \
+		   echo "uninstalled ${T}${CALC_SHAREDIR}/$$i"; \
+		fi; \
+	    fi; \
+	done
+	-${Q} for i in ${CALC_SHAREDIR}; do \
+	    if [ -d "${T}$$i" ]; then \
+		${RMDIR} "${T}$$i" 2>/dev/null; \
+		echo "cleaned up ${T}$$i"; \
+	    fi; \
+	done

cal/beer.cal

@@ -0,0 +1,50 @@
+/*
+ * beer - 99 bottles of beer
+ *
+ * Copyright (C) 1999  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: beer.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/beer.cal,v $
+ *
+ * Under source code control:	1996/11/13 13:21:05
+ * File existed as early as:	1996
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * See: http://www.ionet.net/~timtroyr/funhouse/beer.html#calc
+ */
+
+
+for (i=99; i > 0;) {
+	/* current wall state */
+	some_bottles = (i != 1) ? "bottles" : "bottle";
+	print i, some_bottles, "of beer on the wall,",;
+	print i, some_bottles, "of beer!";
+
+	/* glug, glug */
+	--i;
+	print "Take one down and pass it around,",;
+
+	/* new wall state */
+	less = (i > 0) ? i : "no";
+	bottles = (i!=1) ? "bottles" : "bottle";
+	print less, bottles, "of beer on the wall!\n";
+}

cal/bernoulli.cal

@@ -0,0 +1,97 @@
+/*
+ * bernoulli - clculate the Nth Bernoulli number B(n)
+ *
+ * Copyright (C) 2000  David I. Bell and Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: bernoulli.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/bernoulli.cal,v $
+ *
+ * Under source code control:	1991/09/30 11:18:41
+ * File existed as early as:	1991
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * Calculate the Nth Bernoulli number B(n).
+ *
+ * NOTE: This is now a bulitin function.
+ *
+ * The non-buildin code used the following symbolic formula to calculate B(n):
+ *
+ *	(b+1)^(n+1) - b^(n+1) = 0
+ *
+ * where b is a dummy value, and each power b^i gets replaced by B(i).
+ * For example, for n = 3:
+ *
+ *	(b+1)^4 - b^4 = 0
+ *	b^4 + 4*b^3 + 6*b^2 + 4*b + 1 - b^4 = 0
+ *	4*b^3 + 6*b^2 + 4*b + 1 = 0
+ *	4*B(3) + 6*B(2) + 4*B(1) + 1 = 0
+ *	B(3) = -(6*B(2) + 4*B(1) + 1) / 4
+ *
+ * The combinatorial factors in the expansion of the above formula are
+ * calculated interatively, and we use the fact that B(2i+1) = 0 if i > 0.
+ * Since all previous B(n)'s are needed to calculate a particular B(n), all
+ * values obtained are saved in an array for ease in repeated calculations.
+ */
+
+
+/*
+static Bnmax;
+static mat Bn[1001];
+*/
+
+define B(n)
+{
+/*
+	local	nn, np1, i, sum, mulval, divval, combval;
+
+	if (!isint(n) || (n < 0))
+		quit "Non-negative integer required for Bernoulli";
+
+	if (n == 0)
+		return 1;
+	if (n == 1)
+		return -1/2;
+	if (isodd(n))
+		return 0;
+	if (n > 1000)
+		quit "Very large Bernoulli";
+
+	if (n <= Bnmax)
+		return Bn[n];
+
+	for (nn = Bnmax + 2; nn <= n; nn+=2) {
+		np1 = nn + 1;
+		mulval = np1;
+		divval = 1;
+		combval = 1;
+		sum = 1 - np1 / 2;
+		for (i = 2; i < np1; i+=2) {
+			combval = combval * mulval-- / divval++;
+			combval = combval * mulval-- / divval++;
+			sum += combval * Bn[i];
+		}
+		Bn[nn] = -sum / np1;
+	}
+	Bnmax = n;
+	return Bn[n];
+*/
+	return bernoulli(n);
+}

cal/bigprime.cal

@@ -0,0 +1,49 @@
+/*
+ * bigprime - a prime test, base a, on p*2^x+1 for even x>m
+ *
+ * Copyright (C) 1999  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: bigprime.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/bigprime.cal,v $
+ *
+ * Under source code control:	1991/05/22 21:56:32
+ * File existed as early as:	1991
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+define bigprime(a, m, p)
+{
+	local n1, n;
+
+	n1 = 2^m * p;
+	for (;;) {
+		m++;
+		n1 += n1;
+		n = n1 + 1;
+		if (isodd(m))
+			continue;
+		print m;
+		if (pmod(a, n1 / 2, n) != n1)
+			continue;
+		if (pmod(a, n1 / p, n) == 1)
+			continue;
+		print " " : n;
+	}
+}

cal/bindings

@@ -0,0 +1,75 @@
+# bindings - default key bindings for calc line editing functions
+#
+# Copyright (C) 1999  David I. Bell
+#
+# Calc is open software; you can redistribute it and/or modify it under
+# the terms of the version 2.1 of the GNU Lesser General Public License
+# as published by the Free Software Foundation.
+#
+# Calc 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 Lesser General
+# Public License for more details.
+#
+# A copy of version 2.1 of the GNU Lesser General Public License is
+# distributed with calc under the filename COPYING-LGPL.  You should have
+# received a copy with calc; if not, write to Free Software Foundation, Inc.
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+# @(#) $Revision: 30.1 $
+# @(#) $Id: bindings,v 30.1 2007/03/16 11:09:54 chongo Exp $
+# @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/bindings,v $
+#
+# Under source code control:	1993/05/02 20:09:19
+# File existed as early as:	1993
+#
+# Share and enjoy!  :-) http://www.isthe.com/chongo/tech/comp/calc/
+
+# NOTE: This facility is ignored if calc was compiled with GNU-readline.
+#	In that case, the standard readline mechanisms (see readline(3))
+#	are used in place of those found below.
+
+
+map	base-map
+default insert-char
+^@	set-mark
+^A	start-of-line
+^B	backward-char
+^D	delete-char
+^E	end-of-line
+^F	forward-char
+^H	backward-kill-char
+^J	new-line
+^K	kill-line
+^L	refresh-line
+^M	new-line
+^N	forward-history
+^O	save-line
+^P	backward-history
+^R	reverse-search
+^T	swap-chars
+^U	flush-input
+^V	quote-char
+^W	kill-region
+^Y	yank
+^?	backward-kill-char
+^[	ignore-char	esc-map
+
+map	esc-map
+default ignore-char	base-map
+G	start-of-line
+H	backward-history
+P	forward-history
+K	backward-char
+M	forward-char
+O	end-of-line
+S	delete-char
+g	goto-line
+s	backward-word
+t	forward-word
+d	forward-kill-word
+u	uppercase-word
+l	lowercase-word
+h	list-history
+^[	flush-input
+[	arrow-key

cal/chi.cal

@@ -0,0 +1,251 @@
+/*
+ * chi - chi^2 probabilities with degrees of freedom for null hypothesis
+ *
+ * Copyright (C) 2001  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: chi.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/chi.cal,v $
+ *
+ * Under source code control:	2001/03/27 14:10:11
+ * File existed as early as:	2001
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+/*
+ * Z(x)
+ *
+ * From Handbook of Mathematical Functions
+ *	10th printing, Dec 1972 with corrections
+ *	National Bureau of Standards
+ *
+ * Section 26.2.1, p931.
+ */
+define Z(x, eps_term)
+{
+    local eps;		/* error term */
+
+    /* obtain the error term */
+    if (isnull(eps_term)) {
+    	eps = epsilon();
+    } else {
+	eps = eps_term;
+    }
+
+    /* compute Z(x) value */
+    return exp(-x*x/2, eps) / sqrt(2*pi(eps), eps);
+}
+
+
+/*
+ * P(x[, eps]) asymtotic P(x) expansion for x>0 to an given epsilon error term
+ *
+ * NOTE: If eps is omitted, the stored epsilon value is used.
+ *
+ * From Handbook of Mathematical Functions
+ *	10th printing, Dec 1972 with corrections
+ *	National Bureau of Standards
+ *
+ * 26.2.11, p932:
+ *
+ *	P(x) = 1/2 + Z(x) * sum(n=0; n < infinity){x^(2*n+1)/(1*3*5*...(2*n+1)};
+ *
+ * We continue the fraction until it is less than epsilon error term.
+ *
+ * Also note 26.2.5:
+ *
+ *	P(x) + Q(x) = 1
+ */
+define P(x, eps_term)
+{
+    local eps;		/* error term */
+    local s;		/* sum */
+    local x2;		/* x^2 */
+    local x_term;	/* x^(2*r+1) */
+    local odd_prod;	/* 1*3*5* ... */
+    local odd_term;	/* next odd value to multiply into odd_prod */
+    local term;		/* the recent term added to the sum */
+
+    /* obtain the error term */
+    if (isnull(eps_term)) {
+    	eps = epsilon();
+    } else {
+	eps = eps_term;
+    }
+
+    /* firewall */
+    if (x <= 0) {
+	if (x == 0) {
+	    return 0;	/* hack */
+	} else {
+	    quit "Q(x[,eps]) 1st argument must be >= 0";
+	}
+    }
+    if (eps <= 0) {
+	quit "Q(x[,eps]) 2nd argument must be > 0";
+    }
+
+    /*
+     * aproximate sum(n=0; n < infinity){x^(2*n+1)/(1*3*5*...(2*n+1)}
+     */
+    x2 = x*x;
+    x_term = x;
+    s = x_term;	/* 1st term */
+    odd_term = 1;
+    odd_prod = 1;
+    do {
+
+	/* compute the term */
+	odd_term += 2;
+	odd_prod *= odd_term;
+	x_term *= x2;
+	term = x_term / odd_prod;
+	s += term;
+
+    } while (term >= eps);
+
+    /* apply term and factor */
+    return 0.5 + Z(x,eps)*s;
+}
+
+
+/*
+ * chi_prob(chi_sq, v[, eps]) -  Prob of >= chi^2 with v degrees of freedom
+ *
+ *    Computes the Probability, given the Null Hypothesis, that a given
+ *    Chi squared values >= chi_sq with v degrees of freedom.
+ *
+ *    The chi_prob() function does not work well with odd degrees of freedom.
+ *    It is reasonable with even degrees of freedom, although one must give
+ *    a sifficently small error term as the degress gets large (>100).
+ *
+ * NOTE: This function does not work well with odd degrees of freedom.
+ *	 Can somebody help / find a bug / provide a better method of
+ *	 this odd degrees of freedom case?
+ *
+ * NOTE: This function works well with even degrees of freedom.  However
+ *	 when the even degrees gets large (say, as you approach 100), you
+ *	 need to increase your error term.
+ *
+ * From Handbook of Mathematical Functions
+ *	10th printing, Dec 1972 with corrections
+ *	National Bureau of Standards
+ *
+ * Section 26.4.4, p941:
+ *
+ *   For odd v:
+ *
+ *	Q(chi_sq, v) = 2*Q(chi) + 2*Z(chi) * (
+ *		     sum(r=1, r<=(r-1)/2) {(chi_sq^r/chi) / (1*3*5*...(2*r-1)});
+ *
+ *	chi = sqrt(chi_sq)
+ *
+ *	NOTE: Q(x) = 1-P(x)
+ *
+ * Section 26.4.5, p941.
+ *
+ *   For even v:
+ *
+ *	Q(chi_sq, v) = sqrt(2*pi()) * Z(chi) * ( 1 +
+ *		       sum(r=1, r=((v-2)/2)) { chi_sq^r / (2*4*...*(2r)) } );
+ *
+ *	chi = sqrt(chi_sq)
+ *
+ * Observe that:
+ *
+ *	Z(x) = exp(-x*x/2) / sqrt(2*pi());	(Section 26.2.1, p931)
+ *
+ * and thus:
+ *
+ *	sqrt(2*pi()) * Z(chi) =
+ *	sqrt(2*pi()) * Z(sqrt(chi_sq)) =
+ *	sqrt(2*pi()) * exp(-sqrt(chi_sq)*sqrt(chi_sq)/2) / sqrt(2*pi()) =
+ *	exp(-sqrt(chi_sq)*sqrt(chi_sq)/2) =
+ *	exp(-sqrt(-chi_sq/2)
+ *
+ * So:
+ *
+ *	Q(chi_sq, v) = exp(-sqrt(-chi_sq/2) * ( 1 + sum(....){...} );
+ */
+define chi_prob(chi_sq, v, eps_term)
+{
+    local eps;		/* error term */
+    local r;		/* index in finite sum */
+    local r_lim;	/* limit value for r */
+    local s;		/* sum */
+    local d;		/* demoninator (2*4*6*... or 1*3*5...) */
+    local chi_term;	/* chi_sq^r */
+    local ret;		/* return value */
+
+    /* obtain the error term */
+    if (isnull(eps_term)) {
+	eps = epsilon();
+    } else {
+	eps = eps_term;
+    }
+
+    /*
+     * odd degrees of freedom
+     */
+    if (isodd(v)) {
+
+	local chi;		/* sqrt(chi_sq) */
+
+	/* setup for sum */
+	s = 1;
+	d = 1;
+	chi = sqrt(abs(chi_sq), eps);
+	chi_term = chi;
+	r_lim = (v-1)/2;
+
+	/* compute sum(r=1, r=((v-1)/2)) {(chi_sq^r/chi) / (1*3*5...*(2r-1))} */
+	for (r=2; r <= r_lim; ++r) {
+	    chi_term *= chi_sq;
+	    d *= (2*r)-1;
+	    s += chi_term/d;
+	}
+
+	/* apply term and factor, Q(x) = 1-P(x) */
+	ret = 2*(1-P(chi)) + 2*Z(chi)*s;
+
+    /*
+     * even degrees of freedom
+     */
+    } else {
+
+	/* setup for sum */
+	s =1;
+	d = 1;
+	chi_term = 1;
+	r_lim = (v-2)/2;
+
+	/* compute sum(r=1, r=((v-2)/2)) { chi_sq^r / (2*4*...*(2r)) } */
+	for (r=1; r <= r_lim; ++r) {
+	    chi_term *= chi_sq;
+	    d *= r*2;
+	    s += chi_term/d;
+	}
+
+	/* apply factor - see observation in the main comment above */
+	ret = exp(-chi_sq/2, eps) * s;
+    }
+
+    return ret;
+}

cal/chrem.cal

@@ -1,6 +1,35 @@
 /*
- * chrem - Chinese remainder theorem/problem solver
+ * chrem - chinese remainder theorem/problem solver
  *
+ * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
+ *
+ * Primary author:  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: chrem.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/chrem.cal,v $
+ *
+ * Under source code control:	1992/09/26 01:00:47
+ * File existed as early as:	1992
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
  * When possible, chrem finds solutions for x of a set of congruences
  * of the form:
  *
@@ -11,16 +40,16 @@
  * where the residues r1, r2, ... and the moduli m1, m2, ... are
  * given integers.  The Chinese remainder theorem states that if
  * m1, m2, ... are relatively prime in pairs, the above congruences
- * have a unique solution modulo  m1 * m2 * ...   If m1, m2, ...
+ * have a unique solution modulo  m1 * m2 * ...	  If m1, m2, ...
  * are not relatively prime in pairs, it is possible that no solution
  * exists.  If solutions exist, the general solution is expressible as:
  *
- *                   x = r (mod m)
+ *		     x = r (mod m)
  *
- * where m = lcm(m1,m2,...), and if m > 0, 0 <= r < m.  This
+ * where m = lcm(m1,m2,...), and if m > 0, 0 <= r < m.	This
  * solution may be interpreted as:
  *
- *                  x = r + k * m			[[NOTE 1]]
+ *		    x = r + k * m			[[NOTE 1]]
  *
  * where k is an arbitrary integer.
  *
@@ -30,15 +59,15 @@
  *
  *	chrem(r1,m1 [,r2,m2, ...])
  *
- * 	    r1, r2, ...  	remainder integers or null values
+ *	    r1, r2, ...		remainder integers or null values
- * 	    m1, m2, ...  	moduli integers
+ *	    m1, m2, ...		moduli integers
  *
  *	chrem(r_list, [m_list])
  *
  *	    r_list	list (r1,r2, ...)
  *	    m_list	list (m1,m2, ...)
  *
- * 	    If m_list is omitted, then 'defaultmlist' is used.
+ *	    If m_list is omitted, then 'defaultmlist' is used.
  *	    This default list is a global value that may be changed
  *	    by the user.  Initially it is the first 8 primes.
  *
@@ -50,13 +79,13 @@
  *
  * The moduli may be any integers, not necessarily relatively prime in
  * pairs (as required for the Chinese remainder theorem).  Any moduli
- * may be zero;  x = r (mod 0) has the meaning of x = r.
+ * may be zero;	 x = r (mod 0) has the meaning of x = r.
  *
  * returns:
  *
  *    If args were integer pairs:
  *
- *    	  r		('r' is defined above, see [[NOTE 1]])
+ *	  r		('r' is defined above, see [[NOTE 1]])
  *
  *    If 1 or 2 list args were given:
  *
@@ -84,11 +113,9 @@
  *	    chrem(list(0,1,1,1,1,1),list(7,2,3,4,5,6)) ---> (301,420)
  *
  *	i.e., any value that is 301 mod 420.
- *
- * Written by: Ernest W Bowen <ernie@neumann.une.edu.au>
- * Interface by: Landon Curt Noll <chongo@toad.com>
  */
 
+
 static defaultmlist = list(2,3,5,7,11,13,17,19); /* The first eight primes */
 
 define chrem()
@@ -96,7 +123,7 @@ define chrem()
     local argc;		/* number of args given */
     local rlist;	/* reminder list - ri */
     local mlist;	/* modulus list - mi */
-    local list_args;  	/* true => args given are lists, not r1,m1, ... */
+    local list_args;	/* true => args given are lists, not r1,m1, ... */
     local m,z,r,y,d,t,x,u,i;
 
     /*
@@ -121,7 +148,7 @@ define chrem()
 	mlist = list();
 	for (i=1; i <= argc; i+=2) {
 	    push(rlist, param(i));
-            push(mlist, param(i+1));
+	    push(mlist, param(i+1));
 	}
     }
 
@@ -174,8 +201,7 @@ define chrem()
     }
 }
 
-global lib_debug;
+if (config("resource_debug") & 3) {
-if (lib_debug >= 0) {
     print "chrem(r1,m1 [,r2,m2 ...]) defined";
     print "chrem(rlist [,mlist]) defined";
 }

cal/deg.cal

@@ -0,0 +1,138 @@
+/*
+ * deg - calculate in degrees, minutes, and seconds
+ *
+ * Copyright (C) 1999  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.2 $
+ * @(#) $Id: deg.cal,v 30.2 2010/09/02 06:01:14 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/deg.cal,v $
+ *
+ * Under source code control:	1990/02/15 01:50:33
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+obj deg {deg, min, sec};
+
+define deg(deg, min, sec)
+{
+	local ans;
+
+	if (isnull(sec))
+		sec = 0;
+	if (isnull(min))
+		min = 0;
+	obj deg ans;
+	ans.deg = deg;
+	ans.min = min;
+	ans.sec = sec;
+	fixdeg(ans);
+	return ans;
+}
+
+
+define deg_add(a, b)
+{
+	local obj deg	ans;
+
+	ans.deg = 0;
+	ans.min = 0;
+	ans.sec = 0;
+	if (istype(a, ans)) {
+		ans.deg += a.deg;
+		ans.min += a.min;
+		ans.sec += a.sec;
+	} else
+		ans.deg += a;
+	if (istype(b, ans)) {
+		ans.deg += b.deg;
+		ans.min += b.min;
+		ans.sec += b.sec;
+	} else
+		ans.deg += b;
+	fixdeg(ans);
+	return ans;
+}
+
+
+define deg_neg(a)
+{
+	local obj deg	ans;
+
+	ans.deg = -a.deg;
+	ans.min = -a.min;
+	ans.sec = -a.sec;
+	return ans;
+}
+
+
+define deg_sub(a, b)
+{
+	return a - b;
+}
+
+
+define deg_mul(a, b)
+{
+	local obj deg	ans;
+
+	if (istype(a, ans) && istype(b, ans))
+		quit "Cannot multiply degrees together";
+	if (istype(a, ans)) {
+		ans.deg = a.deg * b;
+		ans.min = a.min * b;
+		ans.sec = a.sec * b;
+	} else {
+		ans.deg = b.deg * a;
+		ans.min = b.min * a;
+		ans.sec = b.sec * a;
+	}
+	fixdeg(ans);
+	return ans;
+}
+
+
+define deg_print(a)
+{
+	print a.deg : 'd' : a.min : 'm' : a.sec : 's' :;
+}
+
+
+define deg_abs(a)
+{
+	return a.deg + a.min / 60 + a.sec / 3600;
+}
+
+
+define fixdeg(a)
+{
+	a.min += frac(a.deg) * 60;
+	a.deg = int(a.deg);
+	a.sec += frac(a.min) * 60;
+	a.min = int(a.min);
+	a.min += a.sec // 60;
+	a.sec %= 60;
+	a.deg += a.min // 60;
+	a.min %= 60;
+	a.deg %= 360;
+}
+
+if (config("resource_debug") & 3) {
+    print "obj deg {deg, min, sec} defined";
+}

cal/dms.cal

@@ -0,0 +1,384 @@
+/*
+ * dms - calculate in degrees, minutes, and seconds (based on deg)
+ *
+ * Copyright (C) 1999,2010  David I. Bell and Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.2 $
+ * @(#) $Id: dms.cal,v 30.2 2010/09/02 06:14:16 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/dms.cal,v $
+ *
+ * Under source code control:	1990/02/15 01:50:33
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+obj dms {deg, min, sec};
+
+define dms(deg, min, sec)
+{
+    local obj dms ans;		/* return value */
+
+    /* default missing args to 0 */
+    if (isnull(sec)) {
+	sec = 0;
+    }
+    if (isnull(min)) {
+	min = 0;
+    }
+
+    /* load object */
+    ans.deg = deg;
+    ans.min = min;
+    ans.sec = sec;
+
+    /* return properly formed object */
+    ans = fixdms(ans);
+    return ans;
+}
+
+
+define dms_add(a, b)
+{
+    local obj dms ans;		/* return value */
+
+    /* initalize value to 1st arg */
+    if (istype(a, ans)) {
+	/* 1st arg is dms object, load it */
+	ans.deg = a.deg;
+	ans.min = a.min;
+	ans.sec = a.sec;
+    } else {
+	/* 1st arg is not dms, assume scalar degrees */
+	ans.deg = a;
+	ans.min = 0;
+	ans.sec = 0;
+    }
+
+    /* add value of 2nd arg */
+    if (istype(b, ans)) {
+	/* 2nd arg is dms object, add it */
+	ans.deg += b.deg;
+	ans.min += b.min;
+	ans.sec += b.sec;
+    } else {
+	/* 2nd arg is not dms, add scalar degrees */
+	ans.deg += b;
+    }
+
+    /* return normalized result */
+    ans = fixdms(ans);
+    return ans;
+}
+
+
+define dms_neg(a)
+{
+    local obj dms ans;		/* return value */
+
+    /* negate argument */
+    if (istype(a, ans)) {
+	/* 1st arg is dms object, load it */
+	ans.deg = -a.deg;
+	ans.min = -a.min;
+	ans.sec = -a.sec;
+    } else {
+	/* 2nd arg is not dms, negate scalar degrees */
+	ans.deg = -a;
+	ans.min = 0;
+	ans.sec = 0;
+    }
+
+    /* return normalized result */
+    ans = fixdms(ans);
+    return ans;
+}
+
+
+define dms_sub(a, b)
+{
+    local obj dms ans;		/* return value */
+
+    /* initalize value to 1st arg */
+    if (istype(a, ans)) {
+	/* 1st arg is dms object, load it */
+	ans.deg = a.deg;
+	ans.min = a.min;
+	ans.sec = a.sec;
+    } else {
+	/* 1st arg is not dms, assume scalar degrees */
+	ans.deg = a;
+	ans.min = 0;
+	ans.sec = 0;
+    }
+
+    /* subtract value of 2nd arg */
+    if (istype(b, ans)) {
+	/* 2nd arg is dms object, subtract it */
+	ans.deg -= b.deg;
+	ans.min -= b.min;
+	ans.sec -= b.sec;
+    } else {
+	/* 2nd arg is not dms, subtract scalar degrees */
+	ans.deg -= b;
+    }
+
+    /* return normalized result */
+    ans = fixdms(ans);
+    return ans;
+}
+
+
+define dms_mul(a, b)
+{
+    local obj dms ans;		/* return value */
+
+    /* dms object multiplication */
+    if (istype(a, ans) && istype(b, ans)) {
+	ans.deg = dms_abs(a) * dms_abs(b);
+	ans.min = 0;
+	ans.sec = 0;
+
+    /* scalar multiplication */
+    } else if (istype(a, ans)) {
+	ans.deg = a.deg * b;
+	ans.min = a.min * b;
+	ans.sec = a.sec * b;
+    } else {
+	ans.deg = b.deg * a;
+	ans.min = b.min * a;
+	ans.sec = b.sec * a;
+    }
+
+    /* return normalized result */
+    ans = fixdms(ans);
+    return ans;
+}
+
+
+define dms_print(a)
+{
+    local obj dms ans;		/* temp object for dms type testing */
+
+    /* firewall - arg must be a dms object */
+    if (! istype(a, ans)) {
+	quit "dms_print called with non dms object";
+    }
+
+    /* print in dms form */
+    print a.deg : 'd' : a.min : 'm' : a.sec : 's' :;
+}
+
+
+define dms_abs(a)
+{
+    local obj dms ans;		/* temp object for dms type testing */
+    local deg;			/* return scalar value */
+
+    /* firewall - just absolute value non dms objects */
+    if (! istype(a, ans)) {
+    	return abs(a);
+    }
+
+    /* compute degrees */
+    deg = a.deg + a.min / 60 + a.sec / 3600;
+
+    /* return degrees */
+    return deg;
+}
+
+
+define dms_norm(a)
+{
+    local obj dms ans;		/* temp object for dms type testing */
+    local deg;			/* degrees */
+
+    /* firewall - arg must be a dms object */
+    if (! istype(a, ans)) {
+	quit "dms_norm called with non dms object";
+    }
+
+    /* square degrees (norm is the square of absolute value */
+    deg = dms_abs(a);
+
+    /* return degrees */
+    return deg*deg;
+}
+
+
+define dms_test(a)
+{
+    local obj dms ans;		/* temp value */
+
+    /* firewall - arg must be a dms object */
+    if (! istype(a, ans)) {
+	quit "dms_test called with non dms object";
+    }
+
+    /* return false of non-zero */
+    ans = fixdms(a);
+    if (ans.deg == 0 && ans.min == 0 && ans.sec == 0) {
+	/* false */
+	return 0;
+    }
+    /* true */
+    return 1;
+}
+
+
+define dms_int(a)
+{
+    local obj dms ans;		/* return value */
+
+    /* firewall - arg must be a dms object */
+    if (! istype(a, ans)) {
+	quit "dms_int called with non dms object";
+    }
+
+    /* normalize the argument */
+    ans = fixdms(a);
+
+    /* truncate to the nearest second */
+    ans.sec = int(ans.sec);
+
+    /* return value to the nearest second */
+    return ans;
+}
+
+
+define dms_frac(a)
+{
+    local obj dms ans;		/* return value */
+
+    /* firewall - arg must be a dms object */
+    if (! istype(a, ans)) {
+	quit "dms_frac called with non dms object";
+    }
+
+    /* normalize the argument */
+    ans = fixdms(a);
+
+    /* remove all but fractional seconds */
+    ans.deg = 0;
+    ans.min = 0;
+    ans.sec = frac(ans.sec);
+
+    /* return value to the second fraction */
+    return ans;
+}
+
+
+define dms_rel(a,b)
+{
+    local abs_a, abs_b;		/* scalars of the arguments */
+
+    /* compute scalars of the arguments */
+    abs_a = dms_abs(a);
+    abs_b = dms_abs(b);
+
+    /* return the comparison */
+    return cmp(abs_a, abs_b);
+}
+
+
+define dms_cmp(a,b)
+{
+    local abs_a, abs_b;		/* scalars of the arguments */
+
+    /* compute scalars of the arguments */
+    abs_a = dms_abs(a);
+    abs_b = dms_abs(b);
+
+    /* return the equality comparison */
+    return (abs_a == abs_b);
+}
+
+
+define dms_inc(a)
+{
+    local obj dms ans;		/* return value */
+
+    /* increment a dms object */
+    if (istype(a, ans)) {
+	ans = a;
+	++ans.sec;
+
+	/* return normalized result */
+	ans = fixdms(ans);
+	return ans;
+    }
+
+    /* increment a scalar */
+    return a+1;
+}
+
+
+define dms_dec(a)
+{
+    local obj dms ans;		/* return value */
+
+    /* decrement a dms object */
+    if (istype(a, ans)) {
+	ans = a;
+	--ans.sec;
+
+	/* return normalized result */
+	ans = fixdms(ans);
+	return ans;
+    }
+
+    /* decrement a scalar */
+    return a-1;
+}
+
+
+define fixdms(a)
+{
+    local obj dms ans;		/* temp value */
+
+    /* firewall */
+    if (! istype(a, ans)) {
+	quit "attempt to fix a non dms object";
+    }
+
+    /* force minutes to be intergral */
+    a.min += frac(a.deg) * 60;
+    a.deg = int(a.deg);
+
+    /* force degrees to be intergral */
+    a.sec += frac(a.min) * 60;
+    a.min = int(a.min);
+
+    /* carry excess seconds into minutes */
+    a.min += a.sec // 60;
+    a.sec %= 60;
+
+    /* carry excess minutes into degrees */
+    a.deg += a.min // 60;
+    a.min %= 60;
+
+    /* round degrees :-) */
+    a.deg %= 360;
+
+    /* return normalized result */
+    return a;
+}
+
+if (config("resource_debug") & 3) {
+    print "obj dms {deg, min, sec} defined";
+}

cal/dotest.cal

@@ -0,0 +1,193 @@
+/*
+ * dotest - test truth statements found in line tests of dotest_testline file
+ *
+ * This file was created by Ernest Bowen <ebowen at une dot edu dot au>
+ * and modified by Landon Curt Noll.
+ *
+ * This dotest_code has been placed in the public domain.  Please do not
+ * copyright this dotest_code.
+ *
+ * ERNEST BOWEN AND LANDON CURT NOLL DISCLAIMS ALL WARRANTIES WITH REGARD TO
+ * THIS	 SOFTWARE,  INCLUDING  ALL IMPLIED WARRANTIES OF MER-
+ * CHANTABILITY AND FITNESS.  IN NO EVENT SHALL	 LANDON	 CURT
+ * NOLL	 BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM  LOSS  OF
+ * USE,	 DATA  OR  PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR  IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * @(#) $Revision: 30.2 $
+ * @(#) $Id: dotest.cal,v 30.2 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/dotest.cal,v $
+ *
+ * This file is not covered under version 2.1 of the GNU LGPL.
+ *
+ * Under source dotest_code control:	2006/03/08 05:54:09
+ * File existed as early as:	2006
+ */
+
+
+/*
+ * dotest - perform tests from dotest_testline file
+ *
+ * given:
+ *	dotest_file	filename containing single test lines
+ *	dotest_code	regress.cal test number to use (def: 0)
+ *	dotest_maxcond	max error conditions allowed (def: <0 ==> 2^31-1)
+ *
+ * returns:
+ *	number of line test failures
+ *
+ * NOTE: All variables used by the dotest() function start with "dotest_".
+ *	 The dotest_file and dotest_read should not use any variable
+ *	 that starts with "dotest_".
+ */
+define dotest(dotest_file, dotest_code = 0, dotest_maxcond = -1)
+{
+    local dotest_f_file;	/* open file containing test lines */
+    local dotest_testline;	/* test line */
+    local dotest_testeval;	/* eval value from dotest_testline test line */
+    local dotest_tmperrcnt;	/* temp error count after line test */
+    local dotest_errcnt;	/* total number of errors */
+    local dotest_failcnt;	/* number of line tests failed */
+    local dotest_testnum;	/* number of test lines evaluated */
+    local dotest_linenum;	/* test line number */
+    local dotest_old_errmax;	/* value of errmax() prior to calling */
+    local dotest_old_errcount;	/* value of errcount() prior to calling */
+
+    /*
+     * preserve calling stats
+     */
+    dotest_old_errmax = errmax();
+    dotest_old_errcount = errcount(0);
+
+    /*
+     * initialize test accounting
+     */
+    dotest_errcnt = errcount();
+    dotest_failcnt = 0;
+    dotest_testnum = 0;
+    dotest_linenum = 0;
+
+    /*
+     * setup error accounting for dotest
+     */
+    if (dotest_maxcond >= 0 && dotest_maxcond < 2147483647) {
+	    errmax(dotest_maxcond + dotest_old_errcount + 1),;
+    } else {
+	    errmax(2147483647),;
+    }
+
+    /*
+     * open the test line file
+     */
+    printf("%d-: opening line file: %d", dotest_code, dotest_file);
+    dotest_f_file = fpathopen(dotest_file, "r");
+    if (!isfile(dotest_f_file)) {
+	printf("**** Unable to file or open file \"%s\"\n",
+		dotest_file);
+	quit;
+    }
+    printf('%d: testing "%s"\n', dotest_code, dotest_file);
+
+    /*
+     * perform dotest_testline test on each line of the file
+     */
+    for (;;) {
+
+	/* get the next test line */
+	dotest_testline = fgets(dotest_f_file);
+	++dotest_linenum;
+	if (iserror(dotest_testline)) {
+	    quit "**** Error while reading file";
+	} else if (isnull(dotest_testline)) {
+	    /* EOF - end of test file */
+	    break;
+	}
+
+	/* skip empty lines */
+	if (dotest_testline == "\n") {
+	    continue;
+	}
+
+	/* evaluate the test line */
+	dotest_testeval = eval(dotest_testline);
+
+	/* ignore white space or comment lines */
+	if (isnull(dotest_testeval)) {
+	    continue;
+	}
+
+	/* look for test line parse errors */
+	if (iserror(dotest_testeval)) {
+	    printf("**** evaluation error: ");
+	    ++dotest_failcnt;
+
+	/* look for test line dotest_failcnt */
+	} else if (dotest_testeval != 1) {
+	    printf("**** did not return 1: ");
+	    ++dotest_failcnt;
+	}
+
+	/* show the test line we just performed */
+	printf("%d-%d: %s", dotest_code, dotest_linenum, dotest_testline);
+
+	/* error accounting */
+	dotest_tmperrcnt = errcount() - dotest_errcnt;
+	if (dotest_tmperrcnt > 0) {
+
+	    /* report any other errors */
+	    if (dotest_tmperrcnt > 1) {
+		printf("%d-%d: NOTE: %d error conditions(s): %s\n",
+		    dotest_code, dotest_linenum, dotest_tmperrcnt);
+	    }
+
+	    /* report the calc error string */
+	    printf("%d-%d: NOTE: last error string: %s\n",
+	        dotest_code, dotest_linenum, strerror());
+
+	    /* new error count level */
+	    dotest_errcnt = errcount();
+	    if (dotest_maxcond >= 0 &&
+	        dotest_old_errcount-dotest_errcnt > dotest_maxcond) {
+		printf("%d-%d: total error conditions: %d > %d\n",
+		       dotest_code, dotest_linenum,
+		       dotest_maxcond, dotest_old_errcount-dotest_errcnt);
+	    }
+	}
+    }
+
+    /*
+     * test the close of the line file
+     */
+    printf("%d-: detected %d error condition(s), many of which may be OK\n",
+    	   dotest_code, dotest_old_errcount-dotest_errcnt);
+    printf("%d-: closing line file: %d\n", dotest_code, dotest_file);
+    fclose(dotest_f_file);
+
+    /*
+     * test line file accounting
+     */
+    if (dotest_failcnt > 0) {
+	printf("**** %d-: %d test failure(s) in %d line(s)\n",
+	    dotest_code, dotest_failcnt, dotest_linenum);
+    } else {
+	printf("%d-: no failure(s) in %d line(s)\n",
+	    dotest_code, dotest_linenum);
+    }
+
+    /*
+     * preppare to return to the caller environment
+     *
+     * We increase the caller's error count by the number
+     * of line tests that failed, not the number of internal
+     * errors that were noted.
+     */
+    errmax(dotest_old_errmax),;
+    errcount(dotest_old_errcount + dotest_failcnt),;
+
+    /*
+     * All Done!!! -- Jessica Noll, Age 2
+     */
+    return dotest_failcnt;
+}

cal/ellip.cal

@@ -1,18 +1,44 @@
 /*
- * Copyright (c) 1995 David I. Bell
+ * ellip - attempt to factor numbers using elliptic functions
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * Attempt to factor numbers using elliptic functions.
+ * Copyright (C) 1999  David I. Bell
- * 	y^2 = x^3 + a*x + b   (mod N).
  *
- * Many points (x,y) (mod N) are found that solve the above equation,
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: ellip.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/ellip.cal,v $
+ *
+ * Under source code control:	1990/02/15 01:50:33
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * Attempt to factor numbers using elliptic functions:
+ *
+ *	y^2 = x^3 + a*x + b   (mod ellip_N).
+ *
+ * Many points (x,y) (mod ellip_N) are found that solve the above equation,
  * starting from a trivial solution and 'multiplying' that point together
  * to generate high powers of the point, looking for such a point whose
- * order contains a common factor with N.  The order of the group of points
+ * order contains a common factor with ellip_N.  The order of the group of
- * varies almost randomly within a certain interval for each choice of a
+ * points varies almost randomly within a certain interval for each choice of
- * and b, and thus each choice provides an independent opportunity to
+ * a and b, and thus each choice provides an independent opportunity to
- * factor N.  To generate a trivial solution, a is chosen and then b is
+ * factor ellip_N.  To generate a trivial solution, a is chosen and then b is
  * selected so that (1,1) is a solution.  The multiplication is done using
  * the basic fact that the equation is a cubic, and so if a line hits the
  * curve in two rational points, then the third intersection point must
@@ -20,11 +46,11 @@
  * the number of rational solutions can be made very large.  When modular
  * arithmetic is used, solving for the third point requires the taking of a
  * modular inverse (instead of division), and if this fails, then the GCD
- * of the failing value and N provides a factor of N.  This description is
+ * of the failing value and ellip_N provides a factor of ellip_N.
- * only an approximation, read "A Course in Number Theory and Cryptography"
+ * This description is only an approximation, read "A Course in Number
- * by Neal Koblitz for a good explanation.
+ * Theory and Cryptography" by Neal Koblitz for a good explanation.
  *
- * factor(iN, ia, B, force)
+ * efactor(iN, ia, B, force)
  *	iN is the number to be factored.
  *	ia is the initial value of a in the equation, and each successive
  *	value of a is an independent attempt at factoring (default 1).
@@ -55,18 +81,19 @@
  * of the powers so far.
  *
  * If a factor is found, it is returned and is also saved in the global
- * variable f.  The number being factored is also saved in the global
+ * variable f.	The number being factored is also saved in the global
- * variable N.
+ * variable ellip_N.
  */
 
+
 obj point {x, y};
-global	N;		/* number to factor */
+global	ellip_N;		/* number to factor */
-global	a;		/* first coefficient */
+global	ellip_a;		/* first coefficient */
-global	b;		/* second coefficient */
+global	ellip_b;		/* second coefficient */
-global	f;		/* found factor */
+global	ellip_f;		/* found factor */
 
 
-define factor(iN, ia, B, force)
+define efactor(iN, ia, B, force)
 {
 	local	C, x, p;
 
@@ -77,28 +104,28 @@ define factor(iN, ia, B, force)
 	if (isnull(ia))
 		ia = 1;
 	obj point x;
-	a = ia;
+	ellip_a = ia;
-	b = -ia;
+	ellip_b = -ia;
-	N = iN;
+	ellip_N = iN;
-	C = isqrt(N);
+	C = isqrt(ellip_N);
 	C = 2 * C + 2 * isqrt(C) + 1;
-	f = 0;
+	ellip_f = 0;
-	while (f == 0) {
+	while (ellip_f == 0) {
-		print "A =", a;
+		print "A =", ellip_a;
 		x.x = 1;
 		x.y = 1;
 		print 2, x;
 		x = x ^ (2 ^ (highbit(C) + 1));
-		for (p = 3; ((p < B) && (f == 0)); p += 2) {
+		for (p = 3; ((p < B) && (ellip_f == 0)); p += 2) {
 			if (!ptest(p, 1))
 				continue;
 			print p, x;
 			x = x ^ (p ^ ((highbit(C) // highbit(p)) + 1));
 		}
-		a++;
+		ellip_a++;
-		b--;
+		ellip_b--;
 	}
-	return f;
+	return ellip_f;
 }
 
 
@@ -115,18 +142,18 @@ define point_mul(p1, p2)
 	if (p2 == 1)
 		return p1;
 	if (p1 == p2)
-		return point_square(&p1);
+		return point_square(`p1);
 	obj point r;
-	m = (minv(p2.x - p1.x, N) * (p2.y - p1.y)) % N;
+	m = (minv(p2.x - p1.x, ellip_N) * (p2.y - p1.y)) % ellip_N;
 	if (m == 0) {
-		if (f == 0)
+		if (ellip_f == 0)
-			f = gcd(p2.x - p1.x, N);
+			ellip_f = gcd(p2.x - p1.x, ellip_N);
 		r.x = 1;
 		r.y = 1;
 		return r;
 	}
-	r.x = (m^2 - p1.x - p2.x) % N;
+	r.x = (m^2 - p1.x - p2.x) % ellip_N;
-	r.y = ((m * (p1.x - r.x)) - p1.y) % N;
+	r.y = ((m * (p1.x - r.x)) - p1.y) % ellip_N;
 	return r;
 }
 
@@ -136,16 +163,16 @@ define point_square(p)
 	local	r, m;
 
 	obj point r;
-	m = ((3 * p.x^2 + a) * minv(p.y << 1, N)) % N;
+	m = ((3 * p.x^2 + ellip_a) * minv(p.y << 1, ellip_N)) % ellip_N;
 	if (m == 0) {
-		if (f == 0)
+		if (ellip_f == 0)
-			f = gcd(p.y << 1, N);
+			ellip_f = gcd(p.y << 1, ellip_N);
 		r.x = 1;
 		r.y = 1;
 		return r;
 	}
-	r.x = (m^2 - p.x - p.x) % N;
+	r.x = (m^2 - p.x - p.x) % ellip_N;
-	r.y = ((m * (p.x - r.x)) - p.y) % N;
+	r.y = ((m * (p.x - r.x)) - p.y) % ellip_N;
 	return r;
 }
 
@@ -158,15 +185,10 @@ define point_pow(p, pow)
 	if (isodd(pow))
 		r = p;
 	t = p;
-	for (bit = 2; ((bit <= pow) && (f == 0)); bit <<= 1) {
+	for (bit = 2; ((bit <= pow) && (ellip_f == 0)); bit <<= 1) {
-		t = point_square(&t);
+		t = point_square(`t);
 		if (bit & pow)
-			r = point_mul(&t, &r);
+			r = point_mul(`t, `r);
 	}
 	return r;
 }
-
-global lib_debug;
-if (lib_debug >= 0) {
-    print "factor(N, I, B, force) defined";
-}

cal/hello.cal

@@ -0,0 +1,36 @@
+/*
+ * hello - print Hello World! forever
+ *
+ * Copyright (C) 1999  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: hello.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/hello.cal,v $
+ *
+ * Under source code control:	1996/11/13 13:25:43
+ * File existed as early as:	1996
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * See: http://www.latech.edu/~acm/helloworld/calc.html
+ */
+
+
+while(1) print "Hello World!";

cal/hms.cal

@@ -0,0 +1,384 @@
+/*
+ * hms - calculate in hours, minutes, and seconds
+ *
+ * Copyright (C) 2010  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.2 $
+ * @(#) $Id: hms.cal,v 30.2 2010/09/02 06:14:16 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/hms.cal,v $
+ *
+ * Under source code control:	2010/09/01 17:14:55
+ * File existed as early as:	2010
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+obj hms {hour, min, sec};
+
+define hms(hour, min, sec)
+{
+    local obj hms ans;		/* return value */
+
+    /* default missing args to 0 */
+    if (isnull(sec)) {
+	sec = 0;
+    }
+    if (isnull(min)) {
+	min = 0;
+    }
+
+    /* load object */
+    ans.hour = hour;
+    ans.min = min;
+    ans.sec = sec;
+
+    /* return properly formed object */
+    ans = fixhms(ans);
+    return ans;
+}
+
+
+define hms_add(a, b)
+{
+    local obj hms ans;		/* return value */
+
+    /* initalize value to 1st arg */
+    if (istype(a, ans)) {
+	/* 1st arg is hms object, load it */
+	ans.hour = a.hour;
+	ans.min = a.min;
+	ans.sec = a.sec;
+    } else {
+	/* 1st arg is not hms, assume scalar hours */
+	ans.hour = a;
+	ans.min = 0;
+	ans.sec = 0;
+    }
+
+    /* add value of 2nd arg */
+    if (istype(b, ans)) {
+	/* 2nd arg is hms object, add it */
+	ans.hour += b.hour;
+	ans.min += b.min;
+	ans.sec += b.sec;
+    } else {
+	/* 2nd arg is not hms, add scalar hours */
+	ans.hour += b;
+    }
+
+    /* return normalized result */
+    ans = fixhms(ans);
+    return ans;
+}
+
+
+define hms_neg(a)
+{
+    local obj hms ans;		/* return value */
+
+    /* negate argument */
+    if (istype(a, ans)) {
+	/* 1st arg is hms object, load it */
+	ans.hour = -a.hour;
+	ans.min = -a.min;
+	ans.sec = -a.sec;
+    } else {
+	/* 2nd arg is not hms, negate scalar hours */
+	ans.hour = -a;
+	ans.min = 0;
+	ans.sec = 0;
+    }
+
+    /* return normalized result */
+    ans = fixhms(ans);
+    return ans;
+}
+
+
+define hms_sub(a, b)
+{
+    local obj hms ans;		/* return value */
+
+    /* initalize value to 1st arg */
+    if (istype(a, ans)) {
+	/* 1st arg is hms object, load it */
+	ans.hour = a.hour;
+	ans.min = a.min;
+	ans.sec = a.sec;
+    } else {
+	/* 1st arg is not hms, assume scalar hours */
+	ans.hour = a;
+	ans.min = 0;
+	ans.sec = 0;
+    }
+
+    /* subtract value of 2nd arg */
+    if (istype(b, ans)) {
+	/* 2nd arg is hms object, subtract it */
+	ans.hour -= b.hour;
+	ans.min -= b.min;
+	ans.sec -= b.sec;
+    } else {
+	/* 2nd arg is not hms, subtract scalar hours */
+	ans.hour -= b;
+    }
+
+    /* return normalized result */
+    ans = fixhms(ans);
+    return ans;
+}
+
+
+define hms_mul(a, b)
+{
+    local obj hms ans;		/* return value */
+
+    /* hms object multiplication */
+    if (istype(a, ans) && istype(b, ans)) {
+	ans.hour = hms_abs(a) * hms_abs(b);
+	ans.min = 0;
+	ans.sec = 0;
+
+    /* scalar multiplication */
+    } else if (istype(a, ans)) {
+	ans.hour = a.hour * b;
+	ans.min = a.min * b;
+	ans.sec = a.sec * b;
+    } else {
+	ans.hour = b.hour * a;
+	ans.min = b.min * a;
+	ans.sec = b.sec * a;
+    }
+
+    /* return normalized result */
+    ans = fixhms(ans);
+    return ans;
+}
+
+
+define hms_print(a)
+{
+    local obj hms ans;		/* temp object for hms type testing */
+
+    /* firewall - arg must be a hms object */
+    if (! istype(a, ans)) {
+	quit "hms_print called with non hms object";
+    }
+
+    /* print in hms form */
+    print a.hour : ':' : a.min : ':' : a.sec :;
+}
+
+
+define hms_abs(a)
+{
+    local obj hms ans;		/* temp object for hms type testing */
+    local hour;			/* return scalar value */
+
+    /* firewall - just absolute value non hms objects */
+    if (! istype(a, ans)) {
+    	return abs(a);
+    }
+
+    /* compute hours */
+    hour = a.hour + a.min / 60 + a.sec / 3600;
+
+    /* return hours */
+    return hour;
+}
+
+
+define hms_norm(a)
+{
+    local obj hms ans;		/* temp object for hms type testing */
+    local hour;			/* hours */
+
+    /* firewall - arg must be a hms object */
+    if (! istype(a, ans)) {
+	quit "hms_norm called with non hms object";
+    }
+
+    /* square hours (norm is the square of absolute value */
+    hour = hms_abs(a);
+
+    /* return hours */
+    return hour*hour;
+}
+
+
+define hms_test(a)
+{
+    local obj hms ans;		/* temp value */
+
+    /* firewall - arg must be a hms object */
+    if (! istype(a, ans)) {
+	quit "hms_test called with non hms object";
+    }
+
+    /* return false of non-zero */
+    ans = fixhms(a);
+    if (ans.hour == 0 && ans.min == 0 && ans.sec == 0) {
+	/* false */
+	return 0;
+    }
+    /* true */
+    return 1;
+}
+
+
+define hms_int(a)
+{
+    local obj hms ans;		/* return value */
+
+    /* firewall - arg must be a hms object */
+    if (! istype(a, ans)) {
+	quit "hms_int called with non hms object";
+    }
+
+    /* normalize the argument */
+    ans = fixhms(a);
+
+    /* truncate to the nearest second */
+    ans.sec = int(ans.sec);
+
+    /* return value to the nearest second */
+    return ans;
+}
+
+
+define hms_frac(a)
+{
+    local obj hms ans;		/* return value */
+
+    /* firewall - arg must be a hms object */
+    if (! istype(a, ans)) {
+	quit "hms_frac called with non hms object";
+    }
+
+    /* normalize the argument */
+    ans = fixhms(a);
+
+    /* remove all but fractional seconds */
+    ans.hour = 0;
+    ans.min = 0;
+    ans.sec = frac(ans.sec);
+
+    /* return value to the second fraction */
+    return ans;
+}
+
+
+define hms_rel(a,b)
+{
+    local abs_a, abs_b;		/* scalars of the arguments */
+
+    /* compute scalars of the arguments */
+    abs_a = hms_abs(a);
+    abs_b = hms_abs(b);
+
+    /* return the comparison */
+    return cmp(abs_a, abs_b);
+}
+
+
+define hms_cmp(a,b)
+{
+    local abs_a, abs_b;		/* scalars of the arguments */
+
+    /* compute scalars of the arguments */
+    abs_a = hms_abs(a);
+    abs_b = hms_abs(b);
+
+    /* return the equality comparison */
+    return (abs_a == abs_b);
+}
+
+
+define hms_inc(a)
+{
+    local obj hms ans;		/* return value */
+
+    /* increment a hms object */
+    if (istype(a, ans)) {
+	ans = a;
+	++ans.sec;
+
+	/* return normalized result */
+	ans = fixhms(ans);
+	return ans;
+    }
+
+    /* increment a scalar */
+    return a+1;
+}
+
+
+define hms_dec(a)
+{
+    local obj hms ans;		/* return value */
+
+    /* decrement a hms object */
+    if (istype(a, ans)) {
+	ans = a;
+	--ans.sec;
+
+	/* return normalized result */
+	ans = fixhms(ans);
+	return ans;
+    }
+
+    /* decrement a scalar */
+    return a-1;
+}
+
+
+define fixhms(a)
+{
+    local obj hms ans;		/* temp value */
+
+    /* firewall */
+    if (! istype(a, ans)) {
+	quit "attempt to fix a non hms object";
+    }
+
+    /* force minutes to be intergral */
+    a.min += frac(a.hour) * 60;
+    a.hour = int(a.hour);
+
+    /* force hours to be intergral */
+    a.sec += frac(a.min) * 60;
+    a.min = int(a.min);
+
+    /* carry excess seconds into minutes */
+    a.min += a.sec // 60;
+    a.sec %= 60;
+
+    /* carry excess minutes into hours */
+    a.hour += a.min // 60;
+    a.min %= 60;
+
+    /* round hours by day */
+    a.hour %= 24;
+
+    /* return normalized result */
+    return a;
+}
+
+if (config("resource_debug") & 3) {
+    print "obj hms {hour, min, sec} defined";
+}

cal/intfile.cal

@@ -0,0 +1,222 @@
+/*
+ * intfile - integer to file and file to integer conversion
+ *
+ * Copyright (C) 2001  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: intfile.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/intfile.cal,v $
+ *
+ * Under source code control:   2001/03/31 08:13:11
+ * File existed as early as:    2001
+ *
+ * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+/*
+ * NOTE: Because leading HALF values are trimmed from integer, a file
+ *	 that begins with lots of 0 bits (in the case of big endian)
+ *	 or that ends with lots of 0 bits (in the case of little endian)
+ *	 will be changed when the subsequent integer is written back.
+ */
+
+
+/*
+ * file2be - convert a file into an big endian integer
+ *
+ * given:
+ *	filename	filename to read
+ *
+ * returns:
+ *	integer read from its contents on big endian order
+ */
+define file2be(filename)
+{
+    local fd;	/* open file */
+    local ret;	/* integer to return */
+    local c;	/* character read from the file */
+    local i;
+
+    /*
+     * open the file for reading
+     */
+    fd = fopen(filename, "rb");
+    if (!isfile(fd)) quit "file2be: cannot open file for reading";
+
+    /*
+     * read the contents of the file
+     *
+     * The first octets become the most significant bits of the integer.
+     */
+    ret = 0;
+    while (! isnull(c = fgetc(fd))) {
+	ret <<= 8;
+	ret += ord(c);
+    }
+
+    /*
+     * cleanup and return the integer
+     */
+    fclose(fd);
+    return ret;
+}
+
+
+/*
+ * file2le - convert a file into an little endian integer
+ *
+ * given:
+ *	filename	filename to read
+ *
+ * returns:
+ *	integer read from its contents on little endian order
+ */
+define file2le(filename)
+{
+    local fd;	/* open file */
+    local ret;	/* integer to return */
+    local c;	/* character read from the file */
+    local shft;	/* bit shift for the c value */
+    local i;
+
+    /*
+     * open the file for reading
+     */
+    fd = fopen(filename, "rb");
+    if (!isfile(fd)) quit "file2le: cannot open file for reading";
+
+    /*
+     * read the contents of the file into a string
+     *
+     * The first octets become are the least significant bits of the integer.
+     */
+    ret = 0;
+    shft = 0;
+    while (! isnull(c = fgetc(fd))) {
+	ret |= (ord(c) << shft);
+	shft += 8;
+    }
+
+    /*
+     * cleanup and return the integer
+     */
+    fclose(fd);
+    return ret;
+}
+
+
+/*
+ * be2file - convert a big endian integer into a file
+ *
+ * given:
+ *	v		integer to write to the file
+ *	filename	filename to write
+ *
+ * returns:
+ *	The number of octets written to the file.
+ *
+ * NOTE: The absolute value of the integer is written to the file.
+ */
+define be2file(v, filename)
+{
+    local fd;		/* open file */
+    local octlen;	/* length of v in octets */
+    local i;
+
+    /*
+     * firewall
+     */
+    if (!isint(v)) {
+	quit "be2file: 1st arg not an integer";
+    }
+    v = abs(v);
+
+    /*
+     * open the file for writing
+     */
+    fd = fopen(filename, "wb");
+    if (!isfile(fd)) quit "be2file: cannot open file for writing";
+
+    /*
+     * write the octets to the file
+     *
+     * The most significant bits of the integer become the first file octets.
+     */
+    octlen = int((highbit(v)+8) / 8);
+    for (i=octlen-1; i >= 0; --i) {
+    	fputc(fd, char(v >> (i*8)));
+    }
+
+    /*
+     * cleanup
+     */
+    fclose(fd);
+    return octlen;
+}
+
+
+/*
+ * le2file - convert a little endian integer into a file
+ *
+ * given:
+ *	v		integer to write to the file
+ *	filename	filename to write
+ *
+ * returns:
+ *	The number of octets written to the file.
+ *
+ * NOTE: The absolute value of the integer is written to the file.
+ */
+define le2file(v, filename)
+{
+    local fd;	/* open file */
+    local cnt;	/* octets written */
+
+    /*
+     * firewall
+     */
+    if (!isint(v)) {
+	quit "be2file: 1st arg not an integer";
+    }
+    v = abs(v);
+
+    /*
+     * open the file for writing
+     */
+    fd = fopen(filename, "wb");
+    if (!isfile(fd)) quit "le2file: cannot open file for writing";
+
+    /*
+     * Write the octets to the file.
+     *
+     * The least significant bits of the integer become the first file octets.
+     */
+    cnt = 0;
+    while (v > 0) {
+	fputc(fd, char(v));
+	v >>= 8;
+	++cnt;
+    }
+
+    /*
+     * cleanup
+     */
+    fclose(fd);
+    return cnt;
+}

cal/linear.cal

@@ -0,0 +1,56 @@
+/*
+ * linear - perform a simple two point 2D linear interpolation
+ *
+ * Copyright (C) 2005-2007  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.2 $
+ * @(#) $Id: linear.cal,v 30.2 2007/03/17 05:57:42 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/linear.cal,v $
+ *
+ * Under source code control:	2005/12/12 06:41:50
+ * File existed as early as:	2005
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * linear - perform a simple two point 2D linear interpolation
+ *
+ * given:
+ *	x0, y0		first known point on the line
+ *	x1, y1		second knonw point on the line
+ *	x		a given point to interpolate on
+ *
+ * returns:
+ *	y such that (x,y) is on the line defined by (x0,y0) and (x1,y1)
+ *
+ * NOTE: The line cannot be vertical.  So x0 != y0.
+ */
+define linear(x0, y0, x1, y1, x)
+{
+    /* firewall */
+    if (!isnum(x0) || ! isnum(y0) || !isnum(x1) || ! isnum(y1) || !isnum(x)) {
+	quit "non-numeric argument passed to linear";
+    }
+    if (x0 == x1) {
+	quit "linear given a line with an infinite slope";
+    }
+
+    /* return y = y0 + (delta_Y/delta_X) * (x - x0) */
+    return y0 + (((y1-y0)/(x1-x0)) * (x - x0));
+}

cal/lucas.cal

@@ -1,29 +1,44 @@
-/*
- * Copyright (c) 1995 Landon Curt Noll
- *
- * Permission to use, copy, modify, and distribute this software and
- * its documentation for any purpose and without fee is hereby granted,
- * provided that the above copyright, this permission notice and text
- * this comment, and the disclaimer below appear in all of the following:
- *
- *	supporting documentation
- *	source copies
- *	source works derived from this source
- *	binaries derived from this source or from derived source
- *
- * LANDON CURT NOLL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
- * EVENT SHALL LANDON CURT NOLL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
- * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- *
- * chongo was here	/\../\		chongo@toad.com
- */
 /*
  * lucas - perform a Lucas primality test on h*2^n-1
  *
+ * Copyright (C) 1999  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: lucas.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/lucas.cal,v $
+ *
+ * Under source code control:	1990/05/03 16:49:51
+ * File existed as early as:	1990
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * NOTE: This is a standard calc resource file.  For information on calc see:
+ *
+ *	http://www.isthe.com/chongo/tech/comp/calc/index.html
+ *
+ * To obtain your own copy of calc, see:
+ *
+ *	http://www.isthe.com/chongo/tech/comp/calc/calc-download.html
+ */
+
+/*
  * HISTORICAL NOTE:
  *
  * On 6 August 1989 at 00:53 PDT, the 'Amdahl 6', a team consisting of
@@ -31,28 +46,35 @@
  * Sergio Zarantonello proved the following 65087 digit number to be prime:
  *
  *				  216193
- *			391581 * 2      -1
+ *			391581 * 2	-1
  *
  * At the time of discovery, this number was the largest known prime.
  * The primality was demonstrated by a program implementing the test
  * found in these routines.  An Amdahl 1200 takes 1987 seconds to test
  * the primality of this number.  A Cray 2 took several hours to
- * confirm this prime.  As of 28 Aug 1993, this prime was the 2nd
+ * confirm this prime.	As of 31 Dec 1995, this prime was the 3rd
  * largest known prime and the largest known non-Mersenne prime.
  *
  * The same team also discovered the following twin prime pair:
  *
  *			   11235		   11235
- *		1706595 * 2     -1	1706595 * 2     +1
+ *		1706595 * 2	-1	1706595 * 2	+1
  *
  * At the time of discovery, this was the largest known twin prime pair.
  *
- * NOTE: Both largest known and largest known twin prime records have been
+ * See:
- *       broken.  Rather than update this file each time, I'll just
- *	 congratulate the finders and encourage others to try for
- *	 larger finds.  Records were made to be broken afterall!
  *
- * ON GAINING A WORLD RECORD:
+ *	http://www.isthe.com/chongo/tech/math/prime/amdahl6.html
+ *
+ * for more information on the Amdahl 6 group.
+ *
+ * NOTE: Both largest known and largest known twin prime records have been
+ *	 broken.  Rather than update this file each time, I'll just
+ *	 congratulate the finders and encourage others to try for
+ *	 larger finds.	Records were made to be broken afterall!
+ */
+
+/* ON GAINING A WORLD RECORD:
  *
  * The routines in calc were designed to be portable, and to work on
  * numbers of 'sane' size.  The Amdahl 6 team used a 'ultra-high speed
@@ -68,14 +90,14 @@
  *
  *	test numbers of the form h*2^n-1
  *	fix a value of n and vary the value h
- *	n mod 128 == 0
+ *	n mod 2^x == 0  for some value of x, say > 7 or more
  *	h*2^n-1 is not divisible by any small prime < 2^40
  *	0 < h < 2^39
  *	h*2^n+1 is not divisible by any small prime < 2^40
  *
  * The Mersenne test for '2^n-1' is the fastest known primality test
  * for a given large numbers.  However, it is faster to search for
- * primes of the form 'h*2^n-1'.  When n is around 20000, one can find
+ * primes of the form 'h*2^n-1'.  When n is around 200000, one can find
  * a prime of the form 'h*2^n-1' in about 1/2 the time.
  *
  * Critical to understanding why 'h*2^n-1' is to observe that primes of
@@ -86,7 +108,7 @@
  * 'h', the time to test each number remains relatively constant.
  *
  * It is clearly a win to eliminate potential test candidates by
- * rejecting numbers that that are divisible by 'small' primes.  We
+ * rejecting numbers that that are divisible by 'small' primes.	 We
  * (the "Amdahl 6") rejected all numbers that were divisible by primes
  * less than '2^40'.  We stopped looking for small factors at '2^40'
  * when the rate of candidates being eliminated was slowed down to
@@ -121,8 +143,8 @@
  * point is beyond the scope of this program.
  */
 
+
 global pprod256;	/* product of  "primes up to 256" / "primes up to 46" */
-global lib_debug;	/* 1 => print debug statements */
 
 /*
  * lucas - lucas primality test on h*2^n-1
@@ -130,7 +152,7 @@ global lib_debug;	/* 1 => print debug statements */
  * ABOUT THE TEST:
  *
  * This routine will perform a primality test on h*2^n-1 based on
- * the mathematics of Lucas, Lehmer and Riesel.  One should read
+ * the mathematics of Lucas, Lehmer and Riesel.	 One should read
  * the following article:
  *
  * Ref1:
@@ -151,7 +173,7 @@ global lib_debug;	/* 1 => print debug statements */
  *
  * This test is performed as follows:	(see Ref1, Theorem 5)
  *
- *	a) generate u(0) 		(see the function gen_u0() below)
+ *	a) generate u(0)		(see the function gen_u0() below)
  *
  *	b) generate u(n-2) according to the rule:
  *
@@ -161,9 +183,9 @@ global lib_debug;	/* 1 => print debug statements */
  *
  * Now the following conditions must be true for the test to work:
  *
- *      n >= 2
+ *	n >= 2
  *	h >= 1
- *      h < 2^n
+ *	h < 2^n
  *	h mod 2 == 1
  *
  * A few misc notes:
@@ -172,10 +194,14 @@ global lib_debug;	/* 1 => print debug statements */
  * any number that is divisible by a prime less than 257.  Valid prime
  * candidates less than 257 are declared prime as a special case.
  *
- * The condition 'h mod 2 == 1' is not a problem.  Say one is testing
+ * In real life, you would eliminate candidates by checking for
- * 'j*2^m-1', where j is even.  If we note that:
+ * divisibility by a prime much larger than 257 (perhaps as high
+ * as 2^39).
  *
- *      j mod 2^x == 0 for x>0   implies   j*2^m-1 == ((j/2^x)*2^(m+x))-1,
+ * The condition 'h mod 2 == 1' is not a problem.  Say one is testing
+ * 'j*2^m-1', where j is even.	If we note that:
+ *
+ *	j mod 2^x == 0 for x>0	 implies   j*2^m-1 == ((j/2^x)*2^(m+x))-1,
  *
  * then we can let h=j/2^x and n=m+x and test 'h*2^n-1' which is the value.
  * We need only consider odd values of h because we can rewrite our numbers
@@ -221,7 +247,7 @@ lucas(h, n)
 	 */
 	oldh = h;
 	oldn = n;
-	shiftdown = fcnt(h,2);  /* h % 2^shiftdown == 0, max shiftdown */
+	shiftdown = fcnt(h,2);	/* h % 2^shiftdown == 0, max shiftdown */
 	if (shiftdown > 0) {
 		h >>= shiftdown;
 		n += shiftdown;
@@ -232,13 +258,13 @@ lucas(h, n)
 	 */
 	if (h <= 0 || n <= 0) {
 		print "ERROR: reduced args violate the rule: 0 < h < 2^n";
-		print "    ERROR: h=":oldh, "n=":oldn, "reduced h=":h, "n=":n;
+		print "	   ERROR: h=":oldh, "n=":oldn, "reduced h=":h, "n=":n;
 		ldebug("lucas", "unknown: h <= 0 || n <= 0");
 		return -1;
 	}
 	if (highbit(h) >= n) {
 		print "ERROR: reduced args violate the rule: h < 2^n";
-		print "    ERROR: h=":oldh, "n=":oldn, "reduced h=":h, "n=":n;
+		print "	   ERROR: h=":oldh, "n=":oldn, "reduced h=":h, "n=":n;
 		ldebug("lucas", "unknown: highbit(h) >= n");
 		return -1;
 	}
@@ -345,26 +371,27 @@ lucas(h, n)
 	 * the v(1) into u(0).
 	 *
 	 * If gen_v1() returns a negative value, then we failed to
-	 * generate a test for h*2^n-1.  This is because h mod 3 == 0
+	 * generate a test for h*2^n-1.	 This is because h mod 3 == 0
 	 * is hard to do, and in rare cases, exceed the tables found
 	 * in this program.  We will generate an message and assume
 	 * the number is not prime, even though if we had a larger
 	 * table, we might have been able to show that it is prime.
 	 */
-	v1 = gen_v1(h, n, testval);
+	v1 = gen_v1(h, n);
 	if (v1 < 0) {
 		/* failure to test number */
 		print "unable to compute v(1) for", h : "*2^" : n : "-1";
 		ldebug("lucas", "unknown: no v(1)");
 		return -1;
 	}
-	u = gen_u0(h, n, testval, v1);
+	u = gen_u0(h, n, v1);
 
 	/*
 	 * compute u(n-2)
 	 */
 	for (i=3; i <= n; ++i) {
-		u = (u^2 - 2) % testval;
+		/* u = (u^2 - 2) % testval; */
+		u = hnrmod(u^2 - 2, h, n, -1);
 	}
 
 	/*
@@ -417,7 +444,6 @@ lucas(h, n)
  * input:
  *	h	- h as in h*2^n-1	(h mod 2 != 0)
  *	n	- n as in h*2^n-1
- *	testval	- h*2^n-1
  *	v1	- gen_v1(h,n)		(see function below)
  *
  * returns:
@@ -425,7 +451,7 @@ lucas(h, n)
  *	-1	- failed to generate u(0)
  */
 define
-gen_u0(h, n, testval, v1)
+gen_u0(h, n, v1)
 {
 	local shiftdown;	/* the power of 2 that divides h */
 	local r;		/* low value: v(n) */
@@ -442,15 +468,9 @@ gen_u0(h, n, testval, v1)
 	if (!isint(n)) {
 		quit "bad args: n must be an integer";
 	}
-	if (!isint(testval)) {
-		quit "bad args: testval must be an integer";
-	}
 	if (!isint(v1)) {
 		quit "bad args: v1 must be an integer";
 	}
-	if (testval <= 0) {
-		quit "bogus arg: testval is <= 0";
-	}
 	if (v1 <= 0) {
 		quit "bogus arg: v1 is <= 0";
 	}
@@ -488,34 +508,40 @@ gen_u0(h, n, testval, v1)
 	 */
 	if (h == 1) {
 		ldebug("gen_u0", "quick h == 1 case");
-		return r%testval;
+		/* return r%(h*2^n-1); */
+		return hnrmod(r, h, n, -1);
 	}
 
 	/* cycle from second highest bit to second lowest bit of h */
 	for (i=hbits-1; i > 0; --i) {
 
 		/* bit(i) is 1 */
-		if (isset(h,i)) {
+		if (bit(h,i)) {
 
 			/* compute v(2n+1) = v(r+1)*v(r)-v1 */
-			r = (r*s - v1) % testval;
+			/* r = (r*s - v1) % (h*2^n-1); */
+			r = hnrmod((r*s - v1), h, n, -1);
 
 			/* compute v(2n+2) = v(r+1)^2-2 */
-			s = (s^2 - 2) % testval;
+			/* s = (s^2 - 2) % (h*2^n-1); */
+			s = hnrmod((s^2 - 2), h, n, -1);
 
 		/* bit(i) is 0 */
 		} else {
 
 			/* compute v(2n+1) = v(r+1)*v(r)-v1 */
-			s = (r*s - v1) % testval;
+			/* s = (r*s - v1) % (h*2^n-1); */
+			s = hnrmod((r*s - v1), h, n, -1);
 
 			/* compute v(2n) = v(r)^-2 */
-			r = (r^2 - 2) % testval;
+			/* r = (r^2 - 2) % (h*2^n-1); */
+			r = hnrmod((r^2 - 2), h, n, -1);
 		}
 	}
 
 	/* we know that h is odd, so the final bit(0) is 1 */
-	r = (r*s - v1) % testval;
+	/* r = (r*s - v1) % (h*2^n-1); */
+	r = hnrmod((r*s - v1), h, n, -1);
 
 	/* compute the final u2 return value */
 	return r;
@@ -555,14 +581,14 @@ gen_u0(h, n, testval, v1)
 quickmax = 8;
 mat d_qval[quickmax];
 mat v1_qval[quickmax];
-d_qval[0] = 5;		v1_qval[0] = 3;		/* a=1   b=1  r=4  */
+d_qval[0] = 5;		v1_qval[0] = 3;		/* a=1	 b=1  r=4  */
-d_qval[1] = 7;		v1_qval[1] = 5;		/* a=3   b=1  r=12  D=21 */
+d_qval[1] = 7;		v1_qval[1] = 5;		/* a=3	 b=1  r=12  D=21 */
-d_qval[2] = 13;		v1_qval[2] = 11;	/* a=3   b=1  r=4  */
+d_qval[2] = 13;		v1_qval[2] = 11;	/* a=3	 b=1  r=4  */
-d_qval[3] = 11;		v1_qval[3] = 20;	/* a=3   b=1  r=2  */
+d_qval[3] = 11;		v1_qval[3] = 20;	/* a=3	 b=1  r=2  */
-d_qval[4] = 29;		v1_qval[4] = 27;	/* a=5   b=1  r=4  */
+d_qval[4] = 29;		v1_qval[4] = 27;	/* a=5	 b=1  r=4  */
-d_qval[5] = 53;		v1_qval[5] = 51;	/* a=53  b=1  r=4  */
+d_qval[5] = 53;		v1_qval[5] = 51;	/* a=53	 b=1  r=4  */
-d_qval[6] = 17;		v1_qval[6] = 66;	/* a=17  b=1  r=1  */
+d_qval[6] = 17;		v1_qval[6] = 66;	/* a=17	 b=1  r=1  */
-d_qval[7] = 19;		v1_qval[7] = 74;	/* a=38  b=1  r=2  */
+d_qval[7] = 19;		v1_qval[7] = 74;	/* a=38	 b=1  r=2  */
 
 /*
  * gen_v1 - compute the v(1) for a given h*2^n-1 if we can
@@ -665,7 +691,7 @@ d_qval[7] = 19;		v1_qval[7] = 74;	/* a=38  b=1  r=2  */
  * are true, and return the related v(1).
  *
  * Before we address the two conditions, we need some background information
- * on two symbols, Legendre and Jacobi.  In Ref 2, pp 278, 284-285, we find
+ * on two symbols, Legendre and Jacobi.	 In Ref 2, pp 278, 284-285, we find
  * the following definitions of J(a,p) and L(a,n):
  *
  * The Legendre symbol L(a,p) takes the value:
@@ -718,7 +744,7 @@ d_qval[7] = 19;		v1_qval[7] = 74;	/* a=38  b=1  r=2  */
  *
  * From Ref2, table 32:
  *
- *	p mod 8 == +/-1   implies  L(2,p) == 1			{note 3}
+ *	p mod 8 == +/-1	  implies  L(2,p) == 1			{note 3}
  *	p mod 12 == +/-1  implies  L(3,p) == 1			{note 4}
  *
  * Since h*2^n-1 mod 8 == -1, for n>2, note 3 implies:
@@ -731,14 +757,14 @@ d_qval[7] = 19;		v1_qval[7] = 74;	/* a=38  b=1  r=2  */
  *
  * By use of {A3.5}, {note 2}, {note 5} and {note 6}, one can show:
  *
- *	L((2^g)*(3^l)*(z^2), h*2^n-1) == 1  (g>=0,l>=0,z>0,n>2)	{note 7}
+ *	L((2^g)*(3^l)*(z^2), h*2^n-1) == 1  (g>=0,l>=0,z>0,n>2) {note 7}
  *
  * Returning to the testing of conditions, take condition 1:
  *
  *	L(D, h*2^n-1) == -1			[condition 1]
  *
  * In order for J(D, h*2^n-1) to be defined, we must ensure that D
- * is not a factor of h*2^n-1.  This is done by pre-screening h*2^n-1 to
+ * is not a factor of h*2^n-1.	This is done by pre-screening h*2^n-1 to
  * not have small factors and selecting D less than that factor check limit.
  *
  * By use of {note 7}, we can show that when we choose D to be:
@@ -759,7 +785,7 @@ d_qval[7] = 19;		v1_qval[7] = 74;	/* a=38  b=1  r=2  */
  *		      == J(h*2^n-1 mod P, P)*(-1)^((h*2^n-2)*(P-1)/4)  {note 0}
  *
  * When does J(h*2^n-1 mod P, P)*(-1)^((h*2^n-2)*(P-1)/4) take the value of -1,
- * thus satisfy [condition 1]?  The answer depends on P.  Now P is a prime>2,
+ * thus satisfy [condition 1]?	The answer depends on P.  Now P is a prime>2,
  * thus P mod 4 == 1 or -1.
  *
  * Take P mod 4 == 1:
@@ -774,7 +800,7 @@ d_qval[7] = 19;		v1_qval[7] = 74;	/* a=38  b=1  r=2  */
  *
  * Take P mod 4 == -1:
  *
- *	P mod 4 == -1  implies  (-1)^((h*2^n-2)*(P-1)/4) == -1
+ *	P mod 4 == -1  implies	(-1)^((h*2^n-2)*(P-1)/4) == -1
  *
  * Thus:
  *
@@ -826,7 +852,7 @@ d_qval[7] = 19;		v1_qval[7] = 74;	/* a=38  b=1  r=2  */
  *		      == J(h*2^n-1 mod Q, Q)*(-1)^((h*2^n-2)*(Q-1)/4)  {note 0}
  *
  * When does J(h*2^n-1 mod Q, Q)*(-1)^((h*2^n-2)*(Q-1)/4) take the value of 1,
- * thus satisfy [condition 2]?  The answer depends on Q.  Now Q is a prime>2,
+ * thus satisfy [condition 2]?	The answer depends on Q.  Now Q is a prime>2,
  * thus Q mod 4 == 1 or -1.
  *
  * Take Q mod 4 == 1:
@@ -841,7 +867,7 @@ d_qval[7] = 19;		v1_qval[7] = 74;	/* a=38  b=1  r=2  */
  *
  * Take Q mod 4 == -1:
  *
- *	Q mod 4 == -1  implies  (-1)^((h*2^n-2)*(Q-1)/4) == -1
+ *	Q mod 4 == -1  implies	(-1)^((h*2^n-2)*(Q-1)/4) == -1
  *
  * Thus:
  *
@@ -849,7 +875,7 @@ d_qval[7] = 19;		v1_qval[7] = 74;	/* a=38  b=1  r=2  */
  *		      == L(h*2^n-1 mod Q, Q) * -1
  *		      == -J(h*2^n-1 mod Q, Q)
  *
- * Therefore [condition 2] is met by selecting  D = Q*(2^j)*(3^k)*(z^2),
+ * Therefore [condition 2] is met by selecting	D = Q*(2^j)*(3^k)*(z^2),
  * where Q is prime>2, j>=0, k>=0, z>0; if and only if one of the following
  * to cases are true:
  *
@@ -888,7 +914,7 @@ d_qval[7] = 19;		v1_qval[7] = 74;	/* a=38  b=1  r=2  */
  *
  *	   r == Q*(2^j)*(3^k)*(z^2)	(Q==1 or Q is prime>2, j>=0, k>=0, z>0)
  *
- *         one of the following is true:
+ *	   one of the following is true:
  *	       P mod 4 ==  1  and  J(h*2^n-1 mod P, P) == -1
  *	       P mod 4 == -1  and  J(h*2^n-1 mod P, P) ==  1
  *
@@ -897,7 +923,7 @@ d_qval[7] = 19;		v1_qval[7] = 74;	/* a=38  b=1  r=2  */
  *	       Q mod 4 == -1  and  J(h*2^n-1 mod Q, Q) == -1
  *
  *     If we cannot find a v(1) quickly enough, then we will give up
- *     testing h*2^n-1.  This does not happen too often, so this hack
+ *     testing h*2^n-1.	 This does not happen too often, so this hack
  *     is not too bad.
  *
  ***
@@ -965,28 +991,28 @@ gen_v1(h, n)
 	 *
 	 * We will check with:
 	 *
-	 *	v(1)=81      D=6557      a=79      b=1      r=316
+	 *	v(1)=81	     D=6557	 a=79	   b=1	    r=316
 	 *
-	 * Now, D==79*83 and r=79*2^2.  If we show that:
+	 * Now, D==79*83 and r=79*2^2.	If we show that:
 	 *
 	 *	J(h*2^n-1 mod 79, 79) == -1
 	 *	J(h*2^n-1 mod 83, 83) == 1
 	 *
-	 * then we will satisfy [condition 1].  Observe:
+	 * then we will satisfy [condition 1].	Observe:
 	 *
- 	 *	79 mod 4 == -1  implies  (-1)^((h*2^n-2)*(79-1)/4) == -1
+	 *	79 mod 4 == -1	implies	 (-1)^((h*2^n-2)*(79-1)/4) == -1
- 	 *	83 mod 4 == -1  implies  (-1)^((h*2^n-2)*(83-1)/4) == -1
+	 *	83 mod 4 == -1	implies	 (-1)^((h*2^n-2)*(83-1)/4) == -1
 	 *
 	 *	J(D, h*2^n-1) == J(83, h*2^n-1) * J(79, h*2^n-1)
 	 *		      == J(h*2^n-1, 83) * (-1)^((h*2^n-2)*(83-1)/4) *
-	 *		         J(h*2^n-1, 79) * (-1)^((h*2^n-2)*(79-1)/4)
+	 *			 J(h*2^n-1, 79) * (-1)^((h*2^n-2)*(79-1)/4)
 	 *		      == J(h*2^n-1 mod 83, 83) * -1 *
-	 *		         J(h*2^n-1 mod 79, 79) * -1
+	 *			 J(h*2^n-1 mod 79, 79) * -1
 	 *		      ==  1 * -1 *
 	 *			 -1 * -1
 	 *		      == -1
 	 *
-	 * We will also satisfy [condition 2].  Observe:
+	 * We will also satisfy [condition 2].	Observe:
 	 *
 	 *	(a^2 - b^2*D)/r == (79^2 - 1^1*6557)/316
 	 *			== -1
@@ -1021,13 +1047,8 @@ gen_v1(h, n)
 define
 ldebug(funct, str)
 {
-	if (lib_debug > 0) {
+	if (config("resource_debug") & 8) {
 		print "DEBUG:", funct:":", str;
 	}
 	return;
 }
-
-global lib_debug;
-if (lib_debug >= 0) {
-    print "lucas(h, n) defined";
-}

cal/lucas_chk.cal

@@ -1,26 +1,33 @@
 /*
- * Copyright (c) 1995 Landon Curt Noll
+ * lucas_chk - test all primes of the form h*2^n-1, 1<=h<200 and n <= high_n
  *
- * Permission to use, copy, modify, and distribute this software and
+ * Copyright (C) 1999  Landon Curt Noll
- * its documentation for any purpose and without fee is hereby granted,
- * provided that the above copyright, this permission notice and text
- * this comment, and the disclaimer below appear in all of the following:
  *
- *	supporting documentation
+ * Calc is open software; you can redistribute it and/or modify it under
- *	source copies
+ * the terms of the version 2.1 of the GNU Lesser General Public License
- *	source works derived from this source
+ * as published by the Free Software Foundation.
- *	binaries derived from this source or from derived source
  *
- * LANDON CURT NOLL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * Calc is distributed in the hope that it will be useful, but WITHOUT
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * EVENT SHALL LANDON CURT NOLL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU Lesser General
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
+ * Public License for more details.
- * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
  *
- * chongo was here	/\../\		chongo@toad.com
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: lucas_chk.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/lucas_chk.cal,v $
+ *
+ * Under source code control:	1991/01/11 05:41:43
+ * File existed as early as:	1991
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
+
 /*
  * primes of the form h*2^n-1 for 1<=h<200 and 1<=n<1000
  *
@@ -42,6 +49,7 @@
  *		199*2^221-1 is NOT prime
  */
 
+
 static prime_cnt = 1145;	/* number of primes in the list */
 
 /* h = prime parameters */
@@ -256,7 +264,7 @@ static mat n_p[prime_cnt] = {
 	59, 75, 103, 163, 235, 375, 615, 767, 2, 18,
 	38, 62, 1, 5, 7, 9, 15, 19, 21, 35,
 	37, 39, 41, 49, 69, 111, 115, 141, 159, 181,
-	201, 217, 487, 567, 677, 765, 811, 841, 917, 2,	/* 900 */
+	201, 217, 487, 567, 677, 765, 811, 841, 917, 2, /* 900 */
 	4, 6, 8, 12, 18, 26, 32, 34, 36, 42,
 	60, 78, 82, 84, 88, 154, 174, 208, 256, 366,
 	448, 478, 746, 5, 13, 15, 31, 77, 151, 181,
@@ -296,7 +304,7 @@ read -once "lucas.cal";
  *
  * input:
  *	high_n	skip tests on n_p[i] > high_n
- *	[quiet]	if given and != 0, then do not print individual test results
+ *	[quiet] if given and != 0, then do not print individual test results
  *
  * returns:
  *	1	all is ok
@@ -328,7 +336,7 @@ lucas_chk(high_n, quiet)
 
 		/* skip primes where h>=2^n */
 		if (highbit(h_p[i]) >= n_p[i]) {
-			if (lib_debug > 0) {
+			if (config("resource_debug") & 8) {
 				print "h>=2^n skip:", h_p[i]:"*2^":n_p[i]:"-1";
 			}
 			continue;
@@ -374,8 +382,3 @@ lucas_chk(high_n, quiet)
 		return 0;
 	}
 }
-
-global lib_debug;
-if (lib_debug >= 0) {
-    print "lucas_chk(high_n) defined";
-}

cal/lucas_tbl.cal

@@ -0,0 +1,165 @@
+/*
+ * lucas_tbl - lucasian criteria for primality tables
+ *
+ * Copyright (C) 1999  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: lucas_tbl.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/lucas_tbl.cal,v $
+ *
+ * Under source code control:	1991/01/26 02:43:43
+ * File existed as early as:	1991
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * Lucasian criteria for primality
+ *
+ * The following table is taken from:
+ *
+ *	"Lucasian Criteria for the Primality of N=h*2^n-1", by Hans Riesel,
+ *	Mathematics of Computation, Vol 23 #108, p 872.
+ *
+ * The index of the *_val[] arrays correspond to the v(1) values found
+ * in the table.  That is, for v(1) == x:
+ *
+ *	D == d_val[x]
+ *	a == a_val[x]
+ *	b == b_val[x]
+ *	r == r_val[x]		(r == abs(a^2 - b^2*D))
+ *
+ *
+ * Note that when *_val[i] is not a number, the related v(1) value
+ * is not found in Table 1.
+ */
+
+
+trymax = 100;
+mat d_val[trymax+1];
+mat a_val[trymax+1];
+mat b_val[trymax+1];
+mat r_val[trymax+1];
+/* v1= 0	    INVALID */
+/* v1= 1	    INVALID */
+/* v1= 2	    INVALID */
+d_val[ 3]=   5;	 a_val[ 3]= 1;	b_val[ 3]=1;  r_val[ 3]=4;
+d_val[ 4]=   3;	 a_val[ 4]= 1;	b_val[ 4]=1;  r_val[ 4]=2;
+d_val[ 5]=  21;	 a_val[ 5]= 3;	b_val[ 5]=1;  r_val[ 5]=12;
+d_val[ 6]=   2;	 a_val[ 6]= 1;	b_val[ 6]=1;  r_val[ 6]=1;
+/* v1= 7	    INVALID */
+d_val[ 8]=  15;	 a_val[ 8]= 3;	b_val[ 8]=1;  r_val[ 8]=6;
+d_val[ 9]=  77;	 a_val[ 9]= 7;	b_val[ 9]=1;  r_val[ 9]=28;
+d_val[10]=   6;	 a_val[10]= 2;	b_val[10]=1;  r_val[10]=2;
+d_val[11]=  13;	 a_val[11]= 3;	b_val[11]=1;  r_val[11]=4;
+d_val[12]=  35;	 a_val[12]= 5;	b_val[12]=1;  r_val[12]=10;
+d_val[13]= 165;	 a_val[13]=11;	b_val[13]=1;  r_val[13]=44;
+/* v1=14	    INVALID */
+d_val[15]= 221;	 a_val[15]=13;	b_val[15]=1;  r_val[15]=52;
+d_val[16]=   7;	 a_val[16]= 3;	b_val[16]=1;  r_val[16]=2;
+d_val[17]= 285;	 a_val[17]=15;	b_val[17]=1;  r_val[17]=60;
+/* v1=18	    INVALID */
+d_val[19]= 357;	 a_val[19]=17;	b_val[19]=1;  r_val[19]=68;
+d_val[20]=  11;	 a_val[20]= 3;	b_val[20]=1;  r_val[20]=2;
+d_val[21]= 437;	 a_val[21]=19;	b_val[21]=1;  r_val[21]=76;
+d_val[22]=  30;	 a_val[22]= 5;	b_val[22]=1;  r_val[22]=5;
+/* v1=23	    INVALID */
+d_val[24]= 143;	 a_val[24]=11;	b_val[24]=1;  r_val[24]=22;
+d_val[25]=  69;	 a_val[25]= 9;	b_val[25]=1;  r_val[25]=12;
+d_val[26]=  42;	 a_val[26]= 6;	b_val[26]=1;  r_val[26]=6;
+d_val[27]=  29;	 a_val[27]= 5;	b_val[27]=1;  r_val[27]=4;
+d_val[28]= 195;	 a_val[28]=13;	b_val[28]=1;  r_val[28]=26;
+d_val[29]=  93;	 a_val[29]= 9;	b_val[29]=1;  r_val[29]=12;
+d_val[30]=  14;	 a_val[30]= 4;	b_val[30]=1;  r_val[30]=2;
+d_val[31]= 957;	 a_val[31]=29;	b_val[31]=1;  r_val[31]=116;
+d_val[32]= 255;	 a_val[32]=15;	b_val[32]=1;  r_val[32]=30;
+d_val[33]=1085;	 a_val[33]=31;	b_val[33]=1;  r_val[33]=124;
+/* v1=34	    INVALID */
+d_val[35]=1221;	 a_val[35]=33;	b_val[35]=1;  r_val[35]=132;
+d_val[36]= 323;	 a_val[36]=17;	b_val[36]=1;  r_val[36]=34;
+d_val[37]=1365;	 a_val[37]=35;	b_val[37]=1;  r_val[37]=140;
+d_val[38]=  10;	 a_val[38]= 3;	b_val[38]=1;  r_val[38]=1;
+d_val[39]=1517;	 a_val[39]=37;	b_val[39]=1;  r_val[39]=148;
+d_val[40]= 399;	 a_val[40]=19;	b_val[40]=1;  r_val[40]=38;
+d_val[41]=1677;	 a_val[41]=39;	b_val[41]=1;  r_val[41]=156;
+d_val[42]= 110;	 a_val[42]=10;	b_val[42]=1;  r_val[42]=10;
+d_val[43]= 205;	 a_val[43]=15;	b_val[43]=1;  r_val[43]=20;
+d_val[44]= 483;	 a_val[44]=21;	b_val[44]=1;  r_val[44]=42;
+d_val[45]=2021;	 a_val[45]=43;	b_val[45]=1;  r_val[45]=172;
+d_val[46]=  33;	 a_val[46]= 6;	b_val[46]=1;  r_val[46]=3;
+/* v1=47	    INVALID */
+d_val[48]=  23;	 a_val[48]= 5;	b_val[48]=1;  r_val[48]=2;
+d_val[49]=2397;	 a_val[49]=47;	b_val[49]=1;  r_val[49]=188;
+d_val[50]=  39;	 a_val[50]= 6;	b_val[50]=1;  r_val[50]=3;
+d_val[51]=  53;	 a_val[51]= 7;	b_val[51]=1;  r_val[51]=4;
+/* v1=52	    INVALID */
+d_val[53]=2805;	 a_val[53]=51;	b_val[53]=1;  r_val[53]=204;
+d_val[54]= 182;	 a_val[54]=13;	b_val[54]=1;  r_val[54]=13;
+d_val[55]=3021;	 a_val[55]=53;	b_val[55]=1;  r_val[55]=212;
+d_val[56]=  87;	 a_val[56]= 9;	b_val[56]=1;  r_val[56]=6;
+d_val[57]=3245;	 a_val[57]=55;	b_val[57]=1;  r_val[57]=220;
+d_val[58]= 210;	 a_val[58]=14;	b_val[58]=1;  r_val[58]=14;
+d_val[59]=3477;	 a_val[59]=57;	b_val[59]=1;  r_val[59]=228;
+d_val[60]= 899;	 a_val[60]=29;	b_val[60]=1;  r_val[60]=58;
+d_val[61]= 413;	 a_val[61]=21;	b_val[61]=1;  r_val[61]=28;
+/* v1=62	    INVALID */
+d_val[63]=3965;	 a_val[63]=61;	b_val[63]=1;  r_val[63]=244;
+d_val[64]=1023;	 a_val[64]=31;	b_val[64]=1;  r_val[64]=62;
+d_val[65]= 469;	 a_val[65]=21;	b_val[65]=1;  r_val[65]=28;
+d_val[66]=  17;	 a_val[66]= 4;	b_val[66]=1;  r_val[66]=1;
+d_val[67]=4485;	 a_val[67]=65;	b_val[67]=1;  r_val[67]=260;
+d_val[68]=1155;	 a_val[68]=33;	b_val[68]=1;  r_val[68]=66;
+d_val[69]=4757;	 a_val[69]=67;	b_val[69]=1;  r_val[69]=268;
+d_val[70]=  34;	 a_val[70]= 6;	b_val[70]=1;  r_val[70]=2;
+d_val[71]=5037;	 a_val[71]=69;	b_val[71]=1;  r_val[71]=276;
+d_val[72]=1295;	 a_val[72]=35;	b_val[72]=1;  r_val[72]=70;
+d_val[73]= 213;	 a_val[73]=15;	b_val[73]=1;  r_val[73]=12;
+d_val[74]=  38;	 a_val[74]= 6;	b_val[74]=1;  r_val[74]=2;
+d_val[75]=5621;	 a_val[75]=73;	b_val[75]=1;  r_val[75]=292;
+d_val[76]=1443;	 a_val[76]=37;	b_val[76]=1;  r_val[76]=74;
+d_val[77]= 237;	 a_val[77]=15;	b_val[77]=1;  r_val[77]=12;
+d_val[78]=  95;	 a_val[78]=10;	b_val[78]=1;  r_val[78]=5;
+/* v1=79	    INVALID */
+d_val[80]=1599;	 a_val[80]=39;	b_val[80]=1;  r_val[80]=78;
+d_val[81]=6557;	 a_val[81]=79;	b_val[81]=1;  r_val[81]=316;
+d_val[82]= 105;	 a_val[82]=10;	b_val[82]=1;  r_val[82]=5;
+d_val[83]=  85;	 a_val[83]= 9;	b_val[83]=1;  r_val[83]=4;
+d_val[84]=1763;	 a_val[84]=41;	b_val[84]=1;  r_val[84]=82;
+d_val[85]=7221;	 a_val[85]=83;	b_val[85]=1;  r_val[85]=332;
+d_val[86]= 462;	 a_val[86]=21;	b_val[86]=1;  r_val[86]=21;
+d_val[87]=7565;	 a_val[87]=85;	b_val[87]=1;  r_val[87]=340;
+d_val[88]= 215;	 a_val[88]=15;	b_val[88]=1;  r_val[88]=10;
+d_val[89]=7917;	 a_val[89]=87;	b_val[89]=1;  r_val[89]=348;
+d_val[90]= 506;	 a_val[90]=22;	b_val[90]=1;  r_val[90]=22;
+d_val[91]=8277;	 a_val[91]=89;	b_val[91]=1;  r_val[91]=356;
+d_val[92]= 235;	 a_val[92]=15;	b_val[92]=1;  r_val[92]=10;
+d_val[93]=8645;	 a_val[93]=91;	b_val[93]=1;  r_val[93]=364;
+d_val[94]= 138;	 a_val[94]=12;	b_val[94]=1;  r_val[94]=6;
+d_val[95]=9021;	 a_val[95]=93;	b_val[95]=1;  r_val[95]=372;
+d_val[96]=  47;	 a_val[96]= 7;	b_val[96]=1;  r_val[96]=2;
+d_val[97]=1045;	 a_val[97]=33;	b_val[97]=1;  r_val[97]=44;
+/* v1=98	    INVALID */
+d_val[99]=9797;	 a_val[99]=97;	b_val[99]=1;  r_val[99]=388;
+d_val[100]=  51; a_val[100]= 7; b_val[100]=1; r_val[100]=2;
+
+if (config("resource_debug") & 3) {
+    print "d_val[100] defined";
+    print "a_val[100] defined";
+    print "b_val[100] defined";
+    print "r_val[100] defined";
+}

cal/mersenne.cal

@@ -0,0 +1,61 @@
+/*
+ * mersenne - perform a primality test of 2^p-1, for prime p>1
+ *
+ * Copyright (C) 1999  David I. Bell and Landon Curt Noll
+ *
+ * Primary author:  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: mersenne.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/mersenne.cal,v $
+ *
+ * Under source code control:	1991/05/22 21:56:36
+ * File existed as early as:	1991
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * NOTE: See lucas.cal for a more general routine.
+ */
+
+
+define mersenne(p)
+{
+	local u, i, p_mask;
+
+	/* firewall */
+	if (! isint(p))
+		quit "p is not an integer";
+
+	/* two is a special case */
+	if (p == 2)
+		return 1;
+
+	/* if p is not prime, then 2^p-1 is not prime */
+	if (! ptest(p,1))
+		return 0;
+
+	/* lltest: u(i+1) = u(i)^2 - 2 mod 2^p-1 */
+	u = 4;
+	for (i = 2; i < p; ++i) {
+		u = hnrmod(u^2 - 2, 1, p, -1);
+	}
+
+	/* 2^p-1 is prime iff u(p) = 0 mod 2^p-1 */
+	return (u == 0);
+}

cal/mfactor.cal

@@ -0,0 +1,319 @@
+/*
+ * mfactor - return the lowest factor of 2^n-1, for n > 0
+ *
+ * Copyright (C) 1999  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: mfactor.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/mfactor.cal,v $
+ *
+ * Under source code control:	1996/07/06 06:09:40
+ * File existed as early as:	1996
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * hset method
+ *
+ * We will assume that mfactor is called with p_elim == 17.
+ *
+ *	n = (the Mersenne exponent we are testing)
+ *	Q = 4*2*3*5*7*11*13*17 (4 * pfact(of some reasonable integer))
+ *
+ * We first determine all values of h mod Q such that:
+ *
+ *	gcd(h*n+1, Q) == 1   and   h*n+1 == +/-1 mod 8
+ *
+ * There will be 2*1*2*4*6*10*12*16 such values of h.
+ *
+ * For efficiency, we keep the difference between consecutive h values
+ * in the hset[] difference array with hset[0] being the first h value.
+ * Last, we multiply the hset[] values by n so that we only need
+ * to add sequential values of hset[] to get factor candidates.
+ *
+ * We need only test factors of the form:
+ *
+ *	(Q*g*n + hx) + 1
+ *
+ * where:
+ *
+ *	g is an integer >= 0
+ *	hx is computed from hset[] difference value described above
+ *
+ * Note that (Q*g*n + hx) is always even and that hx is a multiple
+ * of n.  Thus the typical factor form:
+ *
+ *	2*k*n + 1
+ *
+ * implies that:
+ *
+ *	k = (Q*g + hx/n)/2
+ *
+ * This allows us to quickly eliminate factor values that are divisible
+ * by 2, 3, 5, 7, 11, 13 or 17.	 (well <= p value found below)
+ *
+ * The following loop shows how test_factor is advanced to higher test
+ * values using hset[].	 Here, hcount is the number of elements in hset[].
+ * It can be shown that hset[0] == 0.  We add hset[hcount] to the hset[]
+ * array for looping control convenience.
+ *
+ *	(* increase test_factor thru other possible test values *)
+ *	test_factor = 0;
+ *	hindx = 0;
+ *	do {
+ *		while (++hindx <= hcount) {
+ *			test_factor += hset[hindx];
+ *		}
+ *		hindx = 0;
+ *	} while (test_factor < some_limit);
+ *
+ * The test, mfactor(67, 1, 10000) took on an 200 Mhz r4k (user CPU seconds):
+ *
+ *	210.83	(prior to use of hset[])
+ *	 78.35	(hset[] for p_elim = 7)
+ *	 73.87	(hset[] for p_elim = 11)
+ *	 73.92	(hset[] for p_elim = 13)
+ *	234.16	(hset[] for p_elim = 17)
+ *	p_elim == 19 requires over 190 Megs of memory
+ *
+ * Over a long period of time, the call to load_hset() becomes insignificant.
+ * If we look at the user CPU seconds from the first 10000 cycle to the
+ * end of the test we find:
+ *
+ *	205.00	(prior to use of hset[])
+ *	 75.89	(hset[] for p_elim = 7)
+ *	 73.74	(hset[] for p_elim = 11)
+ *	 70.61	(hset[] for p_elim = 13)
+ *	 57.78	(hset[] for p_elim = 17)
+ *	 p_elim == 19 rejected because of memory size
+ *
+ * The p_elim == 17 overhead takes ~3 minutes on an 200 Mhz r4k CPU and
+ * requires about ~13 Megs of memory.  The p_elim == 13 overhead
+ * takes about 3 seconds and requires ~1.5 Megs of memory.
+ *
+ * The value p_elim == 17 is best for long factorizations.  It is the
+ * fastest even thought the initial startup overhead is larger than
+ * for p_elim == 13.
+ *
+ * NOTE: The values above are prior to optimizations where hset[] was
+ *	 multiplied by n plus other optimizations.  Thus, the CPU
+ *	 times you may get will not likely match the above values.
+ */
+
+
+/*
+ * mfactor - find a factor of a Mersenne Number
+ *
+ * Mersenne numbers are numbers of the form:
+ *
+ *	2^n-1	for integer n > 0
+ *
+ * We know that factors of a Mersenne number are of the form:
+ *
+ *	2*k*n+1	  and	+/- 1 mod 8
+ *
+ * We make use of the hset[] difference array to eliminate factor
+ * candidates that would otherwise be divisible by 2, 3, 5, 7 ... p_elim.
+ *
+ * given:
+ *	n		attempt to factor M(n) = 2^n-1
+ *	start_k		the value k in 2*k*n+1 to start the search (def: 1)
+ *	rept_loop	loop cycle reporting (def: 10000)
+ *	p_elim		largest prime to eliminate from test factors (def: 17)
+ *
+ * returns:
+ *	factor of (2^n)-1
+ *
+ * NOTE: The p_elim argument is optional and defaults to 17.  A p_elim value
+ *	 of 17 is faster than 13 for even medium length runs.  However 13
+ *	 uses less memory and has a shorter startup time.
+ */
+define mfactor(n, start_k, rept_loop, p_elim)
+{
+	local Q;	/* 4*pfact(p_elim), hset[] cycle size */
+	local hcount;	/* elements in the hset[] difference array */
+	local loop;	/* report loop count */
+	local q;	/* test factor of 2^n-1 */
+	local g;	/* g as in test candidate form: (Q*g*hset[i])*n + 1 */
+	local hindx;	/* hset[] index */
+	local i;
+	local tmp;
+	local tmp2;
+
+	/*
+	 * firewall
+	 */
+	if (!isint(n) || n <= 0) {
+		quit "n must be an integer > 0";
+	}
+	if (!isint(start_k)) {
+		start_k = 1;
+	} else if (!isint(start_k) || start_k <= 0) {
+		quit "start_k must be an integer > 0";
+	}
+	if (!isint(rept_loop)) {
+		rept_loop = 10000;
+	}
+	if (rept_loop < 1) {
+		quit "rept_loop must be an integer > 0";
+	}
+	if (!isint(p_elim)) {
+		p_elim = 17;
+	}
+	if (p_elim < 3) {
+		quit "p_elim must be an integer > 2 (try 13 or 17)";
+	}
+
+	/*
+	 * declare our global values
+	 */
+	Q = 4*pfact(p_elim);
+	hcount = 2;
+	/* allocate the h difference array */
+	for (i=2; i <= p_elim; i = nextcand(i)) {
+		hcount *= (i-1);
+	}
+	local mat hset[hcount+1];
+
+	/*
+	 * load the hset[] difference array
+	 */
+	{
+		local x;	/* h*n+1 mod 8 */
+		local h;	/* potential h value */
+		local last_h;	/* previous valid h value */
+
+		last_h = 0;
+		for (i=0,h=0; h < Q; ++h) {
+			if (gcd(h*n+1,Q) == 1) {
+				x = (h*n+1) % 8;
+				if (x == 1 || x == 7) {
+					hset[i++] = (h-last_h) * n;
+					last_h = h;
+				}
+			}
+		}
+		hset[hcount] = Q*n - last_h*n;
+	}
+
+	/*
+	 * setup
+	 *
+	 * determine the next g and hset[] index (hindx) values such that:
+	 *
+	 *	2*start_k <= (Q*g + hset[hindx])
+	 *
+	 * and (Q*g + hset[hindx]) is a minimum and where:
+	 *
+	 *	Q = (4 * pfact(of some reasonable integer))
+	 *	g = (some integer) (hset[] cycle number)
+	 *
+	 * We also compute 'q', the next test candidate.
+	 */
+	g = (2*start_k) // Q;
+	tmp = 2*start_k - Q*g;
+	for (tmp2=0, hindx=0;
+	     hindx < hcount && (tmp2 += hset[hindx]/n) < tmp;
+	     ++hindx) {
+	}
+	if (hindx == hcount) {
+		/* we are beyond the end of a hset[] cycle, start at the next */
+		++g;
+		hindx = 0;
+		tmp2 = hset[0]/n;
+	}
+	q = (Q*g + tmp2)*n + 1;
+
+	/*
+	 * look for a factor
+	 *
+	 * We ignore factors that themselves are divisible by a prime <=
+	 * some small prime p.
+	 *
+	 * This process is guaranteed to find the smallest factor
+	 * of 2^n-1.  A smallest factor of 2^n-1 must be prime, otherwise
+	 * the divisors of that factor would also be factors of 2^n-1.
+	 * Thus we know that if a test factor itself is not prime, it
+	 * cannot be the smallest factor of 2^n-1.
+	 *
+	 * Eliminating all non-prime test factors would take too long.
+	 * However we can eliminate 80.81% of the test factors
+	 * by not using test factors that are divisible by a prime <= 17.
+	 */
+	if (pmod(2,n,q) == 1) {
+		return q;
+	} else {
+		/* report this loop */
+		printf("at 2*%d*%d+1, cpu: %f\n",
+			(q-1)/(2*n), n, usertime());
+		fflush(files(1));
+		loop = 0;
+	}
+	do {
+		/*
+		 * determine if we need to report
+		 *
+		 * NOTE: (q-1)/(2*n) is the k value from 2*k*n + 1.
+		 */
+		if (rept_loop <= ++loop) {
+			/* report this loop */
+			printf("at 2*%d*%d+1, cpu: %f\n",
+				(q-1)/(2*n), n, usertime());
+			fflush(files(1));
+			loop = 0;
+		}
+
+		/*
+		 * skip if divisable by a prime <= 449
+		 *
+		 * The value 281 was determined by timing loops
+		 * which found that 281 was at or near the
+		 * minimum time to factor 2^(2^127-1)-1.
+		 *
+		 * The addition of the do { ... } while (factor(q, 449)>1);
+		 * loop reduced the factoring loop time (36504 k values with
+		 * the hset[] initialization time removed) from 25.69 sec to
+		 * 15.62 sec of CPU time on a 200Mhz r4k.
+		 */
+		do {
+			/*
+			 * determine the next factor candidate
+			 */
+			q += hset[++hindx];
+			if (hindx >= hcount) {
+				hindx = 0;
+				/*
+				 * if we cared about g,
+				 * then we wound ++g here too
+				 */
+			}
+		} while (factor(q, 449) > 1);
+	} while (pmod(2,n,q) != 1);
+
+	/*
+	 * return the factor found
+	 *
+	 * q is a factor of (2^n)-1
+	 */
+	return q;
+}
+
+if (config("resource_debug") & 3) {
+	print "mfactor(n [, start_k=1 [, rept_loop=10000 [, p_elim=17]]])"
+}

cal/mod.cal

@@ -1,23 +1,44 @@
 /*
- * Copyright (c) 1995 David I. Bell
+ * mod - routines to handle numbers modulo a specified number
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * Routines to handle numbers modulo a specified number.
+ * Copyright (C) 1999  David I. Bell
- *	a (mod N)
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: mod.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/mod.cal,v $
+ *
+ * Under source code control:	1990/02/15 01:50:34
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
 
+
 obj mod {a};			/* definition of the object */
 
 global mod_value = 100;		/* modulus value (value of N) */
 
 
-define mod(a)
+define lmod(a)
 {
 	local obj mod	x;
 
 	if (!isreal(a) || !isint(a))
-		quit "Bad argument for mod function";
+		quit "Bad argument for lmod function";
 	x.a = a % mod_value;
 	return x;
 }
@@ -34,7 +55,7 @@ define mod_print(a)
 
 define mod_one()
 {
-	return mod(1);
+	return lmod(1);
 }
 
 
@@ -51,9 +72,9 @@ define mod_cmp(a, b)
 define mod_rel(a, b)
 {
 	if (isnum(a))
-		a = mod(a);
+		a = lmod(a);
 	if (isnum(b))
-		b = mod(b);
+		b = lmod(b);
 	if (a.a < b.a)
 		return -1;
 	return a.a != b.a;
@@ -159,13 +180,13 @@ define mod_inv(a)
 
 define mod_div(a, b)
 {
-	local c, x, y;
+	local c;
-
+	local obj mod x;
-	obj mod x, y;
+	local obj mod y;
 	if (isnum(a))
-		a = mod(a);
+		a = lmod(a);
 	if (isnum(b))
-		b = mod(b);
+		b = lmod(b);
 	c = gcd(a.a, b.a);
 	x.a = a.a / c;
 	y.a = b.a / c;
@@ -189,23 +210,8 @@ define mod_pow(a, b)
 }
 
 
-global lib_debug;
+if (config("resource_debug") & 3) {
-if (lib_debug >= 0) {
     print "obj mod {a} defined";
-    print "mod(a) defined";
-    print "mod_print(a) defined";
-    print "mod_one(a) defined";
-    print "mod_cmp(a, b) defined";
-    print "mod_rel(a, b) defined";
-    print "mod_add(a, b) defined";
-    print "mod_sub(a, b) defined";
-    print "mod_mod(a, b) defined";
-    print "mod_square(a) defined";
-    print "mod_inc(a) defined";
-    print "mod_dec(a) defined";
-    print "mod_inv(a) defined";
-    print "mod_div(a, b) defined";
-    print "mod_pow(a, b) defined";
     print "mod_value defined";
     print "set mod_value as needed";
 }

cal/natnumset.cal

@@ -0,0 +1,616 @@
+/*
+ * natnumset - functions for sets of natural numbers not exceeding a fixed bound
+ *
+ * Copyright (C) 1999  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: natnumset.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/natnumset.cal,v $
+ *
+ * Under source code control:	1997/09/07 23:53:51
+ * File existed as early as:	1997
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * Functions for sets of natural numbers not exceeding a fixed bound B.
+ *
+ * The default value for B is 100; B may be assigned another
+ * value n by setbound(n); with no argument, setbound() returns the current
+ * upper bound.
+ *
+ * A set S is stored as an object with one element with one component S.s;
+ * This component is a string of just sufficient size to include m bits,
+ * where m is the maximum integer in S.
+ *
+ * With zero or more integer arguments, set(a, b, ...) returns the set
+ * whose elements are those of a, b, ... in [0, B].  Note that arguments
+ * < 0 or > B are ignored.
+ *
+ * In an assignment of a set-valued lvalue to an lvalue, as in
+ *
+ *		A = set(1,2,3);
+ *		B = A;
+ *
+ * the sets share the same data string, so a change to either has the effect
+ * of changing both.  A set equal to A but with a different string can be
+ * created by
+ *
+ *		B = A | set()
+ *
+ * The functions empty() and full() return the empty set and the set of all
+ * integers in [0,B] respectively.
+ *
+ * isset(A) returns 1 or 0 according as A is or is not a set
+ *
+ * test(A) returns 0 or 1 according as A is or is not the empty set
+ *
+ * isin(A, n) for set A and integer n returns 1 if n is in A, 0 if
+ *	0 <= n <= B and n is not in A, the null value if n < 0 or n > B.
+ *
+ * addmember(A, n) adds n as a member of A, provided n is in [0, B];
+ *	 this is also achieved by A |= n.
+ *
+ * rmmember(A, n) removes n from A if it is a member; this is also achieved
+ *	by A \= n.
+ *
+ * The following unary and binary operations are defined for sets A, B.
+ *	For binary operations with one argument a set and the other an
+ *	integer n, the integer taken to represent set(n).
+ *
+ *	A | B = union of A and B, integers in at least one of A and B
+ *	A & B = intersection of A and B, integers in both A and B
+ *	A ~ B = symmetric difference (boolean sum) of A and Bi, integers
+ *			in exactly one of A and B
+ *	A \ B = set difference, integers in A but not in B
+ *
+ *	~A	= complement of A, integers not in A
+ *	#A	= number ofintegers in A
+ *	!A	= 1 or 0 according as A is empty or not empty
+ *	+A	= sum of the members of A
+ *
+ *	min(A)	= least member of A, -1 for empty set
+ *	max(A)	= greatest member of A, -1 for empty set
+ *	sum(A)	= sum of the members of A
+ *
+ * In the following a and b denote arbitrary members of A and B:
+ *
+ *	A + B = set of sums a + b
+ *	A - B = set of differences a - b
+ *	A * B = set of products a * b
+ *	A ^ n = set of powers a ^ n
+ *	A % m = set of integers congruent to a mod m
+ *
+ *	A == B returns 1 or not according as A and B are equal or not
+ *	A != B = !(A == B)
+ *	A <= B returns 1 if A is a subset of B, i.e. every member of A is
+ *		a member of B
+ *	A < B = ((A <= B) && (A != B))
+ *	A >= B = (B <= A)
+ *	A > B = (B < A)
+ *
+ * Expresssions may be formed from the above "arithmetic" operations in
+ * the usual way, with parentheses for variations from the usual precedence
+ * rules.  For example
+ *
+ *	A + 3 * A ^ 2 + (A - B) ^ 3
+ *
+ * returns the set of integers expressible as
+ *
+ *	a_1 + 3 * a_2 ^ 2 + (a_3 - b) ^3
+ *
+ * where a_1, a_2, a_3 are in A, and b is in B.
+ *
+ * primes(a, b) returns the set of primes between a and b inclusive.
+ *
+ * interval(a, b) returns the integers between a and b inclusive
+ *
+ * isinterval(A) returns 1 if A is a non-empty interval, 0 otherwise.
+ *
+ * randset(n, a, b) returns a random set of n integers between a and b
+ *	inclusive; a defaults to 0, b to N-1.  An error occurs if
+ *	n is too large.
+ *
+ * polyvals(L, A) for L = list(c_0, c_1, c_2, ...) returns the set of
+ * values of
+ *
+ *	c_0 + c_1 * a + c_2 * a^2 + ...
+ *
+ * for a in the set A.
+ *
+ * polyvals2(L, A, B) returns the set of values of poly(L, i, j) for i in
+ *	A and j in B.  Here L is a list whose members are integers or
+ *	lists of integers, the latter representing polynomials in the
+ *	second variable.  For example, with L = list(0, list(0, 1), 1),
+ *	polyvals2(L, A, B) will return the values of i^2 + i * j for
+ *	i in A, j in B.
+ *
+ */
+
+
+static N;		/* Number of integers in [0,B], = B + 1 */
+static M;		/* Maximum string size required, = N // 8 */
+
+obj set {s};
+
+define isset(a) = istype(a, obj set);
+
+define setbound(n)
+{
+	local v;
+
+	v = N - 1;
+	if (isnull(n))
+		return v;
+	if (!isint(n) || n < 0)
+		quit "Bad argument for setbound";
+	N = n + 1;
+	M = quo(N, 8, 1);	/* M // 8 rounded up */
+	if (v >= 0)
+		return v;
+}
+
+setbound(100);
+
+define empty() = obj set = {""};
+
+define full()
+{
+	local v;
+
+	obj set v;
+	v.s = M * char(-1);
+	if (!ismult(N, 8)) v.s[M-1] = 255 >> (8 - N & 7);
+	return v;
+}
+
+define isin(a, b)
+{
+	if (!isset(a) || !isint(b))
+		quit "Bad argument for isin";
+	return bit(a.s, b);
+}
+
+define addmember(a, n)
+{
+	if (!isset(a) || !isint(n))
+		quit "Bad argument for addmember";
+	if (n < N && n >= 0)
+		setbit(a.s, n);
+}
+
+define rmmember(a, n)
+{
+	if (n < N && n >= 0)
+		setbit(a.s, n, 0);
+}
+
+define set()
+{
+	local i, v, s;
+
+	s = M * char(0);
+	for (i = 1; i <= param(0); i++) {
+		v = param(i);
+		if (!isint(v))
+			quit "Non-integral argument for set";
+		if (v >= 0 && v < N)
+			setbit(s, v);
+	}
+	return mkset(s);
+}
+
+
+define mkset(s)
+{
+	local h, m;
+
+	if (!isstr(s))
+		quit "Non-string argument for mkset";
+	h = highbit(s);
+	if (h >= N)
+		quit "Too-long string for mkset";
+	m = quo(h + 1, 8, 1);
+	return obj set = {head(s, m)};
+}
+
+
+define primes(a,b)
+{
+	local i, s, m;
+
+	if (isnull(b)) {
+		if (isnull(a)) {
+			a = 0;
+			b = N - 1;
+		}
+		else b = 0;
+	}
+
+	if (!isint(a) || !isint(b))
+		quit "Non-integer argument for primes";
+	if (a > b)
+		swap(a,b);
+	if (b < 0 || a >= N)
+		return empty();
+	a = max(a, 0);
+	b = min(b, N-1);
+	s = M * char(0);
+	for (i = a; i <= b; i++)
+		if (isprime(i))
+			setbit(s, i);
+	return mkset(s);
+}
+
+define set_max(a) = highbit(a.s);
+
+define set_min(a) = lowbit(a.s);
+
+define set_not(a) = !a.s;
+
+define set_cmp(a,b)
+{
+	if (isset(a) && isset(b))
+		return a.s != b.s;
+	return 1;
+}
+
+define set_rel(a,b)
+{
+	local c;
+
+	if (a == b)
+		return 0;
+	if (isset(a)) {
+		if (isset(b)) {
+			c = a & b;
+			if (c == a)
+				return -1;
+			if (c == b)
+				return 1;
+			return;
+		}
+		if (!isint(b))
+			return set_rel(a, set(b));
+	}
+	if (isint(a))
+		return set_rel(set(a), b);
+}
+
+
+define set_or(a, b)
+{
+	if (isset(a)) {
+		if (isset(b))
+			return obj set = {a.s | b.s};
+		if (isint(b))
+			return a | set(b);
+	}
+	if (isint(a))
+		return set(a) | b;
+	return newerror("Bad argument for set_or");
+}
+
+define set_and(a, b)
+{
+	if (isint(a))
+		return set(a) & b;
+	if (isint(b))
+		return a & set(b);
+	if (!isset(a) || !isset(b))
+		return newerror("Bad argument for set_and");
+	return mkset(a.s & b.s);
+}
+
+
+define set_comp(a) = full() \ a;
+
+define set_setminus(a,b)
+{
+	if (isint(a))
+		return set(a) \ b;
+	if (isint(b))
+		return a \ set(b);
+	if (!isset(a) || !isset(b))
+		return newerror("Bad argument for set_setminus");
+	return mkset(a.s \ b.s);
+}
+
+
+define set_xor(a,b)
+{
+	if (isint(a))
+		return set(a) ~ b;
+	if (isint(b))
+		return a ~ set(b);
+	if (!isset(a) || !isset(b))
+		return newerror("Bad argument for set_xor");
+	return mkset(a.s ~ b.s);
+}
+
+define set_content(a) = #a.s;
+
+define set_add(a, b)
+{
+	local s, i, j, m, n;
+
+	if (isint(a))
+		return set(a) + b;
+	if (isint(b))
+		return a + set(b);
+	if (!isset(a) || !isset(b))
+		return newerror("Bad argument for set_add");
+	if (!a || !b)
+		return empty();
+	m = highbit(a.s);
+	n = highbit(b.s);
+	s = M * char(0);
+	for (i = 0; i <= m; i++)
+		if (isin(a, i))
+			for (j = 0; j <= n && i + j < N; j++)
+				if (isin(b, j))
+					setbit(s, i + j);
+	return mkset(s);
+}
+
+define set_sub(a,b)
+{
+	local s, i, j, m, n;
+
+	if (isint(b))
+		return a - set(b);
+	if (isint(a))
+		return set(a) - b;
+	if (isset(a) && isset(b)) {
+		if (!a || !b)
+			return empty();
+		m = highbit(a.s);
+		n = highbit(b.s);
+		s = M * char(0);
+		for (i = 0; i <= m; i++)
+			if (isin(a, i))
+				for (j = 0; j <= n && j <= i; j++)
+					if (isin(b, j))
+						setbit(s, i - j);
+		return mkset(s);
+	}
+	return newerror("Bad argument for set_sub");
+}
+
+define set_mul(a, b)
+{
+	local s, i, j, m, n;
+
+	if (isset(a)) {
+		s = M * char(0);
+		m = highbit(a.s);
+		if (isset(b)) {
+			if (!a || !b)
+				return empty();
+			n = highbit(b.s);
+			for (i = 0; i <= m; ++i)
+				if (isin(a, i))
+					for (j = 1; j <= n && i * j < N; ++j)
+						if (isin(b, j))
+							setbit(s, i * j);
+			return mkset(s);
+		}
+		if (isint(b)) {
+			if (b == 0) {
+				if (a)
+					return set(0);
+				return empty();
+			}
+			s = M * char(0);
+			for (i = 0; i <= m && b * i < N; ++i)
+				if (isin(a, i))
+					setbit(s, b * i);
+			return mkset(s);
+		}
+	}
+	if (isint(a))
+		return b * a;
+	return newerror("Bad argument for set_mul");
+}
+
+define set_square(a)
+{
+	local s, i, m;
+
+	s = M * char(0);
+	m = highbit(a.s);
+	for (i = 0; i <= m && i^2 < N; ++i)
+		if (bit(a.s, i))
+			setbit(s, i^2);
+	return mkset(s);
+}
+
+define set_pow(a, n)
+{
+	local s, i, m;
+
+	if (!isint(n) || n < 0)
+		quit "Bad exponent for set_power";
+	s = M * char(0);
+	m = highbit(a.s);
+	for (i = 0; i <= m && i^n < N; ++i)
+		if (bit(a.s, i))
+			setbit(s, i^n);
+	return mkset(s);
+}
+
+define set_sum(a)
+{
+	local v, m, i;
+
+	v = 0;
+	m = highbit(a.s);
+	for (i = 0; i <= m; ++i)
+		if (bit(a.s, i))
+			v += i;
+	return v;
+}
+
+define set_plus(a) = set_sum(a);
+
+define interval(a, b)
+{
+	local i, j, s;
+	static tail = "\0\1\3\7\17\37\77\177\377";
+
+	if (!isint(a) || !isint(b))
+		quit "Non-integer argument for interval";
+	if (a > b)
+		swap(a, b);
+	if (b < 0 || a >= N)
+		return empty();
+	a = max(a, 0);
+	b = min(b, N-1);
+	i = quo(a, 8, 0);
+	j = quo(b, 8, 0);
+	s = M * char(0);
+	if (i == j) {
+		s[i] = tail[b + 1 - 8 * i] \ tail[a - 8 * i];
+		return mkset(s);
+	}
+	s[i] = ~tail[a - 8 * i];
+	while (++i < j)
+		s[i] = -1;
+	s[j] = tail[b + 1 - 8 * j];
+	return mkset(s);
+}
+
+define isinterval(a)
+{
+	local i, max, s;
+
+	if (!isset(a))
+		quit "Non-set argument for isinterval";
+
+	s = a.s;
+	if (!s)
+		return 0;
+	for (i = lowbit(s) + 1, max = highbit(s); i < max; i++)
+		if (!bit(s, i))
+			return 0;
+	return 1;
+}
+
+define set_mod(a, b)
+{
+	local s, m, i, j;
+
+	if (isset(a) && isint(b)) {
+		s = M * char(0);
+		m = highbit(a.s);
+		for (i = 0; i <= m; i++)
+			if (bit(a.s, i))
+				for (j = 0; j < N; j++)
+					if (meq(i, j, b))
+						setbit(s, j);
+		return mkset(s);
+	}
+	return newerror("Bad argument for set_mod");
+}
+
+define randset(n, a, b)
+{
+	local m, s, i;
+
+	if (isnull(a))
+		a = 0;
+	if (isnull(b))
+		b = N - 1;
+	if (!isint(n) || !isint(a) || !isint(b) || n < 0 || a < 0 || b < 0)
+		quit "Bad argument for randset";
+	if (a > b)
+		swap(a, b);
+	m = b - a + 1;
+	if (n > m)
+		return newerror("Too many numbers specified for randset");
+	if (2 * n > m)
+		return interval(a,b) \ randset(m - n, a, b);
+	++b;
+	s = M * char(0);
+	while (n-- > 0) {
+		do
+			i = rand(a, b);
+		while
+			(bit(s, i));
+		setbit(s, i);
+	}
+	return mkset(s);
+}
+
+define polyvals(L, A)
+{
+	local s, m, v, i;
+
+	if (!islist(L))
+		quit "Non-list first argument for polyvals";
+	if (!isset(A))
+		quit "Non-set second argument for polyvals";
+	m = highbit(A.s);
+	s = M * char(0);
+	for (i = 0; i <= m; i++)
+		if (bit(A.s, i)) {
+			v = poly(L,i);
+			if (v >> 0 && v < N)
+				setbit(s, v);
+		}
+	return mkset(s);
+}
+
+define polyvals2(L, A, B)
+{
+	local s1, s2, s, m, n, i, j, v;
+
+	s1 = A.s;
+	s2 = B.s;
+	m = highbit(s1);
+	n = highbit(s2);
+	s = M * char(0);
+	for (i = 0; i <= m; i++)
+		if (bit(s1, i))
+			for (j = 0; j <= n; j++)
+				if (bit(s2, j)) {
+					v = poly(L, i, j);
+					if (v >= 0 && v < N)
+						setbit(s, v);
+				}
+	return mkset(s);
+}
+
+define set_print(a)
+{
+	local i, s, m;
+
+	s = a.s;
+	i = lowbit(s);
+	print "set(":;
+	if (i >= 0) {
+		print i:;
+		m = highbit(s);
+		while (++i <= m)
+			if (bit(s, i))
+				print ",":i:;
+	}
+	print ")",;
+}
+
+local N, M;	/* End scope of static variables N, M */

cal/pell.cal

@@ -0,0 +1,94 @@
+/*
+ * pell - solve Pell's equation
+ *
+ * Copyright (C) 1999  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: pell.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/pell.cal,v $
+ *
+ * Under source code control:	1990/02/15 01:50:34
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * Solve Pell's equation; Returns the solution X to: X^2 - D * Y^2 = 1.
+ * Type the solution to pells equation for a particular D.
+ */
+
+
+define pell(D)
+{
+	local X, Y;
+
+	X = pellx(D);
+	if (isnull(X)) {
+		print "D=":D:" is square";
+		return;
+	}
+	Y = isqrt((X^2 - 1) / D);
+	print X : "^2 - " : D : "*" : Y : "^2 = " : X^2 - D*Y^2;
+}
+
+
+/*
+ * Function to solve Pell's equation
+ * Returns the solution X to:
+ *	X^2 - D * Y^2 = 1
+ */
+define pellx(D)
+{
+	local R, Rp, U, Up, V, Vp, A, T, Q1, Q2, n;
+	local mat ans[2,2];
+	local mat tmp[2,2];
+
+	R = isqrt(D);
+	Vp = D - R^2;
+	if (Vp == 0)
+		return;
+	Rp = R + R;
+	U = Rp;
+	Up = U;
+	V = 1;
+	A = 0;
+	n = 0;
+	ans[0,0] = 1;
+	ans[1,1] = 1;
+	tmp[0,1] = 1;
+	tmp[1,0] = 1;
+	do {
+		T = V;
+		V = A * (Up - U) + Vp;
+		Vp = T;
+		A = U // V;
+		Up = U;
+		U = Rp - U % V;
+		tmp[0,0] = A;
+		ans *= tmp;
+		n++;
+	} while (A != Rp);
+	Q2 = ans[[1]];
+	Q1 = isqrt(Q2^2 * D + 1);
+	if (isodd(n)) {
+		T = Q1^2 + D * Q2^2;
+		Q2 = Q1 * Q2 * 2;
+		Q1 = T;
+	}
+	return Q1;
+}

cal/pi.cal

@@ -0,0 +1,147 @@
+/*
+ * pi - various routines to calculate pi
+ *
+ * Copyright (C) 1999-2004  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: pi.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/pi.cal,v $
+ *
+ * Under source code control:	1991/05/22 21:56:37
+ * File existed as early as:	1991
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * Calculate pi within the specified epsilon using the quartic convergence
+ * iteration.
+ */
+
+
+define qpi(epsilon)
+{
+	local niter, yn, ym, tm, an, am, t, tn, sqrt2, epsilon2, count, digits;
+	local bits, bits2;
+
+	if (isnull(epsilon))
+		epsilon = epsilon();
+	digits = digits(1/epsilon);
+	if	(digits <=  8) { niter = 1; epsilon =	1e-8; }
+	else if (digits <= 40) { niter = 2; epsilon =  1e-40; }
+	else if (digits <= 170) { niter = 3; epsilon = 1e-170; }
+	else if (digits <= 693) { niter = 4; epsilon = 1e-693; }
+	else {
+		niter = 4;
+		t = 693;
+		while (t < digits) {
+			++niter;
+			t *= 4;
+		}
+	}
+	epsilon2 = epsilon/(digits/10 + 1);
+	digits = digits(1/epsilon2);
+	sqrt2 = sqrt(2, epsilon2);
+	bits = abs(ilog2(epsilon)) + 1;
+	bits2 = abs(ilog2(epsilon2)) + 1;
+	yn = sqrt2 - 1;
+	an = 6 - 4 * sqrt2;
+	tn = 2;
+	for (count = 0; count < niter; ++count) {
+		ym = yn;
+		am = an;
+		tn *= 4;
+		t = sqrt(sqrt(1-ym^4, epsilon2), epsilon2);
+		yn = (1-t)/(1+t);
+		an = (1+yn)^4*am-tn*yn*(1+yn+yn^2);
+		yn = bround(yn, bits2);
+		an = bround(an, bits2);
+	}
+	return (bround(1/an, bits));
+}
+
+
+/*
+ * Print digits of PI forever, neatly formatted, using calc.
+ *
+ * Written by Klaus Alexander Seistrup <klaus@seistrup.dk>
+ * on a dull Friday evening in November 1999.
+ *
+ * Inspired by an algorithm conceived by Lambert Meertens.
+ *
+ * See also the ABC Programmer's Handbook, by Geurts, Meertens & Pemberton,
+ * published by Prentice-Hall (UK) Ltd., 1990.
+ *
+ */
+
+define piforever()
+{
+	local k = 2;
+	local a = 4;
+	local b = 1;
+	local a1 = 12;
+	local b1 = 4;
+	local a2, b2, p, q, d, d1;
+	local stdout = files(1);
+	local first = 1, row = -1, col = 0;
+
+	while (1) {
+		/*
+		* Next approximation
+		*/
+		p = k * k;
+		q = k + ++k;
+
+		a2 = a;
+		b2 = b;
+
+		a = a1;
+		a1 = p * a2 + q * a1;
+		b = b1;
+		b1 = p * b2 + q * b1;
+
+		/*
+		* Print common digits
+		*/
+		d = a // b;
+		d1 = a1 // b1;
+
+		while (d == d1) {
+			if (first) {
+				printf("%d.", d);
+				first = 0;
+			} else {
+				if (!(col % 50)) {
+					printf("\n");
+					col = 0;
+					if (!(++row % 20)) {
+						printf("\n");
+						row = 0;
+					}
+				}
+				printf("%d", d);
+				if (!(++col % 10))
+					printf(" ");
+			}
+			a = 10 * (a % b);
+			a1 = 10 * (a1 % b1);
+			d = a // b;
+			d1 = a1 // b1;
+		}
+		fflush(stdout);
+	}
+}

cal/pix.cal

@@ -0,0 +1,71 @@
+/*
+ * pix - iterative method of finding the number of primes less than x
+ *
+ * Copyright (C) 1999  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: pix.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/pix.cal,v $
+ *
+ * Under source code control:	1996/07/09 03:14:14
+ * File existed as early as:	1996
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * Here is an iterative method of finding the number of primes less than
+ * or equal to a given number.	This method is from "Computer Recreations"
+ * June 1996 issue of Scientific American.
+ *
+ * NOTE: For reasonable values of x, the builtin function pix(x) is
+ *	 much faster.  This code is provided because the method
+ *	 is interesting.
+ */
+
+
+define pi_of_x(x)
+{
+	local An;	/* A(n) */
+	local An1;	/* A(n-1) */
+	local An2;	/* A(n-2) */
+	local An3;	/* A(n-3) */
+	local primes;	/* number of primes found */
+	local n;	/* loop counter */
+
+	/*
+	 * setup
+	 */
+	An1 = 2;
+	An2 = 0;
+	An3 = 3;
+	primes = 1;
+
+	/*
+	 * main A(n+1)=A(n-1)+A(n-2) sequence loop
+	 */
+	for (n = 3; n < x; ++n) {
+		An = An2 + An3;
+		An3 = An2;
+		An2 = An1;
+		An1 = An;
+		if (An % n == 0)
+			++primes;
+	}
+	return primes;
+}

cal/pollard.cal

@@ -0,0 +1,52 @@
+/*
+ * pollard - factor using Pollard's p-1 method
+ *
+ * Copyright (C) 1999  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: pollard.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/pollard.cal,v $
+ *
+ * Under source code control:	1991/05/22 21:56:37
+ * File existed as early as:	1991
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+define pfactor(N, B, ai, af)
+{
+	local	a, k, i, d;
+
+	if (isnull(B))
+		B = 1000;
+	if (isnull(ai))
+		ai = 2;
+	if (isnull(af))
+		af = ai + 20;
+	k = lcmfact(B);
+	d = lfactor(N, B);
+	if (d > 1)
+		return d;
+	for (a = ai; a <= af; a++) {
+		i = pmod(a, k, N);
+		d = gcd(i - 1, N);
+		if ((d > 1) && (d != N))
+			return d;
+	}
+	return 1;
+}

cal/poly.cal

@@ -1,6 +1,35 @@
+/*
+ * poly - calculate with polynomials of one variable
+ *
+ * Copyright (C) 1999  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: poly.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/poly.cal,v $
+ *
+ * Under source code control:	1990/02/15 01:50:35
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
 /*
  * A collection of functions designed for calculations involving
- * 	polynomials in one variable (by Ernest W. Bowen).
+ *	polynomials in one variable (by Ernest W. Bowen).
  *
  * On starting the program the independent variable has identifier x
  *	and name "x", i.e. the user can refer to it as x, the
@@ -24,25 +53,25 @@
  *	would assign to q a number value.  As with number expressions
  *	involving operations, the expression used to define the
  *	polynomial is usually lost; in the above example, the normal
- *	computer display for p will be  x^2 - 2x + 1.  Different
+ *	computer display for p will be	x^2 - 2x + 1.  Different
  *	identifiers may of course have the same polynomial value.
  *
  * The polynomial we think of as a_0 + a_1 * x + ... + a_n * x^n,
  *	for number coefficients a_0, a_1, ... a_n may also be
- *	constructed as pol(a_0, a_1, ..., a_n).  Note that here the
+ *	constructed as pol(a_0, a_1, ..., a_n).	 Note that here the
  *	coefficients are to be in ascending power order.  The independent
  *	variable is pol(0,1), so to use t, say, as an identifier for
  *	this, one may assign  t = pol(0,1).  To simultaneously specify
  *	an identifier and a name for the independent variable, there is
- *	the instruction var, used as in identifier = var(name).  For
+ *	the instruction var, used as in identifier = var(name).	 For
  *	example, to use "t" in the way "x" is initially, one may give
- *	the instruction  t = var("t").
+ *	the instruction	 t = var("t").
  *
  * There are four parameters pmode, order, iod and ims for controlling
  *	the format in which polynomials are displayed.
  *	The parameter pmode may have values "alg" or "list": the
  *	former gives a display as an algebraic formula, while
- *	the latter only lists the coefficients.  Whether the terms or
+ *	the latter only lists the coefficients.	 Whether the terms or
  *	coefficients are in ascending or descending power order is
  *	controlled by order being "up" or "down".  If the
  *	parameter iod (for integer-only display), the polynomial
@@ -69,7 +98,7 @@
  *	polynomial, list or matrix were a function.  For example,
  *	if a = 1 + x^2, a(2) will return the value 5, just as if
  *			define a(t) = 1 + t^2;
- *	had been used.   However, when the polynomial definition is
+ *	had been used.	 However, when the polynomial definition is
  *	used, changing the polynomial a will change a(t) to the value
  *	of the new polynomial at t.  For example,
  *	after
@@ -87,7 +116,7 @@
  * Matrices with polynomial elements may be added, subtracted and
  *	multiplied as long as the usual rules for compatibility are
  *	observed.  Also, matrices may be multiplied by polynomials,
- *	i.e. if p is a 	polynomial and A a matrix whose elements
+ *	i.e. if p is a	polynomial and A a matrix whose elements
  *	may be numbers or polynomials, p * A returns the matrix of
  *	the same shape as A with each element multiplied by p.
  *	Square matrices may also be 'substituted for the variable' in
@@ -106,7 +135,7 @@
  * Functions defined include:
  *
  *	monic(a) returns the monic multiple of a, i.e., if a != 0,
- *		the multiple of	a with leading coefficient 1
+ *		the multiple of a with leading coefficient 1
  *	conj(a) returns the complex conjugate of a
  *	ispmult(a,b) returns 1 or 0 according as a is or is not
  *		a polynomial multiple of b
@@ -119,7 +148,7 @@
  *		by Newtonian divided difference interpolation, where
  *		X is a list of x-values, Y a list of corresponding
  *		y-values.  If t is omitted, the interpolating
- *		polynomial is returned.  A y-value may be replaced by
+ *		polynomial is returned.	 A y-value may be replaced by
  *		list (y, y_1, y_2, ...), where y_1, y_2, ... are
  *		the reduced derivatives at the corresponding x;
  *		i.e. y_r is the r-th derivative divided by fact(r).
@@ -170,6 +199,7 @@
  *	should return the zero m x m matrix.
  */
 
+
 obj poly {p};
 
 define pol() {
@@ -328,7 +358,7 @@ define poly_cmp(a,b) {
 	local sa, sb;
 	sa = findlist(a);
 	sb=findlist(b);
-	return  (sa != sb);
+	return	(sa != sb);
 }
 
 define poly_mul(a,b) {
@@ -471,8 +501,9 @@ define plist(s) {
 define deg(a) = size(a.p) - 1;
 
 define polydiv(a,b) {
-	local q, r, d, u, i, m, n, sa, sb, sq;
+	local d, u, i, m, n, sa, sb, sq;
-	obj poly q, r;
+	local obj poly q;
+	local obj poly r;
 	sa=findlist(a); sb = findlist(b); sq = list();
 	m=size(sa)-1; n=size(sb)-1;
 	if (n<0) quit "Zero divisor";
@@ -547,7 +578,7 @@ define D(a, n) {
 	local i,j,v;
 	if (isnull(n)) n = 1;
 	if (!isint(n) || n < 1) quit "Bad order for derivative";
- 	if (ismat(a)) {
+	if (ismat(a)) {
 		v = a;
 		for (i = matmin(a,1); i <= matmax(a,1); i++)
 			for (j = matmin(a,2); j <= matmax(a,2); j++)
@@ -561,7 +592,7 @@ define D(a, n) {
 define Dp(a,n) {
 	local i, v;
 	if (n > 1) return Dp(Dp(a, n-1), 1);
- 	obj poly v;
+	obj poly v;
 	v.p=list();
 	for (i=1; i<size(a.p); i++) append (v.p, i*a.p[[i]]);
 	return v;
@@ -687,42 +718,6 @@ a=pol(1,4,4,2,3,1);
 b=pol(5,16,8,1);
 c=pol(1+2i,3+4i,5+6i);
 
-global lib_debug;
+if (config("resource_debug") & 3) {
-if (lib_debug >= 0) {
 	print "obj poly {p} defined";
-	print "pol() defined";
-	print "poly_print(a) defined";
-	print "poly_add(a, b) defined";
-	print "poly_sub(a, b) defined";
-	print "poly_mul(a, b) defined";
-	print "poly_div(a, b) defined";
-	print "poly_quo(a,b) defined";
-	print "poly_mod(a,b) defined";
-	print "poly_neg(a) defined";
-	print "poly_conj(a) defined";
-	print "poly_cmp(a,b) defined";
-	print "iszero(a) defined";
-	print "plist(a) defined";
-	print "listmul(a,b) defined";
-	print "ev(a,t) defined";
-	print "evp(s,t) defined";
-	print "ispoly(a) defined";
-	print "isstring(a) defined";
-	print "var(name) defined";
-	print "pcoeff(a) defined";
-	print "pterm(a,n) defined";
-	print "deg(a) defined";
-	print "polydiv(a,b) defined";
-	print "D(a,n) defined";
-	print "Dp(a,n) defined";
-	print "pgcd(a,b) defined";
-	print "plcm(a,b) defined";
-	print "monic(a) defined";
-	print "pfgcd(a,b) defined";
-	print "interp(X,Y,x) defined";
-	print "makediffs(X,Y) defined";
-	print "evalfd(T,x) defined";
-	print "mdet(A) defined";
-	print "M(A,n,I,J) defined";
-	print "mprint(A) defined";
 }

cal/prompt.cal

@@ -1,10 +1,32 @@
 /*
- * Copyright (c) 1995 Ernest Bowen
+ * prompt - eemonstration of some uses of prompt() and eval()
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * By: Ernest Bowen <ernie@neumann.une.edu.au>
+ * Copyright (C) 1999  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: prompt.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/prompt.cal,v $
+ *
+ * Under source code control:	1995/12/18 04:43:25
+ * File existed as early as:	1995
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
+
 /*
  * Demonstration of some uses of prompt() and eval().
  *
@@ -36,14 +58,14 @@
  *		3; print sum^2;
  *
  * (Here the second line creates x as a global variable; the local
- * variable x in the fourth line has no effect on the global x.  In
+ * variable x in the fourth line has no effect on the global x.	 In
  * the last three lines, sum is the sum of numbers already entered, so
  * the third last line doubles the value of sum.  The value returned
  * by "print sum^2;" is the null value, so the second last line adds
  * nothing to sum.  The last line returns the value 3, i.e. the last
  * non-null value found for the expressions separated by semicolons,
  * so sum will be increased by 3 after the "print sum^2;" command
- * is executed.  xxx The terminating semicolon is essential in the
+ * is executed.	 xxx The terminating semicolon is essential in the
  * last two lines.  A command like eval("print 7;") is acceptable to
  * calc but eval("print 7") causes an exit from calc. xxx)
  *
@@ -57,10 +79,11 @@
  *	"sin(x)", "x^2 + 3*x", "exp(x, 1e-5)".
  *
  * Values of the function so defined are returned for values of x
- * entered in reponse to the ? prompt.  Operation is terminated by
+ * entered in reponse to the ? prompt.	Operation is terminated by
  * entering "end", "exit" or "quit".
  */
 
+
 define adder() {
 	global sum = 0;
 	local s, t;
@@ -78,7 +101,7 @@ define adder() {
 	}
 }
 
-global x;
+global prompt_x;
 
 define showvalues(str) {
 	local s;
@@ -86,17 +109,11 @@ define showvalues(str) {
 		s = prompt("? ");
 		if (s == "end")
 			break;
-		x = eval(s);
+		prompt_x = eval(s);
-		if (!isnum(x)) {
+		if (!isnum(prompt_x)) {
 			print "Please enter a number";
 			continue;
 		}
 		print "\t":eval(str);
 	}
 }
-
-global lib_debug;
-if (lib_debug >= 0) {
-	print "adder() defined";
-	print "showvalues(str) defined";
-}

cal/psqrt.cal

@@ -0,0 +1,74 @@
+/*
+ * psqrt - calculate square roots modulo a prime
+ *
+ * Copyright (C) 1999  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: psqrt.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/psqrt.cal,v $
+ *
+ * Under source code control:	1990/02/15 01:50:35
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * Returns null if number is not prime or if there is no square root.
+ * The smaller square root is always returned.
+ */
+
+
+define psqrt(u, p)
+{
+	local	p1, q, n, y, r, v, w, t, k;
+
+	p1 = p - 1;
+	r = lowbit(p1);
+	q = p >> r;
+	t = 1 << (r - 1);
+	for (n = 2; ; n++) {
+		if (ptest(n, 1) == 0)
+			continue;
+		y = pmod(n, q, p);
+		k = pmod(y, t, p);
+		if (k == 1)
+			continue;
+		if (k != p1)
+			return;
+		break;
+	}
+	t = pmod(u, (q - 1) / 2, p);
+	v = (t * u) % p;
+	w = (t^2 * u) % p;
+	while (w != 1) {
+		k = 0;
+		t = w;
+		do {
+			k++;
+			t = t^2 % p;
+		} while (t != 1);
+		if (k == r)
+			return;
+		t = pmod(y, 1 << (r - k - 1), p);
+		y = t^2 % p;
+		v = (v * t) % p;
+		w = (w * y) % p;
+		r = k;
+	}
+	return min(v, p - v);
+}

cal/qtime.cal

@@ -0,0 +1,90 @@
+/*
+ * qtime - Display time as English sentence
+ *
+ * Copyright (C) 1999  Klaus Alexander Seistrup and Landon Curt Noll
+ *
+ * Written by: Klaus Alexander Seistrup <kseis@magnetic-ink.dk>
+ * With mods by: Landon Curt Noll <http://www.isthe.com/chongo/>
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: qtime.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/qtime.cal,v $
+ *
+ * Under source code control:	1999/10/13 04:10:33
+ * File existed as early as:	1999
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * usage:
+ *	qtime(utc_hr_offset)
+ *
+ *	utc_hr_offset	Offset from UTC in hours.
+ *
+ * See:
+ *	http://www.magnetic-ink.dk/download/qtime.html
+ *
+ * for examples of qtime() written on other languages.
+ */
+
+
+/*
+ * qtime - Display time as English sentence
+ */
+define qtime(utc_hr_offset)
+{
+	static mat hr[12] = {
+	  "twelve", "one", "two", "three", "four", "five",
+	  "six", "seven", "eight", "nine", "ten", "eleven"
+	};
+	static mat mn[7] = {
+	  "", "five ", "ten ", "a quarter ", "twenty ", "twenty-five ", "half "
+	};
+	static mat ny[5] = {
+	  "nearly ", "almost ", "", "just after ", "after "
+	};
+	static mat up[3] = {
+	  "to ", "", "past "
+	};
+	local adj_mins = (((time() + utc_hr_offset*3600) % 86400) + 30)//60+27;
+	local hours = (adj_mins // 60) % 12;
+	local minutes = adj_mins % 60;
+	local almost =	minutes % 5;
+	local divisions = (minutes // 5) - 5;
+	local to_past_idx =	 divisions > 0 ? 1 : 0;
+
+	if (divisions < 0) {
+		divisions = -divisions;
+		to_past_idx = -1;
+	}
+	++to_past_idx;
+
+	/*
+	 * Print the English sentence
+	 *
+	 * We avoid forward and back quotes just to show that the char()
+	 * builtin function can be used in conjunction with a printf.
+	 */
+	printf("It%cs %s%s%s%s",
+	       char(0x27), ny[almost], mn[divisions],
+	       up[to_past_idx], hr[hours]);
+	if (divisions == 0)
+		printf(" o%cclock", char(0x27));
+	print ".";
+}

cal/quat.cal

@@ -1,8 +1,33 @@
 /*
- * Copyright (c) 1995 David I. Bell
+ * quat - alculate using quaternions of the form: a + bi + cj + dk
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
+ * Copyright (C) 1999  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: quat.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/quat.cal,v $
+ *
+ * Under source code control:	1990/02/15 01:50:35
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
  * Routines to handle quaternions of the form:
  *	a + bi + cj + dk
  *
@@ -11,6 +36,7 @@
  * Where s is a scalar and v is a vector of size 3.
  */
 
+
 obj quat {s, v};		/* definition of the quaternion object */
 
 
@@ -195,22 +221,6 @@ define quat_shift(a, b)
 	return x.s;
 }
 
-global lib_debug;
+if (config("resource_debug") & 3) {
-if (lib_debug >= 0) {
     print "obj quat {s, v} defined";
-    print "quat(a, b, c, d) defined";
-    print "quat_print(a) defined";
-    print "quat_norm(a) defined";
-    print "quat_abs(a, e) defined";
-    print "quat_conj(a) defined";
-    print "quat_add(a, e) defined";
-    print "quat_sub(a, e) defined";
-    print "quat_inc(a) defined";
-    print "quat_dec(a) defined";
-    print "quat_neg(a) defined";
-    print "quat_mul(a, b) defined";
-    print "quat_div(a, b) defined";
-    print "quat_inv(a) defined";
-    print "quat_scale(a, b) defined";
-    print "quat_shift(a, b) defined";
 }

cal/randbitrun.cal

@@ -1,30 +1,38 @@
 /*
- * randbitrun - check rand bit run lengths
+ * randbitrun - check rand bit run lengths of the a55 generator
  *
+ * Copyright (C) 1999  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: randbitrun.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/randbitrun.cal,v $
+ *
+ * Under source code control:	1995/02/13 03:43:11
+ * File existed as early as:	1995
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
  * We will use randbit(1) to generate a stream if single bits.
  * The odds that we will have n bits the same in a row is 1/2^n.
  */
-/*
+
- * Copyright 1995 by Landon Curt Noll.  All Rights Reserved.
- *
- * Permission to use, copy, modify, and distribute this software and
- * its documentation for any purpose and without fee is hereby granted,
- * provided that the above copyright, this permission notice, and the
- * disclaimer below appear in all of the following:
- *
- * 	* supporting documentation
- * 	* source copies
- * 	* source works derived from this source
- * 	* binaries derived from this source or from derived source
- *
- * LANDON CURT NOLL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL LANDON CURT NOLL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
- * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
 
 define randbitrun(run_cnt)
 {
@@ -36,7 +44,7 @@ define randbitrun(run_cnt)
     local last;			/* last random number */
     local current;		/* current random number */
     local MAX_RUN = 18;		/* max run we will keep track of */
-    local mat tally[1:MAX_RUN];	/* tally of length of a rise run of 'x' */
+    local mat tally[1:MAX_RUN]; /* tally of length of a rise run of 'x' */
     local mat prob[1:MAX_RUN];	/* prob[x] = probability of 'x' length run */
 
     /*
@@ -77,7 +85,7 @@ define randbitrun(run_cnt)
 	/* look for a run break */
 	if (current != last) {
 
-	    /*  record the stats */
+	    /*	record the stats */
 	    if (run > max_run) {
 		max_run = run;
 	    }
@@ -112,8 +120,3 @@ define randbitrun(run_cnt)
     printf("length>%d\t\t\t\t\tcount=%d\n", MAX_RUN, long_run_cnt);
     printf("max length=%d\n", max_run);
 }
-
-global lib_debug;
-if (lib_debug >= 0) {
-    print "randbitrun([run_length]) defined";
-}

cal/randmprime.cal

@@ -1,31 +1,35 @@
 /*
  * randmprime - generate a random prime of the form h*2^n-1
  *
- * Copyright (c) 1995 by Landon Curt Noll.  All Rights Reserved.
+ * Copyright (C) 1999  Landon Curt Noll
  *
- * Permission to use, copy, modify, and distribute this software and
+ * Calc is open software; you can redistribute it and/or modify it under
- * its documentation for any purpose and without fee is hereby granted,
+ * the terms of the version 2.1 of the GNU Lesser General Public License
- * provided that the above copyright, this permission notice and text
+ * as published by the Free Software Foundation.
- * this comment, and the disclaimer below appear in all of the following:
  *
- *	supporting documentation
+ * Calc is distributed in the hope that it will be useful, but WITHOUT
- *	source copies
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- *	source works derived from this source
+ * or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU Lesser General
- *	binaries derived from this source or from derived source
+ * Public License for more details.
  *
- * LANDON CURT NOLL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * A copy of version 2.1 of the GNU Lesser General Public License is
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
+ * distributed with calc under the filename COPYING-LGPL.  You should have
- * EVENT SHALL LANDON CURT NOLL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
  *
- * chongo was here	/\../\		chongo@toad.com
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: randmprime.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/randmprime.cal,v $
+ *
+ * Under source code control:	1994/03/14 23:11:21
+ * File existed as early as:	1994
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
 
+
 /* obtain our required libs */
-read -once "cryrand.cal"
 read -once "lucas.cal"
 
 /*
@@ -33,7 +37,7 @@ read -once "lucas.cal"
  *
  * given:
  *	bits	minimum bits in prime to return
- *	seed	random seed for scryrand()
+ *	seed	random seed for srandom()
  *	[dbg]	if given, enable debugging
  *
  * returns:
@@ -62,15 +66,15 @@ randmprime(bits, seed, dbg)
 	bits = 1;
     }
     if (param(0) == 2 || dbg < 0) {
-    	dbg = 0;
+	dbg = 0;
     }
 
     /* seed generator */
-    tmp = scryrand(seed);
+    tmp = srandom(seed, 13);
 
     /* determine initial h and n values */
     n = random(bits>>1, highbit(bits)+bits>>1+1);
-    h = cryrand(n);
+    h = randombit(n);
     h += iseven(h);
     while (highbit(h) >= n) {
        ++n;
@@ -84,8 +88,8 @@ randmprime(bits, seed, dbg)
      * loop until we find a prime
      */
     if (dbg >= 1) {
-	start = runtime();
+	start = usertime();
-	init = runtime();
+	init = usertime();
 	plush = 0;
 	print "DEBUG1: testing (h+" : plush : ")*2^" : n : "-1";
     }
@@ -93,8 +97,8 @@ randmprime(bits, seed, dbg)
 
 	/* bump h, and n if needed */
 	if (dbg >= 2) {
-	    stop = runtime();
+	    stop = usertime();
-	    print "DEBUG2: last test:", stop-start, "   total time:", stop-init;
+	    print "DEBUG2: last test:", stop-start, "	total time:", stop-init;
 	}
 	if (dbg >= 1) {
 	    print "DEBUG1: composite: (h+" : plush : ")*2^" : n : "-1";
@@ -112,7 +116,7 @@ randmprime(bits, seed, dbg)
 
     /* found a prime */
     if (dbg >= 2) {
-	stop = runtime();
+	stop = usertime();
 	print "DEBUG2: last test:", stop-start, "   total time:", stop-init;
 	print "DEBUG3: " : h : "*2^" : n : "-1 is prime";
     }
@@ -130,8 +134,3 @@ randmprime(bits, seed, dbg)
     }
     return ret;
 }
-
-global lib_debug;
-if (lib_debug >= 0) {
-    print "randmprime(bits, seed [,dbg]) defined";
-}

cal/randombitrun.cal

@@ -0,0 +1,122 @@
+/*
+ * randombitrun - check rand bit run lengths of random()
+ *
+ * Copyright (C) 1999  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: randombitrun.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/randombitrun.cal,v $
+ *
+ * Under source code control:	1995/02/13 03:43:11
+ * File existed as early as:	1995
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * We will use randombit(1) to generate a stream if single bits.
+ * The odds that we will have n bits the same in a row is 1/2^n.
+ */
+
+
+define randombitrun(run_cnt)
+{
+    local i;			/* index */
+    local max_run;		/* longest run */
+    local long_run_cnt;		/* number of runs longer than MAX_RUN */
+    local run;			/* current run length */
+    local tally_sum;		/* sum of all tally values */
+    local last;			/* last random number */
+    local current;		/* current random number */
+    local MAX_RUN = 18;		/* max run we will keep track of */
+    local mat tally[1:MAX_RUN]; /* tally of length of a rise run of 'x' */
+    local mat prob[1:MAX_RUN];	/* prob[x] = probability of 'x' length run */
+
+    /*
+     * parse args
+     */
+    if (param(0) == 0) {
+	run_cnt = 65536;
+    }
+
+    /*
+     * run setup
+     */
+    max_run = 0;		/* no runs yet */
+    long_run_cnt = 0;		/* no long runs set */
+    current = randombit(1);	/* our first number */
+    run = 1;
+
+    /*
+     * compute the run length probabilities
+     *
+     * A bit run length of 'r' occurs with a probability of:
+     *
+     *			1/2^n;
+     */
+    for (i=1; i <= MAX_RUN; ++i) {
+	prob[i] = 1.0/(1<<i);
+    }
+
+    /*
+     * look at a number of random number trials
+     */
+    for (i=0; i < run_cnt; ++i) {
+
+	/* get our current number */
+	last = current;
+	current = randombit(1);
+
+	/* look for a run break */
+	if (current != last) {
+
+	    /*	record the stats */
+	    if (run > max_run) {
+		max_run = run;
+	    }
+	    if (run > MAX_RUN) {
+		++long_run_cnt;
+	    } else {
+		++tally[run];
+	    }
+
+	    /* start a new run */
+	    current = randombit(1);
+	    run = 1;
+
+	/* note the continuing run */
+	} else {
+	    ++run;
+	}
+    }
+    /* determine the number of runs found */
+    tally_sum = matsum(tally) + long_run_cnt;
+
+    /*
+     * print the stats
+     */
+    printf("random runbit test used %d values to produce %d runs\n",
+      run_cnt, tally_sum);
+    for (i=1; i <= MAX_RUN; ++i) {
+	printf("length=%d\tprob=%9.7f\texpect=%d \tcount=%d \terr=%9.7f\n",
+	  i, prob[i], round(tally_sum*prob[i]), tally[i],
+	  (tally[i] - round(tally_sum*prob[i]))/tally_sum);
+    }
+    printf("length>%d\t\t\t\t\tcount=%d\n", MAX_RUN, long_run_cnt);
+    printf("max length=%d\n", max_run);
+}

cal/randomrun.cal

@@ -0,0 +1,131 @@
+/*
+ * randomrun - perform a run test on random()
+ *
+ * Copyright (C) 1999  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: randomrun.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/randomrun.cal,v $
+ *
+ * Under source code control:	1997/02/19 03:35:59
+ * File existed as early as:	1997
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * If X(j) < X(j+1) < ... X(j+k) >= X(j+k+1), then we have a run of 'k'.
+ * We ignore the run breaker, X(j+k+1), and start with X(j+k+2) when
+ * considering a new run in order to make our runs chi independent.
+ *
+ * See Knuth's "Art of Computer Programming - 2nd edition",
+ * Volume 2 ("Seminumerical Algorithms"), Section 3.3.2.
+ * "G. Run test", pp. 65-68,
+ * "problem #14", pp. 74, 536.
+ *
+ * We use the suggestion in problem #14 to allow an application of the
+ * chi-square test and to make estimating the run length probs easy.
+ */
+
+
+define randomrun(run_cnt)
+{
+    local i;			/* index */
+    local max_run;		/* longest run */
+    local long_run_cnt;		/* number of runs longer than MAX_RUN */
+    local run;			/* current run length */
+    local tally_sum;		/* sum of all tally values */
+    local last;			/* last random number */
+    local current;		/* current random number */
+    local MAX_RUN = 9;		/* max run we will keep track of */
+    local mat tally[1:MAX_RUN]; /* tally of length of a rise run of 'x' */
+    local mat prob[1:MAX_RUN];	/* prob[x] = probability of 'x' length run */
+
+    /*
+     * parse args
+     */
+    if (param(0) == 0) {
+	run_cnt = 65536;
+    }
+
+    /*
+     * run setup
+     */
+    max_run = 0;		/* no runs yet */
+    long_run_cnt = 0;		/* no long runs set */
+    current = random();		/* our first number */
+    run = 1;
+
+    /*
+     * compute the run length probabilities
+     *
+     * A run length of 'r' occurs with a probability of:
+     *
+     *			1/r! - 1/(r+1)!
+     */
+    for (i=1; i <= MAX_RUN; ++i) {
+	prob[i] = 1.0/fact(i) - 1.0/fact(i+1);
+    }
+
+    /*
+     * look at a number of random number trials
+     */
+    for (i=0; i < run_cnt; ++i) {
+
+	/* get our current number */
+	last = current;
+	current = random();
+
+	/* look for a run break */
+	if (current < last) {
+
+	    /*	record the stats */
+	    if (run > max_run) {
+		max_run = run;
+	    }
+	    if (run > MAX_RUN) {
+		++long_run_cnt;
+	    } else {
+		++tally[run];
+	    }
+
+	    /* start a new run */
+	    current = random();
+	    run = 1;
+
+	/* note the continuing run */
+	} else {
+	    ++run;
+	}
+    }
+    /* determine the number of runs found */
+    tally_sum = matsum(tally) + long_run_cnt;
+
+    /*
+     * print the stats
+     */
+    printf("random run test used %d values to produce %d runs\n",
+      run_cnt, tally_sum);
+    for (i=1; i <= MAX_RUN; ++i) {
+	printf("length=%d\tprob=%9.7f\texpect=%d \tcount=%d \terr=%9.7f\n",
+	  i, prob[i], round(tally_sum*prob[i]), tally[i],
+	  (tally[i] - round(tally_sum*prob[i]))/tally_sum);
+    }
+    printf("length>%d\t\t\t\t\tcount=%d\n", MAX_RUN, long_run_cnt);
+    printf("max length=%d\n", max_run);
+}

cal/randrun.cal

@@ -1,6 +1,33 @@
 /*
  * randrun - perform a run test on rand()
  *
+ * Copyright (C) 1999  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: randrun.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/randrun.cal,v $
+ *
+ * Under source code control:	1995/02/12 20:00:06
+ * File existed as early as:	1995
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
  * If X(j) < X(j+1) < ... X(j+k) >= X(j+k+1), then we have a run of 'k'.
  * We ignore the run breaker, X(j+k+1), and start with X(j+k+2) when
  * considering a new run in order to make our runs chi independent.
@@ -13,27 +40,7 @@
  * We use the suggestion in problem #14 to allow an application of the
  * chi-square test and to make estimating the run length probs easy.
  */
-/*
+
- * Copyright 1995 by Landon Curt Noll.  All Rights Reserved.
- *
- * Permission to use, copy, modify, and distribute this software and
- * its documentation for any purpose and without fee is hereby granted,
- * provided that the above copyright, this permission notice, and the
- * disclaimer below appear in all of the following:
- *
- * 	* supporting documentation
- * 	* source copies
- * 	* source works derived from this source
- * 	* binaries derived from this source or from derived source
- *
- * LANDON CURT NOLL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL LANDON CURT NOLL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
- * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
 
 define randrun(run_cnt)
 {
@@ -45,7 +52,7 @@ define randrun(run_cnt)
     local last;			/* last random number */
     local current;		/* current random number */
     local MAX_RUN = 9;		/* max run we will keep track of */
-    local mat tally[1:MAX_RUN];	/* tally of length of a rise run of 'x' */
+    local mat tally[1:MAX_RUN]; /* tally of length of a rise run of 'x' */
     local mat prob[1:MAX_RUN];	/* prob[x] = probability of 'x' length run */
 
     /*
@@ -86,7 +93,7 @@ define randrun(run_cnt)
 	/* look for a run break */
 	if (current < last) {
 
-	    /*  record the stats */
+	    /*	record the stats */
 	    if (run > max_run) {
 		max_run = run;
 	    }
@@ -122,7 +129,6 @@ define randrun(run_cnt)
     printf("max length=%d\n", max_run);
 }
 
-global lib_debug;
+if (config("resource_debug") & 3) {
-if (lib_debug >= 0) {
     print "randrun([run_length]) defined";
 }

cal/repeat.cal

@@ -0,0 +1,53 @@
+/*
+ * repeat - return the value of a repeated set of digits
+ *
+ * Copyright (C) 2003  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: repeat.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/repeat.cal,v $
+ *
+ * Under source code control:	2003/01/05 00:00:01
+ * File existed as early as:	2003
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+/*
+ * repeat - return the value of a repeated set of digits
+ *
+ * usage:
+ *	repeat(digit_set, repeat_count)
+ */
+define repeat(digit_set, repeat_count)
+{
+    local digit_count;	/* digits in the digit_set */
+
+    /* firewall */
+    if (!isint(digit_set) || digit_set <= 0) {
+	quit "digit set must be an integer > 0";
+    }
+    if (!isint(repeat_count) || repeat_count <= 0) {
+	quit "repeat count must be an integer > 0";
+    }
+
+    /* return repeated set of digits */
+    digit_count = digits(digit_set);
+    return digit_set * (10^(digit_count*repeat_count)-1) / (10^digit_count-1);
+}

cal/screen.cal

@@ -0,0 +1,61 @@
+/*
+ * screen - ANSI control sequences
+ *
+ * This file was created by Ernest Bowen <ebowen at une dot edu dot au>.
+ *
+ * This code has been placed in the public domain.  Please do not
+ * copyright this code.
+ *
+ * ERNEST BOWEN DISCLAIMS ALL WARRANTIES WITH  REGARD  TO
+ * THIS	 SOFTWARE,  INCLUDING  ALL IMPLIED WARRANTIES OF MER-
+ * CHANTABILITY AND FITNESS.  IN NO EVENT SHALL	 LANDON	 CURT
+ * NOLL	 BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM  LOSS  OF
+ * USE,	 DATA  OR  PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR  IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * @(#) $Revision: 30.2 $
+ * @(#) $Id: screen.cal,v 30.2 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/screen.cal,v $
+ *
+ * This file is not covered under version 2.1 of the GNU LGPL.
+ *
+ * Under source code control:	2006/03/08 05:54:09
+ * File existed as early as:	2006
+ */
+
+up = CUU ="\e[A";
+down = CUD = "\e[B}";
+forward = CUF = "\e[C";
+back = CUB = "\e[D";
+save = SCP = "\e[s";
+restore = RCP = "\e[u";
+cls = "\e[2J";
+home = "\e[F";
+eraseline = "\e[K";
+off = "\e[0m";
+bold = "\e[1m";
+faint = "\e[2m";
+italic = "\e[3m";
+blink = "\e[5m";
+rapidblink = "\e[6m";
+reverse = "\e[7m";
+concealed = "\e[8m";
+/* Lowercase indicates foreground, uppercase background" */
+black = "\e[30m";
+red = "\e[31m";
+green = "\e[32m";
+yellow = "\e[33m";
+blue = "\e[34m";
+magenta = "\e[35m";
+cyan = "\e[36m";
+white = "\e[37m";
+Black = "\e[40m";
+Red = "\e[41m";
+Green = "\e[42m";
+Yellow = "\e[43m";
+Blue = "\e[44m";
+Magenta = "\e[45m";
+Cyan = "\e[46m";
+White = "\e[47m";

cal/seedrandom.cal

@@ -0,0 +1,161 @@
+/*
+ * seedrandom - seed the cryptographically strong Blum generator
+ *
+ * Copyright (C) 1999  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: seedrandom.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/seedrandom.cal,v $
+ *
+ * Under source code control:	1996/01/01 08:21:00
+ * File existed as early as:	1996
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * The period of Blum generators with modulus 'n=p*q' (where p and
+ * q are primes 3 mod 4) is:
+ *
+ *	lambda(n) = lcm(factors of p-1 & q-1)
+ *
+ * One can construct a generator with a maximal period when
+ * 'p' and 'q' have the fewest possible factors in common.
+ * The quickest way to select such primes is only use 'p'
+ * and 'q' when '(p-1)/2' and '(q-1)/2' are both primes.
+ * This function will seed the random() generator that uses
+ * such primes.
+ *
+ * given:
+ *	seed1 - a large random value (at least 10^20 and perhaps < 10^314)
+ *	seed2 - a large random value (at least 10^20 and perhaps < 10^314)
+ *	size - min Blum modulus as a power of 2 (at least 32, perhaps >= 512)
+ *	trials - number of ptest() trials (default 25)
+ *
+ * returns:
+ *	the previous random state
+ *
+ * NOTE: The [10^20, 10^314) range comes from the fact that the 13th internal
+ *	 modulus is ~10^315.  We want the lower bound seed to be reasonably big.
+ */
+
+
+define seedrandom(seed1, seed2, size, trials)
+{
+	local p;		/* first Blum prime */
+	local fp;		/* prime co-factor of p-1 */
+	local sp;		/* min bit size of p */
+	local q;		/* second Blum prime */
+	local fq;		/* prime co-factor of q-1 */
+	local sq;		/* min bit size of q */
+	local n;		/* Blum modulus */
+	local binsize;		/* smallest power of 2 > n=p*q */
+	local r;		/* initial quadratic residue */
+	local random_state;	/* the initial rand state */
+	local random_junk;	/* rand state that is not needed */
+	local old_state;	/* old random state to return */
+
+	/*
+	 * firewall
+	 */
+	if (!isint(seed1)) {
+		quit "1st arg (seed1) is not an int";
+	}
+	if (!isint(seed2)) {
+		quit "2nd arg (seed2) is not an int";
+	}
+	if (!isint(size)) {
+		quit "3rd arg (size) is not an int";
+	}
+	if (!isint(trials)) {
+		trials = 25;
+	}
+	if (digits(seed1) <= 20) {
+		quit "1st arg (seed1) must be > 10^20 and perhaps < 10^314";
+	}
+	if (digits(seed2) <= 20) {
+		quit "2nd arg (seed2) must be > 10^20 and perhaps < 10^314";
+	}
+	if (size < 32) {
+		quit "3rd arg (size) needs to be >= 32 (perhaps >= 512)";
+	}
+	if (trials < 1) {
+		quit "4th arg (trials) must be > 0";
+	}
+
+	/*
+	 * determine the search parameters
+	 */
+	++size;		/* convert power of 2 to bit length */
+	sp = int((size/2)-(size*0.03)+1);
+	sq = size - sp;
+
+	/*
+	 * find the first Blum prime
+	 */
+	random_state = srandom(seed1, 13);
+	do {
+		do {
+			fp = nextcand(2^sp+randombit(sp), 1, 1, 3, 4);
+			p = 2*fp+1;
+		} while (ptest(p,1,0) == 0);
+	} while(ptest(p, trials) == 0 || ptest(fp, trials) == 0);
+	if (config("resource_debug") & 8) {
+		print "/* 1st Blum prime */ p=", p;
+	}
+
+	/*
+	 * find the 2nd Blum prime
+	 */
+	random_junk = srandom(seed2, 13);
+	do {
+		do {
+			fq = nextcand(2^sq+randombit(sq), 1, 1, 3, 4);
+			q = 2*fq+1;
+		} while (ptest(q,1,0) == 0);
+	} while(ptest(q, trials) == 0 || ptest(fq, trials) == 0);
+	if (config("resource_debug") & 8) {
+		print "/* 2nd Blum prime */ q=", q;
+	}
+
+	/*
+	 * seed the Blum generator
+	 */
+	n = p*q;				/* the Blum modulus */
+	binsize = highbit(n)+1;			/* smallest power of 2 > p*q */
+	r = pmod(rand(1<<ceil(binsize*4/5), 1<<(binsize-2)), 2, n);
+	if (config("resource_debug") & 8) {
+		print "/* seed quadratic residue */ r=", r;
+		print "/* newn", binsize, "bit quadratic residue*/ newn=", n;
+	}
+	old_state = srandom(r, n);
+
+	/*
+	 * restore other states that we altered
+	 */
+	random_junk = srandom(random_state);
+
+	/*
+	 * return the previous random state
+	 */
+	return old_state;
+}
+
+if (config("resource_debug") & 3) {
+    print "seedrandom(seed1, seed2, size [, trials]) defined";
+}

cal/set8700.cal

@@ -0,0 +1,77 @@
+/*
+ * set8700 - environment for dotest line tests for the 8700 set of regress.cal
+ *
+ * Copyright (C) 2006  Ernest Bowen and Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: set8700.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/set8700.cal,v $
+ *
+ * Under source code control:	2006/05/20 14:10:11
+ * File existed as early as:	2006
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+/*
+ * setup global variables for dotest() to use with set8700.set
+ */
+
+global set8700_A;
+global set8700_B;
+global set8700_M;
+global set8700_M1;
+global set8700_M2;
+global set8700_L;
+global set8700_L1;
+global set8700_L2;
+global set8700_O;
+global set8700_P;
+global set8700_P1;
+global set8700_P2;
+global set8700_Q;
+global set8700_R;
+global set8700_S;
+global set8700_X;
+global set8700_Y;
+global set8700_x;
+global set8700_y;
+
+define set8700_getA1() = set8700_A;
+
+define set8700_getA2() { return set8700_A; }
+
+define set8700_getvar() {local a = 42; protect(a,256); return a;}
+
+define set8700_f(set8700_x) = set8700_x^2;
+
+define set8700_g(set8700_x)
+{
+    if (isodd(set8700_x)) protect(set8700_x, 256);
+    return set8700_x;
+}
+
+obj set8700_point {
+	set8700_x, set8700_y, set8700_z
+}
+
+global mat set8700_c[] = { 1, 2+3i, -5+4i, 5i+6, -7i };
+
+global mat set8700_e[] = { 0, 1, 0, 0, 2, -3/2, 2, -1/2,
+			   -3, 0.5, -1.0, 0.5, 1.0, 0.0, 0.0, 0.0 };

cal/set8700.line

@@ -0,0 +1,429 @@
+##
+## set8700 - dotest line tests for the 8700 set of regress.cal
+##
+## Copyright (C) 2006  Ernest Bowen and Landon Curt Noll
+##
+## Calc is open software; you can redistribute it and/or modify it under
+## the terms of the version 2.1 of the GNU Lesser General Public License
+## as published by the Free Software Foundation.
+##
+## Calc 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 Lesser General
+## Public License for more details.
+##
+## A copy of version 2.1 of the GNU Lesser General Public License is
+## distributed with calc under the filename COPYING-LGPL.  You should have
+## received a copy with calc; if not, write to Free Software Foundation, Inc.
+## 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+##
+## @(#) $Revision: 30.1 $
+## @(#) $Id: set8700.line,v 30.1 2007/03/16 11:09:54 chongo Exp $
+## @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/set8700.line,v $
+##
+## Under source code control:	2006/05/20 14:10:11
+## File existed as early as:	2006
+##
+## chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+## Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+
+
+strcpy("", "") == ""
+strcpy("", "xyz") == ""
+strcpy("a", "xyz") == "x"
+strcpy("ab", "xyz") == "xy"
+strcpy("abc", "xyz") == "xyz"
+strcpy("abcd", "xyz") == "xyz\0"  ## Result will print as "xyz"
+strcpy("abcde", "xyz") == "xyz\0e"
+strcpy("abcdef", "xyz") == "xyz\0ef"
+strcpy("abcdef", "x\0z") == "x\0z\0ef" ## Note z is copied
+strcpy("abc", "") == "\0bc"
+
+strncpy("abcdef", "xyz", 0) == "abcdef" ## No characters copied
+strncpy("abcdef", "xyz", 1) == "xbcdef" ## One character copied, no '\0'
+strncpy("abcdef", "xyz", 2) == "xycdef"
+strncpy("abcdef", "xyz", 3) == "xyzdef"
+strncpy("abcdef", "xyz", 4) == "xyz\0ef"
+strncpy("abcdef", "xyz", 5) == "xyz\0\0f" ## Two nulls as in C
+strncpy("abcdef", "xyz", 6) == "xyz\0\0\0"
+strncpy("abcdef", "xyz", 7) == "xyz\0\0\0" ## Size of first string unchanged
+strncpy("a\0cdef", "\0yz", 4) == "\0yz\0ef"
+strncpy("ab", "xyz", 3) == "xy"
+
+strcmp("", "") == 0
+strcmp("", "a") == -1
+strcmp("\n", "\n") == 0
+strcmp("\0", "") == 1		## '\0' treated like other characters
+strcmp("ab", "") == 1
+strcmp("ab", "a") == 1
+strcmp("ab", "ab") == 0
+strcmp("ab", "abc") == -1
+strcmp("abc", "abb") == 1
+strcmp("abc", "abc") == 0
+strcmp("abc", "abd") == -1
+strcmp("abc\0", "abc") == 1
+
+strncmp("abc", "xyz", 0) == 0
+strncmp("abc", "xyz", 1) == -1
+strncmp("abc", "", 1) == 1
+strncmp("abc", "a", 1) == 0
+strncmp("", "", 2) == 0
+strncmp("a", "a", 2) == 0
+strncmp("a", "b", 2) == -1
+strncmp("ab", "ab", 2) == 0
+strncmp("ab", "ac", 2) == -1
+strncmp("\0ac", "\0b", 2) == -1
+strncmp("ab", "abc", 2) == 0
+strncmp("abc", "abd", 2) == 0
+strncmp("a", "a\0", 2) == -1
+strncmp("a", "a", 3) == 0
+strncmp("abc", "abd", 3) == -1
+strncmp("\0\0\n", "\0\0\t", 3) == 1
+
+str("abc") == "abc"
+str("ab\0") == "ab"
+str("a\0c") == "a"
+str("\0bc") == ""
+
+size("") == 0
+size("a") == 1
+size("\0") == 1
+size("a\0") == 2
+size("a\0b") == 3
+
+strlen("\0") == 0
+strlen("a\0") == 1
+strlen("a\0b") == 1
+
+0 * "abc" == ""
+1 * "abc" == "abc"
+2 * "abc" == "abcabc"
+3 * "abc" == "abcabcabc"
+1 * "" == ""
+-1 * "abc" == "cba"
+-2 * "abc" == "cbacba"
+"abc" + "xyz" == "abcxyz"
+"abc" - "xyz" == "abczyx"
+
+
+substr("abcd",0,0) == ""
+substr("abcd",0,1) == "a"
+substr("abcd",0,2) == "ab"
+substr("abcd",1,0) == ""
+substr("abcd",1,1) == "a"
+substr("abcd",1,2) == "ab"
+substr("abcd",2,0) == ""
+substr("abcd",2,1) == "b"
+substr("abcd",2,2) == "bc";
+substr("abcd",2,3) == "bcd";
+substr("abcd",2,4) == "bcd";
+substr("abcd",2,5) == "bcd"; ## substr stops at end of string
+substr("abcd",4,0) == ""
+substr("abcd",4,1) == "d"
+substr("abcd",4,2) == "d"
+substr("abcd",4,3) == "d"
+substr("abcd",5,0) == ""
+substr("abcd",5,1) == ""
+substr("a\0c\0",2,2) == "\0c"  ## '\0' treated like other characters
+substr("a\0c\0",2,3) == "\0c\0"
+
+#"" == 0	## # operator counts number of bits
+#"\0" == 0
+# "a" == 3
+   #	  "ab" == 6	## white space ignored
+# "abc" == 10
+# 27 == 4
+# 0b1010111011 == 7
+
+7 # 9 == 2		## 7 # 9 = abs(7 - 9)
+3/4 # 2/3 == 1/12
+
+a = 5, a #= 2, a == 3
+a #= 4, a == 1
+
+## Binary # operator not defined for strings
+
+protect(set8700_A) == 0
+## Testing with one lvalue
+isnull(protect(set8700_A,65))
+protect(set8700_A) == 65
+isnull(protect(set8700_A, -1))
+protect(set8700_A) == 64
+protect(set8700_A,-2), protect(set8700_A) == 64
+protect(set8700_A,5), protect(set8700_A) == 69
+protect(set8700_A,-4), protect(set8700_A) == 65
+protect(set8700_A,0), protect(set8700_A) == 0
+protect(set8700_A,1234), protect(set8700_A) == 1234
+protect(set8700_A,-1234), protect(set8700_A) == 0
+protect(set8700_A,65535), protect(set8700_A) == 65535
+protect(set8700_A,-65535), protect(set8700_A) == 0
+
+## Simple assignments
+set8700_A = 42, protect(set8700_A,1024), set8700_B = set8700_A, protect(set8700_B) == 1024
+set8700_A = 6 * 7, protect(set8700_A) == 1024
+set8700_A == set8700_B
+
+## Testing matrix protectioon
+set8700_A = mat [3] = {1, 2, list(3,4)}; 1
+protect(set8700_A, 65, 1), protect(set8700_A) == 1089
+protect(set8700_A[0]) == 65
+protect(set8700_A[2]) == 65
+protect(set8700_A[2][1]) == 0
+protect(set8700_A, 65, 2), protect(set8700_A[2][1]) == 65
+protect(set8700_A,-1024), protect(set8700_A) == 65
+protect(set8700_A, -1, 1), protect(set8700_A) == 64
+protect(set8700_A[1]) == 64
+protect(set8700_A[2]) == 64
+protect(set8700_A[2][0]) == 65
+protect(set8700_A,0), protect(set8700_A) == 0
+protect(set8700_A[1]) == 64
+protect(set8700_A, 0, 2), protect(set8700_A) == 0
+protect(set8700_A[1]) == 0
+protect(set8700_A[2][1]) == 0
+protect(set8700_A,1024, 2), protect(set8700_A) == 1024
+protect(set8700_A[2]) == 1024
+protect(set8700_A[2][0], 512), protect(set8700_A[2][0]) == 1536
+
+## Testing simple assignment of matrix
+set8700_B = set8700_A, protect(set8700_B) == 1024	## protect(set8700_A) copied
+protect(set8700_B[2]) == 1024		## protect(set8700_A[2]) copied
+protect(set8700_B[2][0]) == 1536	## protect(set8700_A[2][0]) copied
+
+## copying matrix to list
+set8700_B = list(5,6,7), protect(set8700_B) == 1024
+protect(set8700_B[0]) == 0
+protect(set8700_B[2]) == 0
+protect(set8700_A,0), protect(set8700_A) == 0
+copy(set8700_A,set8700_B), set8700_B[0] == 1 && set8700_B[1] == 2
+set8700_B[2] == list(3,4)
+protect(set8700_B) == 1024		## protect(set8700_A) not copied
+protect(set8700_B[0]) == 1024		## protect(set8700_A[0]) copied
+protect(set8700_B[2][0]) == 1536	## protect(set8700_A[2][0]) copied
+
+## copying matrix to matrix
+set8700_B = mat[3], protect(set8700_B) == 1024
+protect(set8700_B[2]) == 0
+copy(set8700_A,set8700_B), set8700_B[0] == 1 && set8700_B[1] == 2
+set8700_B[2] == list(3,4)
+protect(set8700_B) == 1024		## protect(set8700_A) not copied
+protect(set8700_B[0]) == 1024		## protect(set8700_A[0]) copied
+protect(set8700_B[2][0]) == 1536	## protect(set8700_A[2][0]) copied
+
+## Testing list protection
+set8700_A = list(1, 2, list(3,4)), 1
+protect(set8700_A,1024, 2), protect(set8700_A) == 1024
+protect(set8700_A[2]) == 1024
+protect(set8700_A[2][0], 512), protect(set8700_A[2][0]) == 1536
+
+## Simple assignment of list
+set8700_B = set8700_A, protect(set8700_B) == 1024	## protect(set8700_A) copied
+protect(set8700_B[2]) == 1024		## protect(set8700_A[2]) copied
+protect(set8700_B[2][0]) == 1536	## protect(set8700_A[2][0]) copied
+
+## Copying list to list
+set8700_B = list(5,6,7), protect(set8700_B) == 1024
+protect(set8700_B[2]) == 0
+copy(set8700_A,set8700_B), set8700_B[0] == 1 && set8700_B[1] == 2
+set8700_B[2] == list(3,4)
+protect(set8700_B) == 1024		## protect(set8700_A) not copied
+protect(set8700_B[0]) == 1024		## protect(set8700_A[0]) copied
+protect(set8700_B[2][0]) == 1536	## protect(set8700_A[2][0]) copied
+
+## Copying list to matrix
+set8700_B = mat[3], protect(set8700_B) == 1024
+protect(set8700_B[2]) == 0
+copy(set8700_A,set8700_B), set8700_B[0] == 1 && set8700_B[1] == 2
+set8700_B[2] == list(3,4)
+protect(set8700_B) == 1024
+protect(set8700_B[0]) == 1024		## protect(set8700_A[0]) copied
+protect(set8700_B[2][0]) == 1536	## protect(set8700_A[2][0]) copied
+
+## Protecting one element of a list
+set8700_A = list(1,4,3,2), protect(set8700_A[1]) == 0
+protect(set8700_A[1], 1024), protect(set8700_A[1]) == 1024
+
+## Testing sort
+set8700_A = sort(set8700_A), set8700_A == list(1,2,3,4)
+protect(set8700_A[1]) == 0
+protect(set8700_A[3]) == 1024		## status of 4
+
+## Testings reverse
+set8700_A = reverse(set8700_A), set8700_A == list(4,3,2,1)
+protect(set8700_A[0]) == 1024		## status of 4
+
+## Testing swap
+swap(set8700_A[0], set8700_A[1]), set8700_A == list(3,4,2,1)
+protect(set8700_A[0]) == 0		## status moved
+protect(set8700_A[1]) == 1024		## 4 retains protection
+
+## Testing list with protected list argument
+protect(set8700_A, 0), protect(set8700_A) == 0
+protect(set8700_A, 512), protect(set8700_A) == 512
+protect(set8700_A[1]) == 1024
+set8700_L = list(1,set8700_A,3), protect(set8700_L) == 0
+protect(set8700_L[0]) == 0
+protect(set8700_L[1]) == 512		## protect(set8700_A) copied
+protect(set8700_L[1][1]) == 1024	## protect(set8700_A[1]) copied
+
+## Testing list with "intialization"
+set8700_L = list(1,2,3), protect(set8700_L) == 0
+protect(set8700_L[0]) | protect(set8700_L[1]) | protect(set8700_L[2]) == 0	## All zero
+set8700_L = {1,set8700_A}, set8700_L[1] == set8700_A
+protect(set8700_L[1]) == 512		## protect(set8700_A) copied
+protect(set8700_L[1][1]) == 1024	## protect(set8700_A[1]) copied
+set8700_L[1] = 2, protect(set8700_L[1]) == 512	## Not changed
+
+## Testing matrix with "initialization"
+set8700_M = mat[3] = {1,set8700_A}, protect(set8700_M) == 0
+protect(set8700_M[0]) == 0
+protect(set8700_M[1]) == 512		## protect(set8700_A) copied
+protect(set8700_M[2]) == 0
+protect(set8700_M[1][1]) == 1024	## protect(set8700_A[1]) copied
+
+## Testing push, pop, append, remove
+set8700_A = list(1,2), protect(set8700_A,0,1), protect(set8700_A[0]) == 0
+protect(set8700_A[0], 256), protect(set8700_A[0]) == 256
+protect(set8700_A[1]) == 0
+append(set8700_A, pop(set8700_A)), protect(set8700_A[0]) ==  0
+protect(set8700_A[1]) == 256
+push(set8700_A, remove(set8700_A)), protect(set8700_A[0]) == 256
+protect(set8700_A[1]) == 0
+
+## Testing operation-assignments
+set8700_A = 5, protect(set8700_A,1024), protect(set8700_A) == 1024
+protect(set8700_A, 1024), set8700_A = 7, protect(set8700_A) == 1024
+protect(set8700_A,1024), set8700_A += 2, protect(set8700_A) == 1024
+protect(set8700_A,1024), set8700_A *= 2, protect(set8700_A) == 1024
+protect(set8700_A,1024), set8700_A |= 2, protect(set8700_A) == 1024
+protect(set8700_A,1024), set8700_A &= 2, protect(set8700_A) == 1024
+protect(set8700_A,1024), set8700_A ^= 2, protect(set8700_A) == 1024
+
+protect(set8700_B,0), set8700_B = set8700_getA1(), protect(set8700_B) == 1024
+protect(set8700_B,0), set8700_B = set8700_getA2(), protect(set8700_B) == 1024
+set8700_B = set8700_getvar(), protect(set8700_B) == 1024 + 256
+
+set8700_x = 7,  protect(set8700_x) == 0
+protect(7,2) == error(10234)
+protect(set8700_x,2.5) == error(10235)
+protect(set8700_x,"abc") == error(10235)
+protect(set8700_x, 1e6) == error(10235)
+protect(set8700_x,1), (set8700_x = 2) == error(10366)
+(set8700_x = 3 + 4) == error(10366)
+
+protect(set8700_x,2), protect(set8700_x) == 3
+protect(set8700_x,-1), protect(set8700_x) == 2
+(set8700_x = 2) == error(10368)
+(set8700_x = 3 + 4) == 7
+protect(set8700_x,2), ++set8700_x == error(10379)
+set8700_x == 7
+--set8700_x == error(10382)
+set8700_x == 7
+set8700_x++ == error(10385)
+set8700_x == 7
+set8700_x-- == error(10388)
+
+protect(set8700_A,0), protect(set8700_A,16), 1
+set8700_A = "abcdef", protect(set8700_A) == 16		## No copy to set8700_A
+protect(set8700_B,0), set8700_B = "xyz", protect(set8700_B) == 0
+copy(set8700_B, set8700_A) == error(10226)
+set8700_A == "abcdef"				## set8700_A not changed
+protect(set8700_A,0), copy(set8700_B,set8700_A), set8700_A == "xyzdef"
+protect(set8700_B,128), protect(set8700_B) == 128	## No copy from set8700_B
+copy(set8700_B,set8700_A,,,3) == error(10225)
+set8700_A == "xyzdef"
+protect(set8700_B,0), copy(set8700_B,set8700_A,,,3), set8700_A == "xyzxyz"
+
+set8700_A = "abcdef", protect(set8700_A, 16), swap(set8700_A[0], set8700_A[5]) == error(10371)
+set8700_A == "abcdef"
+protect(set8700_A,0), isnull(swap(set8700_A[0], set8700_A[5]))
+set8700_A == "fbcdea"
+protect(set8700_A,2), ++set8700_A[0] == error(10377)
+--set8700_A[1] == error(10380)
+set8700_A[2]++ == error(10383)
+set8700_A[3]-- == error(10386)
+set8700_A == "fbcdea"
+protect(set8700_A,0), ++set8700_A[0] == 'g'
+--set8700_A[1] == 'a'
+set8700_A[2]++ == ord('c')
+set8700_A[3]-- == ord('d')
+set8700_A == "gadcea"
+
+protect(set8700_x,0), protect(set8700_y,0), protect(set8700_x,256), protect(set8700_y,512),1
+quomod(11,4,set8700_x,set8700_y), set8700_x == 2 && set8700_y == 3
+protect(set8700_x) == 256
+protect(set8700_y) == 512
+
+set8700_A = mat[3]; protect(set8700_A[0], 1024); protect(set8700_A[0]) == 1024
+set8700_x = 7, protect(set8700_x,0), protect(set8700_x, 512), 1
+set8700_A = {set8700_x,,set8700_x}, protect(set8700_A[0]) == 1536
+protect(set8700_A[1]) == 0
+protect(set8700_A[2]) == 512
+protect(set8700_A,16), protect(set8700_A) == 16		## No copy to
+set8700_A == (mat[3] = {7,0,7})
+set8700_A = {1,2,3}, errno() == 10390;
+set8700_A == (mat[3] = {7,0,7})
+
+protect(set8700_A,0), set8700_A = {1,2,3}, set8700_A == (mat[3] = {1,2,3})
+protect(set8700_A[1],1), protect(set8700_A[1]) == 1
+set8700_A = {4,5,6}, errno() == 10394
+set8700_A == (mat[3] = {4,2,6})
+modify(7, "set8700_f") == error(10405)
+set8700_A = list(2,3,5), modify(set8700_A, 7) == error(10406)
+protect(set8700_A,2), modify(set8700_A, "set8700_f") == error(10407)
+protect(set8700_A,0), modify(set8700_A, "h") == error(10408)
+set8700_B = 42, protect(set8700_B,0), modify(set8700_B, "set8700_f") == error(10409)
+set8700_A == list(2,3,5)		## set8700_A not affected by failures
+protect(set8700_A,0,1), modify(set8700_A, "set8700_f") == null()
+set8700_A == list(4,9,25)
+modify(set8700_A,"set8700_g") == null()
+protect(set8700_A[0]) == 0
+protect(set8700_A[1]) == 256 && protect(set8700_A[2]) == 256
+
+set8700_A = 0, protect(set8700_A,0), set8700_A = pop(2), set8700_A == error(10181)
+set8700_A = pop(list(1,2,3)), set8700_A == error(10181)
+set8700_B = set8700_A = pop(2), set8700_B == error(10181)
+set8700_A = 32, protect(set8700_A,8), (set8700_A = pop(2)) == error(10370)
+set8700_A == 32
+set8700_B = set8700_A = pop(2), set8700_B == error(10370)
+## Testing copying of protected elements and initialization
+set8700_M1 = mat[3], protect(set8700_M1,0), protect(set8700_M1[1],1), protect(set8700_M1[1]) == 1
+set8700_M2 = mat[3], protect(set8700_M2,0), protect(set8700_M2[2],4), protect(set8700_M2[2]) == 4
+set8700_L = list(set8700_M1, set8700_M2), protect(set8700_L[0][1]) == 1 && protect(set8700_L[1][2]) == 4
+set8700_L = {{1,2,3},{'a','b','c'}}, set8700_L[0] == (mat[3] = {1,0,3})
+set8700_L[1] == (mat[3] = {'a','b',0})
+set8700_M = mat[2], protect(set8700_M,0), set8700_M = {1,2,3,4}, set8700_M == (mat[2] = {1,2})
+set8700_x = 5, set8700_M = {set8700_x++, set8700_x++, set8700_x++, set8700_x++, set8700_x++}, set8700_M == (mat[2] = {5,6})
+set8700_x == 10		## All initialization terms evaluated
+set8700_S = "   ", set8700_S = {'a','b','c','d'}, set8700_S == "abc"
+
+set8700_P = obj set8700_point = {1,2,3,4}, set8700_P.set8700_x == 1 && set8700_P.set8700_y == 2 && set8700_P.set8700_z == 3
+protect(set8700_P,16), set8700_Q = set8700_P, set8700_Q = {5,6,7}, set8700_Q == set8700_P
+set8700_P == (obj set8700_point = {1,2,3})
+set8700_L = list(mat[1] = {set8700_P}), protect(set8700_L[0][0]) == 16
+set8700_L = {{{4,5,6}}}, set8700_L[0][0] == set8700_P
+protect(set8700_L,0,2), set8700_L = {{{4,5,6}}}, set8700_L[0][0] == (obj set8700_point = {4,5,6})
+
+## Testing quomod
+quomod(14,5,3,4) == error(10374)
+global set8700_a,set8700_b; quomod("abc", 4, set8700_a, set8700_b) == error(10375)
+quomod(14,5,set8700_a,set8700_b,0) == 1 && set8700_a == 2 && set8700_b == 4
+quomod(14,5,set8700_a,set8700_b,1) == 1 && set8700_a == 3 && set8700_b == -1
+quomod("abc",2,set8700_a,set8700_b) == error(10375)
+set8700_a = "abc"; quomod(14,5,set8700_a,set8700_b) == error(10375)
+set8700_a = null(); quomod(14,5,set8700_a,set8700_b,24) == 1; set8700_a == 3 && set8700_b == -1
+quomod(14,5,set8700_a,set8700_a) == error(10374)
+quomod(14,5,set8700_a,set8700_b,-1) == error(10375)
+protect(set8700_a,1); quomod(17,2,set8700_a,set8700_b) == error(10376)
+protect(set8700_a,0); quomod(17,2,set8700_a,set8700_b); set8700_a == 8 && set8700_b == 1
+set8700_p = &set8700_a, set8700_q = &set8700_b; quomod(14,5,*set8700_p,*set8700_q); *set8700_p == 2 && *set8700_q == 4
+
+## Testing estr
+base(1/3) == 10
+strcmp(estr(null()), "\"\"") == 0
+strcmp(estr(bernoulli(48)), "-5609403368997817686249127547/46410") == 0
+strcmp(estr(sin(3i)), "1001787492740990189897i/100000000000000000000") == 0
+base(10) == 1/3
+strcmp(estr("fizzbin"), "\"fizzbin\"") == 0
+strcmp(estr(set8700_c), "mat[5]={1,2+3i,-5+4i,6+5i,-7i}") == 0
+strcmp(estr(set8700_e), "mat[16]={0,1,0,0,2,-3/2,2,-1/2,-3,1/2,-1,1/2,1,0,0,0}") == 0
+strcmp(estr(list(2,3,5)), "list(2,3,5)") == 0

cal/solve.cal

@@ -0,0 +1,69 @@
+/*
+ * solve - solve f(x) = 0 to within the desired error value for x
+ *
+ * Copyright (C) 1999  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.2 $
+ * @(#) $Id: solve.cal,v 30.2 2008/05/10 13:30:00 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/solve.cal,v $
+ *
+ * Under source code control:	1990/02/15 01:50:37
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * Solve the equation f(x) = 0 to within the desired error value for x.
+ * The function 'f' must be defined outside of this routine, and the low
+ * and high values are guesses which must produce values with opposite signs.
+ */
+
+
+define solve(low, high, epsilon)
+{
+	local flow, fhigh, fmid, mid, places;
+
+	if (isnull(epsilon))
+		epsilon = epsilon();
+	if (epsilon <= 0)
+		quit "Non-positive epsilon value";
+	places = highbit(1 + int(1/epsilon)) + 1;
+	flow = f(low);
+	if (abs(flow) < epsilon)
+		return low;
+	fhigh = f(high);
+	if (abs(fhigh) < epsilon)
+		return high;
+	if (sgn(flow) == sgn(fhigh))
+		quit "Non-opposite signs";
+	while (1) {
+		mid = bround(high - fhigh * (high - low) / (fhigh - flow), places);
+		if ((mid == low) || (mid == high))
+			places++;
+		fmid = f(mid);
+		if (abs(fmid) < epsilon)
+			return mid;
+		if (sgn(fmid) == sgn(flow)) {
+			low = mid;
+			flow = fmid;
+		} else {
+			high = mid;
+			fhigh = fmid;
+		}
+	}
+}

cal/sumsq.cal

@@ -0,0 +1,65 @@
+/*
+ * sumsq - find unique two positive integers whose squares sum to a given prime
+ *
+ * Copyright (C) 1999  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: sumsq.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/sumsq.cal,v $
+ *
+ * Under source code control:	1990/02/15 01:50:37
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * Determine the unique two positive integers whose squares sum to the
+ * specified prime.  This is always possible for all primes of the form
+ * 4N+1, and always impossible for primes of the form 4N-1.
+ */
+
+
+define ss(p)
+{
+	local a, b, i, p4;
+
+	if (p == 2) {
+		print "1^2 + 1^2 = 2";
+		return;
+	}
+	if ((p % 4) != 1) {
+		print p, "is not of the form 4N+1";
+		return;
+	}
+	if (!ptest(p, min(p-2, 10))) {
+		print p, "is not a prime";
+		return;
+	}
+	p4 = (p - 1) / 4;
+	i = 2;
+	do {
+		a = pmod(i++, p4, p);
+	} while ((a^2 % p) == 1);
+	b = p;
+	while (b^2 > p) {
+		i = b % a;
+		b = a;
+		a = i;
+	}
+	print a : "^2 +" , b : "^2 =" , a^2 + b^2;
+}

cal/sumtimes.cal

@@ -0,0 +1,186 @@
+/*
+ * sumtimes - runtimes evaluating sums & squares of large lists and mats
+ *
+ * Copyright (C) 2006  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: sumtimes.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/sumtimes.cal,v $
+ *
+ * Under source code control:	2006/06/22 17:29
+ * File existed as early as:	2006
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+global sumtimes_t0, sumtimes_t1, sumtimes_t2, sumtimes_t3;
+global sumtimes_A, sumtimes_B;
+config("tilde", 0),;
+
+define timematsum(N) {
+    local n, s, p, ptop;
+
+    sumtimes_A = mat[N];
+
+    for (n = 0; n < N; n++) sumtimes_A[n] = rand(N);
+
+    ptop = &sumtimes_A[n-1];
+    sumtimes_t0 = usertime();
+    for (s = n = 0; n < N; n++) s += sumtimes_A[n];
+    sumtimes_t1 = usertime();
+    for (s = 0, p = &sumtimes_A[0]; p <= ptop; p++) s += *p;
+    sumtimes_t2 = usertime();
+    s = matsum(sumtimes_A);
+    sumtimes_t3 = usertime();
+
+    print "Matrix sum runtimes";
+    printf('\tStandard "for" loop:\t\t%.4f\n', sumtimes_t1 - sumtimes_t0);
+    printf('\t"For" loop using pointers:\t\t%.4f\n', sumtimes_t2 - sumtimes_t1);
+    printf('\tUsing builtin "matsum":\t\t%.4f\n', sumtimes_t3 - sumtimes_t2);
+}
+
+define timelistsum(N) {
+    local n, s;
+
+    sumtimes_A = makelist(N);
+    for (n = 0; n < N; n++) sumtimes_A[n] = rand(N);
+
+    sumtimes_t0 = usertime();
+    for (s = n = 0; n < N; n++) s += sumtimes_A[n];
+    sumtimes_t1 = usertime();
+    s = sum(sumtimes_A);
+    sumtimes_t2 = usertime();
+    print "List sum runtimes";
+    printf('\tStandard "for" loop:\t\t%.4f\n', sumtimes_t1 - sumtimes_t0);
+    printf('\tUsing builtin "sum":\t\t%.4f\n', sumtimes_t2 - sumtimes_t1);
+}
+
+
+define timematsort(N) {
+    local n;
+
+    sumtimes_A = mat[N];
+    for (n = 0; n < N; n++) sumtimes_A[n] = rand(N);
+    sumtimes_t0 = usertime();
+    sort(sumtimes_A);
+    sumtimes_t1 = usertime();
+    printf('\tMatrix sort runtime:\t\t%.4f\n', sumtimes_t1 - sumtimes_t0);
+}
+
+
+define timelistsort(N) {
+    local n;
+
+    sumtimes_A = makelist(N);
+    for (n = 0; n < N; n++) sumtimes_A[n] = rand(N);
+    sumtimes_t0 = usertime();
+    sort(sumtimes_A);
+    sumtimes_t1 = usertime();
+    printf('\tList sort runtime:\t\t%.4f\n', sumtimes_t1 - sumtimes_t0);
+}
+
+define timematreverse(N) {
+    local n;
+
+    sumtimes_A = mat[N];
+    for (n = 0; n < N; n++) sumtimes_A[n] = rand(N);
+    sumtimes_t0 = usertime();
+    reverse(sumtimes_A);
+    sumtimes_t1 = usertime();
+    printf('\tMatrix reverse runtime        %.4f\n', sumtimes_t1 - sumtimes_t0);
+}
+
+define timelistreverse(N) {
+    local n;
+
+    sumtimes_A = makelist(N);
+    for (n = 0; n < N; n++) sumtimes_A[n] = rand(N);
+    sumtimes_t0 = usertime();
+    reverse(sumtimes_A);
+    sumtimes_t1 = usertime();
+    printf('\tList reverse runtime:\t\t%.4f\n', sumtimes_t1 - sumtimes_t0);
+}
+
+define timematssq(N) {
+    local n, s, p, ptop;
+
+    sumtimes_A = mat[N];
+
+    for (n = 0; n < N; n++) sumtimes_A[n] = rand(N);
+
+    ptop = &sumtimes_A[n-1];
+    sumtimes_t0 = usertime();
+    for (s = n = 0; n < N; n++) s += sumtimes_A[n]^2;
+    sumtimes_t1 = usertime();
+    for (s = 0, p = &sumtimes_A[0]; p <= ptop; p++) s += (*p)^2;
+    sumtimes_t2 = usertime();
+
+    print "Matrix sum of squares runtimes";
+    printf('\tStandard "for" loop:\t\t%.4f\n', sumtimes_t1 - sumtimes_t0);
+    printf('\t"For" loop using pointers:\t\t%.4f\n', sumtimes_t2 - sumtimes_t1);
+}
+
+define timelistssq(N) {
+    local n, s;
+
+    sumtimes_A = makelist(N);
+    for (n = 0; n < N; n++) sumtimes_A[n] = rand(N);
+
+    sumtimes_t0 = usertime();
+    for (s = n = 0; n < N; n++) s += sumtimes_A[n]^2;
+    sumtimes_t1 = usertime();
+    s = ssq(sumtimes_A);
+    sumtimes_t2 = usertime();
+    print "List sum of squares runtimes";
+    printf('\tStandard "for" loop:\t\t%.4f\n', sumtimes_t1 - sumtimes_t0);
+    printf('\tUsing builtin "ssq":\t\t%.4f\n', sumtimes_t2 - sumtimes_t1);
+}
+
+define timehmean(N, M = 10) {
+    local n, s, v1, v2;
+
+    sumtimes_A = makelist(N);
+    for (n = 0; n < N; n++) sumtimes_A[n] = rand(1, M);
+
+    sumtimes_t0 = usertime();
+    for (s = n = 0; n < N; n++) s += 1/sumtimes_A[n];
+    v1 = N/s;
+    sumtimes_t1 = usertime();
+    v2 = hmean(sumtimes_A);
+    sumtimes_t2 = usertime();
+    print v1, v2;
+    print "List harmonic meanruntimes";
+    printf('\tStandard "for" loop:\t\t%.4f\n', sumtimes_t1 - sumtimes_t0);
+    printf('\tUsing builtin "hmean":\t\t%.4f\n', sumtimes_t2 - sumtimes_t1);
+}
+
+define doalltimes(N) {
+    timematsum(N);
+    print;
+    timelistsum(N);
+    print;
+    timematssq(N);
+    print;
+    timelistssq(N);
+    print;
+    timematsort(N);
+    timelistsort(N);
+    timematreverse(N);
+    timelistreverse(N);
+    print;
+}

cal/surd.cal

@@ -1,11 +1,33 @@
 /*
- * Copyright (c) 1995 David I. Bell
+ * surd - calculate using quadratic surds of the form: a + b * sqrt(D).
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * Calculate using quadratic surds of the form: a + b * sqrt(D).
+ * Copyright (C) 1999  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: surd.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/surd.cal,v $
+ *
+ * Under source code control:	1990/02/15 01:50:38
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
 
+
 obj surd {a, b};		/* definition of the surd object */
 
 global surd_type = -1;		/* type of surd (value of D) */
@@ -261,28 +283,8 @@ define surd_rel(a, b)
 	return sgn(x^2 - y^2 * surd_type) * sgn(x);
 }
 
-global lib_debug;
+if (config("resource_debug") & 3) {
-if (lib_debug >= 0) {
     print "obj surd {a, b} defined";
-    print "surd(a, b) defined";
-    print "surd_print(a) defined";
-    print "surd_conj(a) defined";
-    print "surd_norm(a) defined";
-    print "surd_value(a, xepsilon) defined";
-    print "surd_add(a, b) defined";
-    print "surd_sub(a, b) defined";
-    print "surd_inc(a) defined";
-    print "surd_dec(a) defined";
-    print "surd_neg(a) defined";
-    print "surd_mul(a, b) defined";
-    print "surd_square(a) defined";
-    print "surd_scale(a, b) defined";
-    print "surd_shift(a, b) defined";
-    print "surd_div(a, b) defined";
-    print "surd_inv(a) defined";
-    print "surd_sgn(a) defined";
-    print "surd_cmp(a, b) defined";
-    print "surd_rel(a, b) defined";
     print "surd_type defined";
     print "set surd_type as needed";
 }

cal/test1700.cal

@@ -0,0 +1,32 @@
+/*
+ * test1700 - 1700 series of the regress.cal test suite
+ *
+ * Copyright (C) 1999  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test1700.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test1700.cal,v $
+ *
+ * Under source code control:	1994/03/14 23:12:51
+ * File existed as early as:	1994
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+++value;

cal/test2300.cal

@@ -1,12 +1,31 @@
 /*
- * Copyright (c) 1995 Landon Curt Noll
+ * test2300 - 2300 series of the regress.cal test suite
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * By: Landon Curt Noll
+ * Copyright (C) 1999  Landon Curt Noll
- *     chongo@toad.com  -or-  ...!{pyramid,sun,uunet}!hoptoad!chongo
  *
- * This library is used by the 2300 series of the regress.cal test suite.
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test2300.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test2300.cal,v $
+ *
+ * Under source code control:	1995/07/09 06:12:13
+ * File existed as early as:	1995
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 

cal/test2600.cal

@@ -1,13 +1,34 @@
 /*
- * Copyright (c) 1996 Ernest Bowen and Landon Curt Noll
+ * test2600 - 2600 series of the regress.cal test suite
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * By: Ernest Bowen and Landon Curt Noll
+ * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
- *     ernie@neumann.une.edu.au and chongo@toad.com
  *
- * This library is used by the 2600 series of the regress.cal test suite.
+ * Primary author:  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.2 $
+ * @(#) $Id: test2600.cal,v 30.2 2007/07/11 22:57:23 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test2600.cal,v $
+ *
+ * Under source code control:	1995/10/13 00:13:14
+ * File existed as early as:	1995
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
+
 /*
  * Stringent tests of some of calc's builtin functions.
  * Most of the tests are concerned with the accuracy of the value
@@ -49,6 +70,7 @@
  * All functions return the number of errors that they detected.
  */
 
+
 global defaultverbose = 1;	/* default verbose value */
 global err;
 
@@ -291,6 +313,102 @@ define testpower(str, n, b, eps, verbose)
 }
 
 
+define testpower2(str, n, eps, verbose)
+{
+	local i, a, c, m, min, max;
+	local b;
+	local num;
+	local c2;
+	local oldeps;
+
+	if (isnull(verbose)) verbose = 2;
+	if (verbose > 0) {
+		print str:":",:;
+	}
+	if (isnull(eps))
+		eps = epsilon();
+	oldeps = epsilon(eps);
+	epsilon(eps),;
+	if (!isnum(b))
+		quit "Second argument (exponent) to be a number";
+	min = 1000;
+	max = -1000;
+	for (i = 1; i <= n; i++) {
+		if (verbose > 2) print i,:;
+
+		/* real ^ real */
+		a = rand(1,1e20);
+		a = a / (int(a/2)+rand(1,1e20));
+		b = rand(1,1e20);
+		b = b / (int(b/2)+rand(1,1e20));
+		c = a ^ b;
+		c2 = power(a, b);
+		if (c != c2) {
+			m++;
+			if (verbose > 1) {
+				printf("*** real^real failure for a = %d\n", a);
+			}
+		}
+
+		/* complex ^ real */
+		a = rand(1,1e20);
+		a = a / (int(a/2)+rand(1,1e20));
+		b = rand(1,1e20);
+		b = b / (int(b/2)+rand(1,1e20));
+		c = (a*1i) ^ b;
+		c2 = power(a*1i, b);
+		if (c != c2) {
+			m++;
+			if (verbose > 1) {
+				printf("*** comp^real failure for a = %d\n", a);
+			}
+		}
+
+		/* real ^ complex */
+		a = rand(1,1e20);
+		a = a / (int(a/2)+rand(1,1e20));
+		b = rand(1,1e20);
+		b = b / (int(b/2)+rand(1,1e20));
+		c = a ^ (b*1i);
+		c2 = power(a, b*1i);
+		if (c != c2) {
+			m++;
+			if (verbose > 1) {
+				printf("*** real^comp failure for a = %d\n", a);
+			}
+		}
+
+		/* complex ^ complex */
+		a = rand(1,1e20);
+		a = a / (int(a/2)+rand(1,1e20));
+		b = rand(1,1e20);
+		b = b / (int(b/2)+rand(1,1e20));
+		c = (a*1i) ^ (b*1i);
+		c2 = power(a*1i, b*1i);
+		if (c != c2) {
+			m++;
+			if (verbose > 1) {
+				printf("*** comp^comp failure for a = %d\n", a);
+			}
+		}
+	}
+	epsilon(oldeps),;
+	if (verbose > 0) {
+		if (m) {
+			printf("*** %d error(s)\n", m);
+			printf("    %s: rem/eps min=%d, max=%d\n",
+			       str, min, max);
+		} else {
+			printf("no errors\n");
+		}
+	}
+	if (verbose > 1) {
+		printf("    %s: rem/eps min=%0.4d, max=%0.4d\n", str, min, max);
+	}
+	return m;
+}
+
+
 define cpow(a, b, eps)		/* Find rem/eps for power(a,b,eps) */
 {
 	local v, v1, c, n, d, h;
@@ -480,8 +598,9 @@ define test2600(verbose, tnum)
 	for (i=0; i < 32; ++i) {
 		config("sqrt", i);
 		err += testsqrt(strcat(str(tnum++),": sqrt",str(i)), n*10,
-			        ep, verbose);
+				ep, verbose);
 	}
+	err += testpower2(strcat(str(tnum++),": power"), n*4, ep, verbose);
 	if (verbose > 1) {
 		if (err) {
 			print "***", err, "error(s) found in test2600";
@@ -491,26 +610,3 @@ define test2600(verbose, tnum)
 	}
 	return tnum;
 }
-
-global lib_debug;
-if (lib_debug >= 0) {
-	print "global defaultverbose defined";
-	print "global err defined";
-	print "testismult(str,n,verbose) defined";
-	print "testsqrt(str,n,eps,verbose) defined";
-	print "testexp(str,n,eps,verbose) defined";
-	print "testln(str,n,eps,verbose) defined";
-	print "testpower(str,n,b,eps,verbose) defined";
-	print "testgcd(str,n,verbose) defined";
-	print "cpow(x,n,eps) defined";
-	print "cexp(x,eps) defined";
-	print "cln(x,eps) defined";
-	print "mkreal() defined";
-	print "mkcomplex() defined";
-	print "mkbigreal() defined";
-	print "mksmallreal() defined";
-	print "testappr(str,n,verbose) defined";
-	print "checkappr(x,y,z,verbose) defined";
-	print "checkresult(x,y,z,a) defined";
-	print "test2600(verbose,tnum) defined";
-}

cal/test2700.cal

@@ -1,27 +1,47 @@
 /*
- * Copyright (c) 1996 Ernest Bowen and Landon Curt Noll
+ * test2700 - 2700 series of the regress.cal test suite
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * By: Ernest Bowen and Landon Curt Noll
+ * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
- *     ernie@neumann.une.edu.au and chongo@toad.com
  *
- * This library is used by the 2700 series of the regress.cal test suite.
+ * Primary author:  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test2700.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test2700.cal,v $
+ *
+ * Under source code control:	1995/11/01 22:52:25
+ * File existed as early as:	1995
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
+
 /*
- * The following script gives a severe test of sqrt(x,y,z) for
+ * The following resource file gives a severe test of sqrt(x,y,z) for
  * all 128 values of z, randomly produced real and complex x, and randomly
  * produced nonzero values for y.  After loading it, testcsqrt(n) will
  * test n combinations of x and y;  testcsqrt(str,n,2) will print 1 2 3 ...
  * indicating work in process; testcsqrt(str,n,3) will give information about
- * errors detected and will print values of x and y used.  The
+ * errors detected and will print values of x and y used.
- * number generators are essentially as in the script I sent yesterday.
  * I've also defined a function iscomsq(x) which does for complex as well
  * as real x what issq(x) currently does for real x.
  */
 
-global defaultverbose = 1;
+
-global err;
+defaultverbose = 1;
 
 define mknonnegreal() {
 	switch(rand(8)) {
@@ -68,11 +88,11 @@ define mkfrac() = rand(2) ? mkposfrac() : -mkposfrac();
 define mksquarereal() = mknonnegreal()^2;
 
 /*
- * XXX - Should be able to do better than the following.  For nonsquare
+ * We might be able to do better than the following.  For nonsquare
- * positive integer less than 1e6, could use
+ * positive integer less than 1e6, could use:
  *		 x = rand(1, 1000);
  *		 return rand(x^2 + 1, (x + 1)^2);
- * Maybe could do
+ * Maybe could do:
  *		do
  *			x = mkreal_2700();
  *		while
@@ -124,7 +144,7 @@ define testcsqrt(str, n, verbose)
 }
 
 
-define checksqrt(x,y,z,v) 	/* Returns >0 if an error is detected */
+define checksqrt(x,y,z,v)	/* Returns >0 if an error is detected */
 {
 	local A, B, X, Y, t1, t2, eps, u, n, f, s;
 
@@ -308,24 +328,3 @@ define test2700(verbose, tnum)
 	}
 	return tnum;
 }
-
-global lib_debug;
-if (lib_debug >= 0) {
-	print "global defaultverbose defined";
-	print "global err defined";
-	print "mknonnegreal() defined";
-	print "mkposreal() defined";
-	print "mkreal_2700() defined";
-	print "mknonzeroreal() defined";
-	print "mkposfrac() defined";
-	print "mkfrac() defined";
-	print "mksquarereal() defined";
-	print "mknonsquarereal() defined";
-	print "mkcomplex_2700() defined";
-	print "testcsqrt(str,n,verbose) defined";
-	print "checksqrt(x,y,z,v) defined";
-	print "checkavrem(A,B,X,eps) defined";
-	print "checkrounding(s,n,t,u,z) defined";
-	print "iscomsq(x) defined";
-	print "test2700(verbose,tnum) defined";
-}

cal/test3100.cal

@@ -0,0 +1,40 @@
+/*
+ * test3100 - 3100 series of the regress.cal test suite
+ *
+ * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
+ *
+ * Primary author:  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test3100.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test3100.cal,v $
+ *
+ * Under source code control:	1995/11/28 11:56:57
+ * File existed as early as:	1995
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+obj res {r};
+global md;
+define res_test(a) = !ismult(a.r, md);
+define res_sub(a,b) {local obj res v = {(a.r - b.r) % md}; return v;};
+define res_mul(a,b) {local obj res v = {(a.r * b.r) % md}; return v;};
+define res_neg(a) {local obj res v = {(-a.r) % md}; return v;};
+define res_inv(a) {local obj res v = {minv(a.r, md)}; return v;};
+define res(x) {local obj res v = {x % md}; return v;};

cal/test3300.cal

@@ -1,16 +1,36 @@
 /*
- * Copyright (c) 1995 Ernest Bowen and Landon Curt Noll
+ * test3300 - 3300 series of the regress.cal test suite
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * By: Ernest Bowen and Landon Curt Noll
+ * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
- *     ernie@neumann.une.edu.au and chongo@toad.com
  *
- * This library is used by the 3300 series of the regress.cal test suite.
+ * Primary author:  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test3300.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test3300.cal,v $
+ *
+ * Under source code control:	1995/12/02 04:27:41
+ * File existed as early as:	1995
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
 
-global defaultverbose = 1;	/* default verbose value */
+
-global err;
+defaultverbose = 1;	/* default verbose value */
 
 define testi(str, n, N, verbose)
 {
@@ -61,9 +81,9 @@ define testr(str, n, N, verbose)
 	for (i = 0; i < n; i++)
 		for (j = 0; j < n; j++)
 			A[i,j] = rand(-(N^2), N^2)/rand(1, N);
-	t = runtime();
+	t = usertime();
 	d1 = det(A);
-	t = runtime() - t;
+	t = usertime() - t;
 	d2 = det(A^2);
 	if (d2 != d1^2) {
 		if (verbose > 0) {
@@ -122,13 +142,3 @@ define test3300(verbose, tnum)
 	}
 	return tnum;
 }
-
-global lib_debug;
-
-if (lib_debug >= 0) {
-	print "global defaultverbose defined";
-	print "global err defined";
-	print "testi(str, n, N, verbose) defined";
-	print "testr(str, n, N, verbose) defined";
-	print "test3300(verbose, tnum) defined";
-}

cal/test3400.cal

@@ -1,13 +1,34 @@
 /*
- * Copyright (c) 1996 Ernest Bowen and Landon Curt Noll
+ * test3400 - 3400 series of the regress.cal test suite
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * By: Ernest Bowen and Landon Curt Noll
+ * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
- *     ernie@neumann.une.edu.au and chongo@toad.com
  *
- * This library is used by the 3400 series of the regress.cal test suite.
+ * Primary author:  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test3400.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test3400.cal,v $
+ *
+ * Under source code control:	1995/12/02 05:20:11
+ * File existed as early as:	1995
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
+
 /*
  * tests of performance of some trigonometric functions
  *
@@ -32,8 +53,8 @@
  * that the two sides might differ by eps.  [[test changed to test eps error]]
  */
 
-global defaultverbose = 1;	/* default verbose value */
+
-global err;
+defaultverbose = 1;	/* default verbose value */
 
 global pi1k = pi(1e-1000);
 
@@ -299,17 +320,3 @@ define test3400(verbose, tnum)
 	}
 	return tnum;
 }
-
-global lib_debug;
-
-if (lib_debug >= 0) {
-	print "global defaultverbose defined";
-	print "global err defined";
-	print "test3401(str, n, eps, verbose) defined";
-	print "test3402(str, n, eps, verbose) defined";
-	print "test3403(str, n, eps, verbose) defined";
-	print "test3404(str, n, eps, verbose) defined";
-	print "test3405(str, n, eps, verbose) defined";
-	print "test3406(str, n, eps, verbose) defined";
-	print "test3400(verbose, tnum) defined";
-}

cal/test3500.cal

@@ -1,18 +1,39 @@
 /*
- * Copyright (c) 1996 Ernest Bowen and Landon Curt Noll
+ * test3500 - 3500 series of the regress.cal test suite
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * By: Ernest Bowen and Landon Curt Noll
+ * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
- *     ernie@neumann.une.edu.au and chongo@toad.com
  *
- * This library is used by the 3500 series of the regress.cal test suite.
+ * Primary author:  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test3500.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test3500.cal,v $
+ *
+ * Under source code control:	1995/12/18 22:50:46
+ * File existed as early as:	1995
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
+
 /*
  * Stringent tests of the functions frem, fcnt, gcdrem.
  *
  * testf(n) gives n tests of frem(x,y) and fcnt(x,y) with randomly
- * 	integers x and y generated so that x = f * y^k where f, y and
+ *	integers x and y generated so that x = f * y^k where f, y and
  *	k are randomly generated.
  *
  * testg(n) gives n tests of gcdrem(x,y) with x and y generated as for
@@ -22,7 +43,7 @@
  *	powers of small primes some of which are common to both x and y.
  *	This test uses f = abs(x) and iteratively f = frem(f,p) where
  *	p varies over the prime divisors of y; the final value for f
- *	should equal g.  For both x and y the primes are raised to the
+ *	should equal g.	 For both x and y the primes are raised to the
  *	power rand(N); N defaults to 10.
  *
  * If verbose is > 1, the numbers x, y and values for some of the
@@ -31,8 +52,8 @@
  *
  */
 
-global defaultverbose = 1;	/* default verbose value */
+
-global err;
+defaultverbose = 1;	/* default verbose value */
 
 define testfrem(x,y,verbose)
 {
@@ -272,15 +293,3 @@ define test3500(verbose, tnum, n, N)
 	}
 	return tnum;
 }
-
-global lib_debug;
-if (lib_debug >= 0) {
-	print "global defaultverbose defined";
-	print "global err defined";
-	print "testfrem(x, y, verbose) defined";
-	print "testgcdrem(x, y, verbose) defined";
-	print "testf(str, n, verbose) defined";
-	print "testg(str, n, verbose) defined";
-	print "testh(str, n, N, verbose) defined";
-	print "test3500(verbose, n, N) defined";
-}

cal/test4000.cal

@@ -1,13 +1,34 @@
 /*
- * Copyright (c) 1996 Ernest Bowen and Landon Curt Noll
+ * test4000 - 4000 series of the regress.cal test suite
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * By: Ernest Bowen and Landon Curt Noll
+ * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
- *     ernie@neumann.une.edu.au and chongo@toad.com
  *
- * This library is used by the 4000 series of the regress.cal test suite.
+ * Primary author:  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test4000.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test4000.cal,v $
+ *
+ * Under source code control:	1996/03/13 02:38:45
+ * File existed as early as:	1996
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
+
 /*
  * Functions for testing and timing ptest, nextcand, prevcand.
  *
@@ -53,8 +74,8 @@
  *	modulus to 1.
  */
 
-global defaultverbose = 1;      /* default verbose value */
+
-global err;
+defaultverbose = 1;	/* default verbose value */
 
 /*
  * test defaults
@@ -124,7 +145,7 @@ define ptimes(str, N, n, count, skip, verbose)
 	mat A[n];
 	for (i = 0; i < n; i++)
 		A[i] = plen(N);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++) {
 		p = ptest(A[i], count, skip);
 		if (!p) {
@@ -138,7 +159,7 @@ define ptimes(str, N, n, count, skip, verbose)
 		if (m) {
 			printf("*** %d error(s)\n", m);
 		} else {
-			t = round(runtime() - t, 4);
+			t = round(usertime() - t, 4);
 			if (verbose > 1) {
 				printf("%d probable primes: time = %d\n", n, t);
 			} else {
@@ -173,7 +194,7 @@ define ctimes(str, N, n, count, skip, verbose)
 	mat A[n];
 	for (i = 0; i < n; i++)
 		A[i] = clen(N);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++) {
 		p = ptest(A[i], count, skip);
 		if (p) {
@@ -187,7 +208,7 @@ define ctimes(str, N, n, count, skip, verbose)
 		if (m) {
 			printf("*** %d error(s)\n", m);
 		} else {
-			t = round(runtime() - t, 4);
+			t = round(usertime() - t, 4);
 			if (verbose > 1) {
 				printf("%d probable primes: time = %d\n", n, t);
 			} else {
@@ -221,7 +242,7 @@ define crtimes(str, a, b, n, count, skip, verbose)
 		A[i] = rand(a,b);
 		P[i] = ptest(A[i], 20, 0);
 	}
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++) {
 		p = ptest(A[i], count, skip);
 		if (p != P[i]) {
@@ -236,7 +257,7 @@ define crtimes(str, a, b, n, count, skip, verbose)
 		if (m) {
 			printf("*** %d error(s)?\n", m);
 		} else {
-			t = round(runtime() - t, 4);
+			t = round(usertime() - t, 4);
 			if (verbose > 1) {
 				printf("%d probable primes: time = %d\n", n, t);
 			} else {
@@ -274,16 +295,16 @@ define ntimes(str, N, n, count, skip, residue, modulus, verbose)
 	mat A[n];
 	for (i = 0; i < n; i++)
 		A[i] = rlen(N);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++) {
 		p = nextcand(A[i], count, skip, residue, modulus);
 	}
-	tnext = round(runtime() - t, 4);
+	tnext = round(usertime() - t, 4);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++) {
 		p = prevcand(A[i], count, skip, residue, modulus);
 	}
-	tprev = round(runtime() - t, 4);
+	tprev = round(usertime() - t, 4);
 	if (verbose > 0) {
 		printf("%d evaluations, nextcand: %d, prevcand: %d\n", n, tnext, tprev);
 	}
@@ -302,7 +323,7 @@ define testnextcand(str, N, n, count, skip, residue, modulus, verbose)
 	if (isnull(count))
 		count = COUNT;
 	if (isnull(n)) {
- 		n = ceil(K3/(H3 + N^3));
+		n = ceil(K3/(H3 + N^3));
 		print "n =",n;
 	}
 	if (isnull(skip))
@@ -356,7 +377,7 @@ define testprevcand(str, N, n, count, skip, residue, modulus, verbose)
 	if (isnull(count))
 		count = COUNT;
 	if (isnull(n)) {
- 		n = ceil(K3/(H3 + N^3));
+		n = ceil(K3/(H3 + N^3));
 		print "n =",n;
 	}
 	if (isnull(skip))
@@ -452,34 +473,3 @@ define test4000(v, tnum)
 	}
 	return tnum;
 }
-
-
-global lib_debug;
-
-if (lib_debug >= 0) {
-	print "global defaultverbose";
-	print "global err";
-	print "global BASEB";
-	print "global BASE";
-	print "global COUNT";
-	print "global SKIP";
-	print "global RESIDUE";
-	print "global MODULUS";
-	print "global K1";
-	print "global H1";
-	print "global K2";
-	print "global H2";
-	print "global K3";
-	print "global H3";
-	print "plen(N) defined";
-	print "clen(N) defined";
-	print "ptimes(str, N, n, count, skip, verbose) defined";
-	print "ctimes(str, N, n, count, skip, verbose) defined";
-	print "crtimes(str, a, b, n, count, skip, verbose) defined";
-	print "ntimes(str, N, n, count, skip, residue, mod, verbose) defined";
-	print "testnextcand(str, N, n, cnt, skip, res, mod, verbose) defined";
-	print "testnext1(x, y, count, skip, residue, modulus) defined";;
-	print "testprevcand(str, N, n, cnt, skip, res, mod, verbose) defined";
-	print "testprev1(x, y, count, skip, residue, modulus) defined";
-	print "test4000(verbose, tnum) defined";
-}

cal/test4100.cal

@@ -1,13 +1,34 @@
 /*
- * Copyright (c) 1996 Ernest Bowen and Landon Curt Noll
+ * test4100 - 4100 series of the regress.cal test suite
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * By: Ernest Bowen and Landon Curt Noll
+ * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
- *     ernie@neumann.une.edu.au and chongo@toad.com
  *
- * This library is used by the 4100 series of the regress.cal test suite.
+ * Primary author:  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test4100.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test4100.cal,v $
+ *
+ * Under source code control:	1996/03/13 03:53:22
+ * File existed as early as:	1996
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
+
 /*
  * Some severe tests and timing functions for REDC functions and pmod.
  *
@@ -48,18 +69,17 @@
  *
  */
 
-global defaultverbose = 1;      /* default verbose value */
+
-global err;
+defaultverbose = 1;	/* default verbose value */
 
 /*
  * test defaults
  */
-global K1 = 2^17;
+global test4100_K1 = 2^17;
-global K2 = 2^12;
+global test4100_K2 = 2^12;
-global BASEB = 16;
+global test4100_BASE = 2^config("baseb");
-global BASE = 2^BASEB;
 
-define rlen_4100(N) = rand(BASE^(N-1), BASE^N);
+define rlen_4100(N) = rand(test4100_BASE^(N-1), test4100_BASE^N);
 
 define olen(N)
 {
@@ -212,7 +232,7 @@ define times(str,N,n,verbose)
 	m = olen(N);
 	m2 = m^2;
 	if (isnull(n)) {
-		n = ceil(K1/power(N,1.585));
+		n = ceil(test4100_K1/power(N,1.585));
 		if (verbose > 1)
 			printf("n = %d\n", n);
 	}
@@ -225,38 +245,38 @@ define times(str,N,n,verbose)
 		C[i] = rand(m2);
 	}
 	z = rcin(0,m);	/* to initialize redc and maybe lastmod information */
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		z = rcin(A[i],m);
-	trcin = round(runtime() - t, 3);
+	trcin = round(usertime() - t, 3);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		z = rcout(A[i],m);
-	trcout = round(runtime() - t, 3);
+	trcout = round(usertime() - t, 3);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		z = rcmul(A[i],B[i],m);
-	trcmul = round(runtime() - t, 3);
+	trcmul = round(usertime() - t, 3);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		z = rcsq(A[i],m);
-	trcsq = round(runtime() - t, 3);
+	trcsq = round(usertime() - t, 3);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		z = A[i] * B[i];
-	tmul = round(runtime() - t, 3);
+	tmul = round(usertime() - t, 3);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		z = A[i]^2;
-	tsq = round(runtime() - t, 3);
+	tsq = round(usertime() - t, 3);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		z = C[i] % A[i];
-	tmod = round(runtime() - t, 3);
+	tmod = round(usertime() - t, 3);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		quomod(C[i], A[i], x, y);
-	tquomod = round(runtime() - t,3);
+	tquomod = round(usertime() - t,3);
 
 	if (verbose > 1) {
 		printf("rcin: %d, rcout: %d, rcmul: %d, rcsq: %d\n",
@@ -286,7 +306,7 @@ define powtimes(str, N1, N2, n, verbose)
 		N2 = 1;
 
 	if (isnull(n)) {
-		n = ceil(K2/power(N1, 1.585)/N2);
+		n = ceil(test4100_K2/power(N1, 1.585)/N2);
 		printf ("n  = %d\n", n);
 	}
 	mat A[n];
@@ -294,8 +314,8 @@ define powtimes(str, N1, N2, n, verbose)
 	mat B[n];
 	v = olen(N1);
 
-	cp = config("pow2", 1);
+	cp = config("pow2", 2);
-	crc = config("redc2", 1);
+	crc = config("redc2", 2);
 
 	/* initialize redc and lastmod info */
 
@@ -306,29 +326,29 @@ define powtimes(str, N1, N2, n, verbose)
 		Ar[i] = rcin(A[i], v);
 		B[i] = rlen_4100(N2);
 	}
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		z1 += pmod(A[i], B[i], v);
-	tbignum = round(runtime() - t, 4);
+	tbignum = round(usertime() - t, 4);
 	config("pow2", 1e6);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		z2 += pmod(A[i], B[i], v);
-	tnormal = round(runtime() - t, 4);
+	tnormal = round(usertime() - t, 4);
 	config("redc2",1e6);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		z3 += pmod(A[i], B[i], v);
-	tsmall = round(runtime() - t, 4);
+	tsmall = round(usertime() - t, 4);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		z4 += rcpow(Ar[i], B[i], v);
-	trcsmall = round(runtime() - t, 4);
+	trcsmall = round(usertime() - t, 4);
-	config("redc2", 1);
+	config("redc2", 2);
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		z5 += rcpow(Ar[i], B[i], v);
-	trcbig = round(runtime() - t, 4);
+	trcbig = round(usertime() - t, 4);
 
 	if (z1 != z2) {
 		++m;
@@ -386,7 +406,7 @@ define inittimes(str,N,n,verbose)
 	}
 	m = 0;
 	if (isnull(n)) {
-		n = ceil(K1/N^2);
+		n = ceil(test4100_K1/N^2);
 		if (verbose > 1) {
 			printf ("n = %d\n", n);
 		}
@@ -399,13 +419,13 @@ define inittimes(str,N,n,verbose)
 		M[i] = olen(N);
 		A[i] = rand(M[i]);
 	}
-	t = runtime();
+	t = usertime();
 	for (i = 0; i < n; i++)
 		R[i] = rcin(A[i], M[i]);
-	trcin = round(runtime() - t, 4);
+	trcin = round(usertime() - t, 4);
 	for (i = 0; i < n; i++)
 		B[i] = rcout(R[i], M[i]);
-	trcout = round(runtime() - t, 4);
+	trcout = round(usertime() - t, 4);
 	for (i = 0; i < n; i++) {
 		if (B[i] != A[i]) {
 			++m;
@@ -472,22 +492,3 @@ define test4100(v, tnum)
 	}
 	return tnum;
 }
-
-global lib_debug;
-
-if (lib_debug >= 0) {
-	print "global defaultverbose";
-	print "global err";
-	print "global K1";
-	print "global K2";
-	print "global BASEB";
-	print "global BASE";
-	print "rlen_4100(N) defined";
-	print "olen(N) defined";
-	print "test4101(x, y, m, k, z1, z2) defined";
-	print "testall(str, n, N, M, verbose) defined";
-	print "times(str, N, n, verbose) defined";
-	print "powtimes(str, N1, N2, n, verbose) defined";
-	print "inittimes(str, N, n, verbose) defined";
-	print "test4100(verbose, tnum) defined";
-}

cal/test4600.cal

@@ -1,17 +1,36 @@
 /*
- * Copyright (c) 1996 Ernest Bowen and Landon Curt Noll
+ * test4600 - 4600 series of the regress.cal test suite
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * By: Ernest Bowen and Landon Curt Noll
+ * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
- *     ernie@neumann.une.edu.au and chongo@toad.com
  *
- * This library is used by the 4600 series of the regress.cal test suite.
+ * Primary author:  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test4600.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test4600.cal,v $
+ *
+ * Under source code control:	1996/07/02 20:04:40
+ * File existed as early as:	1996
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 
-global defaultverbose = 1		/* default verbose value */
+defaultverbose = 1;	/* default verbose value */
-global err;
 
 /*
  * test globals
@@ -28,15 +47,15 @@ define stest(str, verbose)
 	if (verbose > 0) {
 		print str:":",:;
 	}
-	x = rm("junk4600");
+	x = rm("-f", "junk4600");
 
 	/*
 	 * do file operations
 	 */
-	f = fopen("junk4600", "w");
+	f = fopen("junk4600", "wb");
 	if (iserror(f)) {
 		print 'failed';
-		print '**** fopen("junk4600", "w") failed';
+		print '**** fopen("junk4600", "wb") failed';
 		return 1;
 	}
 	if (iserror(fputs(f,
@@ -47,9 +66,9 @@ define stest(str, verbose)
 		print '**** fputs(f, "Fourscore ... failed';
 		return 1;
 	}
-	if (iserror(freopen(f, "r"))) {
+	if (iserror(freopen(f, "rb"))) {
 		print 'failed';
-		print '**** iserror(freopen(f, "r")) failed';
+		print '**** iserror(freopen(f, "rb")) failed';
 		return 1;
 	}
 	if (iserror(rewind(f))) {
@@ -92,14 +111,14 @@ define stest(str, verbose)
 		print '**** rsearch(f, "and") != 109 failed';
 		return 1;
 	}
-	if (ftell(f) != 112) {
+	if (ftell(f) != 111) {
 		print 'failed';
-		print '**** ftell(f) != 112 failed';
+		print '**** ftell(f) != 111 failed';
 		return 1;
 	}
-	if (iserror(fseek(f, -1, 1))) {
+	if (iserror(fseek(f, -4, 1))) {
 		print 'failed';
-		print '**** iserror(fseek(f, -1, 1)) failed';
+		print '**** iserror(fseek(f, -4, 1)) failed';
 		return 1;
 	}
 	if (rsearch(f, "and") != 10) {
@@ -107,14 +126,14 @@ define stest(str, verbose)
 		print '**** rsearch(f, "and") != 10 failed';
 		return 1;
 	}
-	if (ftell(f) != 13) {
+	if (ftell(f) != 12) {
 		print 'failed';
-		print '**** ftell(f) != 13 failed';
+		print '**** ftell(f) != 12 failed';
 		return 1;
 	}
-	if (iserror(fseek(f, -1, 1))) {
+	if (iserror(fseek(f, -4, 1))) {
 		print 'failed';
-		print '**** iserror(fseek(f, -1, 1)) failed';
+		print '**** iserror(fseek(f, -4, 1)) failed';
 		return 1;
 	}
 	if (!isnull(rsearch(f, "and"))) {
@@ -152,8 +171,8 @@ define ttest(str, m, n, verbose)
 	if (verbose > 0) {
 		print str:":",:;
 	}
-	i = rm("junk4600");
+	i = rm("-f", "junk4600");
-	f = fopen("junk4600", "w");
+	f = fopen("junk4600", "wb");
 
 	if (isnull(n))
 		n = 4;
@@ -168,16 +187,17 @@ define ttest(str, m, n, verbose)
 		j = 1 + randbit(n);
 		a = "";
 		while (j-- > 0)
-			a = strcat(a, char(rand(1, 256)));
+			a = strcat(a, char(rand(32, 127)));
 		A[i] = a;
 		fputs(f, a);
 		pos[i+1] = ftell(f);
 		if (verbose > 1)
 			printf("A[%d] has length %d\n", i, strlen(a));
 	}
+	fflush(f);
 	if (verbose > 1)
 		printf("File has size %d\n", pos[i]);
-	freopen(f, "r");
+	freopen(f, "rb");
 	if (size(f) != pos[i]) {
 		print 'failed';
 		printf("**** Failure 1 for file size\n");
@@ -216,12 +236,17 @@ define ttest(str, m, n, verbose)
 				break;
 			fseek(f, -1, 1);
 		}
-		if (ftell(f) != pos[i + 1]) {
+		if (ftell(f) != pos[i + 1] - 1) {
 			print 'failed';
 			printf("**** Failure 5 for i = %d\n", i);
 			return 1;
 		}
 	}
+	if (iserror(fclose(f))) {
+		print 'failed';
+		printf("**** Failure 6 for i = %d\n", i);
+		return 1;
+	}
 	i = rm("junk4600");
 	if (verbose > 0) {
 		printf("passed\n");
@@ -298,14 +323,3 @@ define test4600(v, tnum)
 	}
 	return tnum;
 }
-
-global lib_debug;
-
-if (lib_debug >= 0) {
-	print "stest(str [, verbose]) defined";
-	print "ttest([m, [n [,verbose]]]) defined";
-	print "sprint(x) defined";
-	print "findline(f,s) defined";
-	print "findlineold(f,s) defined";
-	print "test4600(verbose, tnum) defined";
-}

cal/test5100.cal

@@ -0,0 +1,70 @@
+/*
+ * test5100 - 5100 series of the regress.cal test suite
+ *
+ * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
+ *
+ * Primary author:  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test5100.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test5100.cal,v $
+ *
+ * Under source code control:	1996/12/02 23:57:10
+ * File existed as early as:	1996
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+defaultverbose = 1;	/* default verbose value */
+
+/*
+ * We test the new code generator declaration scope and order.
+ *
+ * In this function two static variables a5100 and b5100 are created,
+ * with zero value, when the definition is read.
+ *
+ * The variable a5100 is initialized with the value x if and when this
+ * function is first called with a positive even x. The varable b5100
+ * is similarly initialized if and when this function is first called positive
+ * odd x.
+ *
+ * Each time this function is called with positive integer x, a5100 or
+ * b5100 is incremented.
+ *
+ * Finally the values of the static variables are assigned to the global
+ * variables a5100 and b5100.
+ *
+ * Immediately after the last of several calls to this function
+ * a5100 = 0 if none of the x's have been positive even, otherwise
+ * a5100 = the first positive even x + the number of positive even x's,
+ * and b5100 = 0 if none of the x's have been positive odd, otherwise
+ * b5100 = the first positive odd x + the number of positive odd x's.
+ */
+define test5100(x)
+{
+	if (isint(x) && x > 0) {
+		if (iseven(x)) {
+			static a5100 = x;
+			a5100++;
+		} else {
+			static b5100 = x;
+			b5100++;
+		}
+	}
+	global a5100 = a5100, b5100 = b5100;
+}

cal/test5200.cal

@@ -0,0 +1,52 @@
+/*
+ * test5200 - 5200 series of the regress.cal test suite
+ *
+ * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
+ *
+ * Primary author:  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test5200.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test5200.cal,v $
+ *
+ * Under source code control:	1997/02/07 02:48:10
+ * File existed as early as:	1997
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+defaultverbose = 1;	/* default verbose value */
+
+/*
+ * test the fix of a global/static bug
+ *
+ * Given the following:
+ *
+ *	global a = 10;
+ *	static a = 20;
+ *	define f(x) = a + x;
+ *	define g(x) {global a = 30; return a + x;}
+ *	define h(x) = a + x;
+ *
+ * Older versions of
+ */
+global a5200 = 10;
+static a5200 = 20;
+define f5200(x) = a5200 + x;
+define g5200(x) {global a5200 = 30; return a5200 + x;}
+define h5200(x) = a5200 + x;

cal/test8400.cal

@@ -0,0 +1,48 @@
+/*
+ * test8400 - 8400 series of the regress.cal test suite
+ *
+ * Copyright (C) 1999  Landon Curt Noll
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test8400.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test8400.cal,v $
+ *
+ * Under source code control:	1999/10/31 01:00:03
+ * File existed as early as:	1999
+ *
+ * chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+print "8401: in test8400.cal";
+
+/*
+ * test8400 - dummy function to allow a check of quit-based memory leaks
+ */
+define test8400()
+{
+    local x8401 = 19937;    /* watch for lost memory */
+    static s8401 = 44497;   /* watch for lost memory */
+
+    return x8401+s8401;
+}
+print "8402: parsed test8400()";
+vrfy(test8400() == 64434,	    '8403: test8400() == 64434');
+
+quit;
+prob('quit did not end test8400.cal');

cal/test8500.cal

@@ -0,0 +1,264 @@
+/*
+ * test8500 - 8500 series of the regress.cal test suite
+ *
+ * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
+ *
+ * Primary author:  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: test8500.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/test8500.cal,v $
+ *
+ * Under source code control:	1999/11/12 20:59:59
+ * File existed as early as:	1999
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * Tests of // and % operators
+ */
+
+
+global err_8500;	/* divmod_8500 error count */
+global L_8500;		/* list of problem values */
+global ver_8500;	/* test verbosity - see setting comment near bottom */
+global old_seed_8500;	/* old srand() seed */
+
+/*
+ * save the config state so that we can change it and restore later
+ */
+global cfg_8500 = config("all");
+
+
+/*
+ * onetest_8500 - perform one division / remainder test
+ *
+ * Returns:
+ *	0 = test was successful
+ *	>0 = test error indicator
+ */
+define onetest_8500(a,b,rnd) {
+	local q, r, s, S;
+
+	/*
+	 * set a random rounding mode
+	 */
+	config("quo", rnd), config("mod", rnd);
+
+	/*
+	 * perform the division and mod
+	 */
+	q = a // b;
+	r = a % b;
+
+	/*
+	 * verify the fundamental math
+	 */
+	if (a != q * b + r)
+		return 1;
+
+	/*
+	 * determine if the rounding worked
+	 */
+	if (b) {
+		if (rnd & 16)
+			s = sgn(abs(r) - abs(b)/2);
+		else
+			s = sgn(abs(r) - abs(b));
+
+		if (s < 0 || r == 0)
+			return 0;
+
+		if (s > 0)
+			return 2;
+
+		if (((rnd & 16) && s == 0) || !(rnd & 16)) {
+
+			S = sgn(r) * sgn(b);   /* This is sgn(a/b) - a//b */
+			switch (rnd & 15) {
+				case 0: return (S < 0) ? 3 : 0;
+				case 1: return (S > 0) ? 4 : 0;
+				case 2: return (S != sgn(a)*sgn(b)) ? 5 : 0;
+				case 3: return (S != -sgn(a)*sgn(b)) ? 6 : 0;
+					break;
+				case 4: return (S != sgn(b)) ? 7 : 0;
+				case 5: return (S != -sgn(b)) ? 8 : 0;
+				case 6: return (S != sgn(a)) ? 9 : 0;
+				case 7: return (S != -sgn(a)) ? 10 : 0;
+				case 8: return (isodd(q)) ? 11 : 0;
+				case 9: return (iseven(q)) ? 12 : 0;
+				case 10: return (iseven(q) != (a/b > 0)) ? 13:0;
+				case 11: return (isodd(q) != (a/b > 0)) ? 14:0;
+				case 12: return (iseven(q) != (b > 0)) ? 15 : 0;
+				case 13: return (isodd(q) != (b > 0)) ? 16 : 0;
+				case 14: return (iseven(q) != (a > 0)) ? 17 : 0;
+				case 15: return (isodd(q) != (a > 0)) ? 18 : 0;
+			}
+		}
+	}
+
+	/*
+	 * all is well
+	 */
+	return 0;
+}
+
+
+/*
+ * divmod_8500 - perform a bunch of pseudo-random // and % test
+ *
+ * divmod_8500(N, M1, M2) will perform N tests with randomly chosen integers
+ * a, b with abs(a) < M1, abs(b) < M2, which with 50% probability are
+ * converted to a = (2 * a + 1) * b,  b = 2 * b (to give case where
+ * a / b is an integer + 1/2).
+ *
+ * N defaults to 10, M1 to 2^128, M2 to 2^64
+ *
+ * The testnum, if > 0, is used while printing a failure or success.
+ *
+ * The rounding parameter is randomly chosen.
+ *
+ * After a run of divmod_8500 the a, b, rnd values which gave failure are
+ * stored in the list L_8500.  L_8500[0], L_8500[1], L_8500[2] are a, b, rnd for the first
+ * test, etc.
+ */
+define divmod_8500(N = 10, M1 = 2^128, M2 = 2^64, testnum = 0)
+{
+	local a, b, i, v, rnd;
+	local errmsg;		/* error message to display */
+
+	/*
+	 * firewall
+	 */
+	if (!isint(M1) || M1 < 2)
+		quit "Bad second arg for dtest";
+
+	if (!isint(M2) || M2 < 2)
+		quit "Bad third arg for dtest";
+
+	/*
+	 * test setup
+	 */
+	err_8500 = 0;
+	L_8500 = list();
+
+	/*
+	 * perform the random results
+	 */
+	for (i = 0; i < N; i++) {
+
+		/*
+		 * randomly select two values in the range controlled by M1,M2
+		 */
+		a = rand(-M1+1, M1);
+		b = rand(-M2+1, M2);
+		if (rand(2)) {
+			a = (2 * a + 1) * b;
+			b *= 2;
+		}
+
+		/*
+		 * seelect one of the 32 rounding modes at random
+		 */
+		rnd = rand(32);
+
+		/*
+		 * ver_8500 pre-test reporting
+		 */
+		if (ver_8500 > 1)
+			printf("Test %d: a = %d, b = %d, rnd = %d\n",
+					 i, a, b, rnd);
+
+		/*
+		 * perform the actual test
+		 */
+		v = onetest_8500(a, b, rnd);
+
+		/*
+		 * individual test analysis
+		 */
+		if (v != 0) {
+			err_8500++;
+			if (ver_8500 != 0) {
+				if (testnum > 0) {
+					errmsg = strprintf(
+						"Failure %d on test %d", v, i);
+					prob(errmsg);
+				} else {
+					printf("Failure %d on test %d", v, i);
+				}
+			}
+			append(L_8500, a, b, rnd);
+		}
+	}
+
+	/*
+	 * report in the results
+	 */
+	if (err_8500) {
+		if (testnum > 0) {
+			errmsg = strprintf(
+			    "%d: divmod_8500(%d,,,%d): %d failures",
+			    testnum, N, testnum, err_8500);
+			prob(errmsg);
+		} else {
+			printf("%s failure%s", err_8500,
+			       (err_8500 > 1) ? "s" : "");
+		}
+	} else {
+		if (testnum > 0) {
+			errmsg = strprintf("%d: divmod_8500(%d,,,%d)",
+			    testnum, N, testnum);
+			vrfy(err_8500 == 0, errmsg);
+		} else {
+			print "No failure";
+		}
+	}
+}
+
+/*
+ * ver_8500 != 0 displays failures; ver_8500 > 1 displays all numbers tested
+ */
+ver_8500 = 0;
+print '8501: ver_8500 = 0';
+old_seed_8500 = srand(31^61);
+print '8502: old_seed_8500 = srand(31^61)';
+
+/*
+ * do the tests
+ */
+divmod_8500(250, 2^128, 2^1, 8503);
+divmod_8500(250, 2^128, 2^64, 8504);
+divmod_8500(250, 2^256, 2^64, 8505);
+divmod_8500(250, 2^1024, 2^64, 8506);
+divmod_8500(250, 2^1024, 2^128, 8507);
+divmod_8500(250, 2^16384, 2^1024, 8508);
+divmod_8500(1000, 2^128, 2^64, 8509);
+
+/*
+ * restore state
+ */
+config("all", cfg_8500),;
+print '8510: config("all", cfg_8500),';
+srand(old_seed_8500),;
+print '8511: srand(old_seed_8500),';
+
+/*
+ * finished with 8500 tests
+ */
+print '8512: Ending test_divmod';

cal/unitfrac.cal

@@ -0,0 +1,55 @@
+/*
+ * unixfrac - represent a fraction as a sum of distince unit fractions
+ *
+ * Copyright (C) 1999  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: unitfrac.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/unitfrac.cal,v $
+ *
+ * Under source code control:	1990/02/15 01:50:38
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * Represent a fraction as sum of distinct unit fractions.
+ * The output is the unit fractions themselves, and in square brackets,
+ * the number of digits in the numerator and denominator of the value left
+ * to be found.	 Numbers larger than 3.5 become very difficult to calculate.
+ */
+
+
+define unitfrac(x)
+{
+	local	d, di, n;
+
+	if (x <= 0)
+		quit "Non-positive argument";
+	d = 2;
+	do {
+		n = int(1 / x) + 1;
+		if (n > d)
+			d = n;
+		di = 1/d;
+		print '	 [': digits(num(x)): '/': digits(den(x)): ']',, di;
+		x -= di;
+		d++;
+	} while ((num(x) > 1) || (x == di) || (x == 1));
+	print '	 [1/1]',, x;
+}

cal/varargs.cal

@@ -0,0 +1,54 @@
+/*
+ * varargs - example of a varargs-like use
+ *
+ * Copyright (C) 1999  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: varargs.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/varargs.cal,v $
+ *
+ * Under source code control:	1991/05/22 21:56:34
+ * File existed as early as:	1991
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+/*
+ * Example program to use 'varargs'.
+ *
+ * Program to sum the cubes of all the specified numbers.
+ */
+
+
+define sc()
+{
+	local s, i;
+
+	s = 0;
+	for (i = 1; i <= param(0); i++) {
+		if (!isnum(param(i))) {
+			print "parameter",i,"is not a number";
+			continue;
+		}
+		s += param(i)^3;
+	}
+	return s;
+}
+
+if (config("resource_debug") & 3) {
+    print "sc(a, b, ...) defined";
+}

cal/xx_print.cal

@@ -0,0 +1,289 @@
+/*
+ * xx_print - demo print object routines
+ *
+ * Copyright (C) 1999  Ernest Bowen
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: xx_print.cal,v 30.1 2007/03/16 11:09:54 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/xx_print.cal,v $
+ *
+ * Under source code control:	1997/04/17 00:08:50
+ * File existed as early as:	1997
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+global listmax = 3;
+global matrowmax = 3;
+global matcolmax = 3;
+print "globals listmax, matrowmax, matcolmax defined; all assigned value 3";
+print;
+
+global blkmax = 8;
+print "global blkmax defined, assigned value 8";
+print;
+
+B = blk();
+define is_octet(a) = istype(a, B[0]);
+
+define list_print(a) {
+	local i;
+	print "(":;
+	for (i = 0; i < size(a); i++) {
+		if (i > 0)
+			print ",":;
+		if (i >= listmax) {
+			print "...":;
+			break;
+		}
+		print a[[i]]:;
+	}
+	print ")":;
+}
+
+define mat_print (a) {
+	local i, j;
+
+	if (matdim(a) == 1) {
+		for (i = 0; i < size(a); i++) {
+			if (i >= matrowmax) {
+				printf("  ...");
+				break;
+			}
+			printf("%8d", a[i]);
+		}
+		return;
+	}
+	if (matdim(a) > 2)
+		quit "Dimension for mat_print greater than 2";
+
+	for (i = matmin(a,1); i <= matmax(a,1); i++) {
+		if (i >= matmin(a,1) + matcolmax) {
+			print "	    ...";
+			break;
+		}
+		for (j = matmin(a,2); j <= matmax(a,2); j++) {
+			if (j >= matmin(a,2) + matrowmax) {
+				printf("   ...");
+				break;
+			}
+			printf("%8d", a[i,j]);
+		}
+		print;
+	}
+}
+
+define octet_print(a) {
+	switch(a) {
+		case 8: print "BS":;
+			return;
+		case 9: print "HT":;
+			return;
+		case 10: print "NL":;
+			return;
+		case 12: print "FF":;
+			return;
+		case 13: print "CR":;
+			return;
+		case 27: print "ESC":;
+			return;
+	}
+	if (a > 31 && a < 127)
+		print char(a):;
+	else
+		print "Non-print":;
+}
+
+
+define blk_print(a) {
+	local i, n;
+
+	n = size(a);
+
+	printf("Unnamed block with %d bytes of data\n", n);
+	print "First few characters: ":;
+	for (i = 0; i < n; i++) {
+		if (i >= blkmax) {
+			print "...",;
+			break;
+		}
+		print a[i],;
+	}
+}
+
+
+define nblk_print (a) {
+	local n, i;
+
+	n = size(a);
+
+	printf("Block named \"%s\" with %d bytes of data\n", name(a), n);
+	print "First few characters: ":;
+	for (i = 0; i < n; i++) {
+		if (i >= blkmax) {
+			print "...",;
+			break;
+		}
+		print a[i],;
+	}
+}
+
+
+define strchar(a) {
+
+	if (isstr(a))
+		a = ord(a);
+
+	else if (is_octet(a))
+		a = a;		/* This converts octet to number */
+
+	else if (!isint(a) || a < 0 || a > 255)
+		quit "Bad argument for strchar";
+
+	switch (a) {
+		case 7: print "\\a":;
+			return;
+		case 8: print "\\b":;
+			return;
+		case 9: print "\\t":;
+			return;
+		case 10: print "\\n":;
+			return;
+		case 11: print "\\v":;
+			return;
+		case 12: print "\\f":;
+			return;
+		case 13: print "\\r":;
+			return;
+		case 27: print "\\e":;
+			return;
+		case 34: print "\\\"":;
+			return;
+		case 39: print "\\\'":;
+			return;
+		case 92: print "\\\\":;
+			return;
+	}
+	if (a > 31 && a < 127) {
+		print char(a):;
+		return;
+	}
+	print "\\":;
+	if (a >= 64) print a // 64:;
+	a = a % 64;
+	if (a >= 8) print a // 8:;
+	a = a % 8;
+	print a:;
+}
+
+
+define file_print(a) {
+	local c;
+
+	rewind(a);
+	for (;;) {
+		c = fgetc(a);
+		if (iserror(c))
+			quit "Failure when reading from file";
+		if (isnull(c))
+			break;
+		strchar(c);
+	}
+	print;
+}
+
+
+define error_print(a) {
+	local n = iserror(a);
+
+	if (n == 10001) {
+		print "1/0":;
+		return;
+	}
+	if (n == 10002) {
+		print "0/0":;
+		return;
+	}
+	print strerror(a):;
+}
+
+
+L = list(1,2,3,4,5);
+
+mat M1[5] = {1,2,3,4,5};
+
+mat M2[4,4] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+
+B1 = blk() = {"A", "B", "C", "D"};
+B2 = blk("sample") = {77, 102, 29, 13, 126, 8, 100, 27, 0, 1};
+
+dummy = rm("-f", "xx_print.foo");
+f = fopen("xx_print.foo", "w+");
+
+fputstr(f, "alpha\nbeta\f\"gamma\"");
+fputstr(f, "\x09delta\n");
+fputstr(f, "\1\2\3");
+fflush(f);
+
+print "Here is a list:";
+print L;
+print;
+
+print "A one-dimensional matrix:";
+print M1;
+print;
+
+print "A two-dimensional matrix:";
+print M2;
+print;
+
+print "An unnamed block:";
+print B1;
+print;
+
+print "A named block with some special octets:";
+print B2;
+print;
+
+print "A file:";
+print f;
+print;
+
+undefine mat_print;
+
+fclose(f);
+print "f closed";
+print;
+dummy = rm("-f", "xx_print.foo");
+
+mat M[7] = {1, 2, 3/0, 0/0, eval(2+3), fgetc(f), 7};
+print "Here is a matrix with some \"errors\" as elements":
+print M;
+print;
+
+define octet_print(a) {
+	local b, x;
+	x = a;
+
+	for (b = 128; b; b >>= 1)
+		print (x >= b ? (x -= b, 1) : 0):;
+}
+
+print "Here is the earlier block with a new octet_print()";
+print B1;
+print;

calc.h

@@ -1,165 +1,268 @@
 /*
- * Copyright (c) 1995 David I. Bell
+ * calc - definitions for calculator program
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * Definitions for calculator program.
+ * Copyright (C) 1999-2007  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.2 $
+ * @(#) $Id: calc.h,v 30.2 2007/07/10 17:44:52 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/RCS/calc.h,v $
+ *
+ * Under source code control:	1990/02/15 01:48:31
+ * File existed as early as:	before 1990
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
 
-#ifndef	CALC_H
-#define	CALC_H
 
+#if !defined(__CALC_H__)
+#define __CALC_H__
 
-#include <stdio.h>
 #include <setjmp.h>
-#include "value.h"
+#if defined(CALC_SRC)	/* if we are building from the calc source tree */
+# include "decl.h"
+# include "value.h"
+# include "have_const.h"
+#else
+# include <calc/decl.h>
+# include <calc/value.h>
+# include <calc/have_const.h>
+#endif
 
 
 /*
  * Configuration definitions
  */
-#define	CALCPATH	"CALCPATH"	/* environment variable for files */
+#define CALCPATH	"CALCPATH"	/* environment variable for files */
-#define	CALCRC		"CALCRC"	/* environment variable for startup */
+#define CALCRC		"CALCRC"	/* environment variable for startup */
-#define	CALCBINDINGS	"CALCBINDINGS"	/* environment variable for hist bindings */
+#define CALCBINDINGS	"CALCBINDINGS"	/* env variable for hist bindings */
-#define	HOME		"HOME"		/* environment variable for home dir */
+#define HOME		"HOME"		/* environment variable for home dir */
-#define	PAGER		"PAGER"		/* environment variable for help */
+#define PAGER		"PAGER"		/* environment variable for help */
-#define	SHELL		"SHELL"		/* environment variable for shell */
+#define SHELL		"SHELL"		/* environment variable for shell */
-#define DEFAULTCALCHELP	"help"		/* help file that -h prints */
+#define DEFAULTCALCBINDINGS "bindings"	/* default calc bindings file */
+#define DEFAULTCALCHELP "help"		/* help file that -h prints */
 #define DEFAULTSHELL	"sh"		/* default shell to use */
-#define	CALCEXT		".cal"	/* extension for files read in */
+#define CALCEXT		".cal"	/* extension for files read in */
-#define	PATHSIZE	1024	/* maximum length of path name */
+#define MAX_CALCRC	1024	/* maximum length of $CALCRC */
-#define	HOMECHAR	'~'	/* char which indicates home directory */
+#define HOMECHAR	'~'	/* char which indicates home directory */
 #define DOTCHAR		'.'	/* char which indicates current directory */
-#define	PATHCHAR	'/'	/* char which separates path components */
+#define PATHCHAR	'/'	/* char which separates path components */
-#define	LISTCHAR	':'	/* char which separates paths in a list */
+#if defined(__MSDOS__) || defined(__WIN32)
-#define	MAXCMD		16384	/* maximum length of command invocation */
+#define LISTCHAR	';'	/* char which separates paths in a list */
-#define	MAXERROR	512	/* maximum length of error message string */
+#else
+#define LISTCHAR	':'	/* char which separates paths in a list */
+#endif
+#define MAXCMD		16384	/* maximum length of command invocation */
 
-#define	SYMBOLSIZE	256	/* maximum symbol name size */
+#define SYMBOLSIZE	256	/* maximum symbol name size */
-#define	MAXINDICES	20	/* maximum number of indices for objects */
+#define MAXLABELS	100	/* maximum number of user labels in function */
-#define	MAXLABELS	100	/* maximum number of user labels in function */
+#define MAXSTRING	1024	/* maximum size of string constant */
-#define	MAXOBJECTS	10	/* maximum number of object types */
+#define MAXSTACK	2048	/* maximum depth of evaluation stack */
-#define	MAXSTRING	1024	/* maximum size of string constant */
+#define MAXFILES	20	/* maximum number of opened files */
-#define	MAXSTACK	1000	/* maximum depth of evaluation stack */
-#define	MAXFILES	20	/* maximum number of opened files */
 #define PROMPT1		"> "	/* default normal prompt*/
 #define PROMPT2		">> "	/* default prompt inside multi-line input */
 
 
-#define	TRACE_NORMAL	0x00	/* normal trace flags */
+#define TRACE_NORMAL	0x00	/* normal trace flags */
-#define	TRACE_OPCODES	0x01	/* trace every opcode */
+#define TRACE_OPCODES	0x01	/* trace every opcode */
-#define	TRACE_NODEBUG	0x02	/* suppress debugging opcodes */
+#define TRACE_NODEBUG	0x02	/* suppress debugging opcodes */
 #define TRACE_LINKS	0x04	/* display links for real and complex numbers */
 #define TRACE_FNCODES	0x08	/* display code for newly defined function */
-#define	TRACE_MAX	0x0f	/* maximum value for trace flag */
+#define TRACE_MAX	0x0f	/* maximum value for trace flag */
 
 #define ABORT_NONE	0	/* abort not needed yet */
-#define ABORT_STATEMENT	1	/* abort on statement boundary */
+#define ABORT_STATEMENT 1	/* abort on statement boundary */
 #define ABORT_OPCODE	2	/* abort on any opcode boundary */
 #define ABORT_MATH	3	/* abort on any math operation */
 #define ABORT_NOW	4	/* abort right away */
 
+#define ERRMAX 20		/* default errmax value */
+#define E_OK 0			/* no error */
+
 /*
  * File ids corresponding to standard in, out, error, and when not in use.
  */
-#define	FILEID_STDIN	((FILEID) 0)
+#define FILEID_STDIN	((FILEID) 0)
-#define	FILEID_STDOUT	((FILEID) 1)
+#define FILEID_STDOUT	((FILEID) 1)
-#define	FILEID_STDERR	((FILEID) 2)
+#define FILEID_STDERR	((FILEID) 2)
-#define	FILEID_NONE	((FILEID) -1)
+#define FILEID_NONE	((FILEID) -1)	/* must be < 0 */
 
 /*
  * File I/O routines.
  */
-extern FILEID openid(char *name, char *mode);
+E_FUNC FILEID openid(char *name, char *mode);
-extern FILEID indexid(long index);
+E_FUNC FILEID openpathid(char *name, char *mode, char *pathlist);
-extern BOOL validid(FILEID id);
+E_FUNC FILEID indexid(long index);
-extern BOOL errorid(FILEID id);
+E_FUNC BOOL validid(FILEID id);
-extern BOOL eofid(FILEID id);
+E_FUNC BOOL errorid(FILEID id);
-extern int closeid(FILEID id);
+E_FUNC BOOL eofid(FILEID id);
-extern int getcharid(FILEID id);
+E_FUNC int closeid(FILEID id);
-extern int idprintf(FILEID id, char *fmt, int count, VALUE **vals);
+E_FUNC int getcharid(FILEID id);
-extern int idfputc(FILEID id, int ch);
+E_FUNC int idprintf(FILEID id, char *fmt, int count, VALUE **vals);
-extern int idfputs(FILEID id, char *str);
+E_FUNC int idfputc(FILEID id, int ch);
-extern int printid(FILEID id, int flags);
+E_FUNC int idfputs(FILEID id, STRING *str);
-extern int flushid(FILEID id);
+E_FUNC int printid(FILEID id, int flags);
-extern int readid(FILEID id, int flags, char **retptr);
+E_FUNC int flushid(FILEID id);
-extern int getloc(FILEID id, ZVALUE *loc);
+E_FUNC int readid(FILEID id, int flags, STRING **retptr);
-extern int setloc(FILEID id, ZVALUE zpos);
+E_FUNC int getloc(FILEID id, ZVALUE *loc);
-extern int getsize(FILEID id, ZVALUE *size);
+E_FUNC int setloc(FILEID id, ZVALUE zpos);
-extern int get_device(FILEID id, ZVALUE *dev);
+E_FUNC int getsize(FILEID id, ZVALUE *size);
-extern int get_inode(FILEID id, ZVALUE *ino);
+E_FUNC int get_device(FILEID id, ZVALUE *dev);
-extern FILEID reopenid(FILEID id, char *mode, char *name);
+E_FUNC int get_inode(FILEID id, ZVALUE *ino);
-extern int closeall(void);
+E_FUNC FILEID reopenid(FILEID id, char *mode, char *name);
-extern int flushall(void);
+E_FUNC int closeall(void);
-extern int idfputstr(FILEID id, char *str);
+
-extern int rewindid(FILEID id);
+#if !defined(_WIN32)
-extern void rewindall(void);
+E_FUNC int flushall(void);
-extern long filesize(FILEID id);
+#endif
-extern void showfiles(void);
+
-extern int fscanfid(FILEID id, char *fmt, int count, VALUE **vals);
+E_FUNC int idfputstr(FILEID id, char *str);
-extern int scanfstr(char *str, char *fmt, int count, VALUE **vals);
+E_FUNC int rewindid(FILEID id);
-extern long ftellid(FILEID id);
+E_FUNC void rewindall(void);
-extern long fseekid(FILEID id, long offset, int whence);
+E_FUNC ZVALUE zfilesize(FILEID id);
-extern int isattyid(FILEID id);
+E_FUNC void showfiles(void);
-long fsearch(FILEID id, char *str, long pos);
+E_FUNC int fscanfid(FILEID id, char *fmt, int count, VALUE **vals);
-long frsearch(FILEID id, char *str, long pos);
+E_FUNC int scanfstr(char *str, char *fmt, int count, VALUE **vals);
+E_FUNC int ftellid(FILEID id, ZVALUE *res);
+E_FUNC int fseekid(FILEID id, ZVALUE offset, int whence);
+E_FUNC int isattyid(FILEID id);
+E_FUNC int fsearch(FILEID id, char *str, ZVALUE start, ZVALUE end, ZVALUE *res);
+E_FUNC int frsearch(FILEID id, char *str, ZVALUE first, ZVALUE last, ZVALUE *res);
+E_FUNC void showconstants(void);
+E_FUNC void freeconstant(unsigned long);
+E_FUNC void freestringconstant(long);
+E_FUNC void trimconstants(void);
 
 /*
  * Input routines.
  */
-extern FILE *f_open(char *name, char *mode);
+E_FUNC int openstring(char *str, size_t num);
-extern int openstring(char *str);
+E_FUNC int openterminal(void);
-extern int openterminal(void);
+E_FUNC int opensearchfile(char *name, char *pathlist, char *exten, int reopen_ok);
-extern int opensearchfile(char *name, char *pathlist, char *exten, int reopen_ok);
+E_FUNC char *nextline(void);
-extern char *nextline(void);
+E_FUNC int nextchar(void);
-extern int nextchar(void);
+E_FUNC void reread(void);
-extern void reread(void);
+E_FUNC void resetinput(void);
-extern void resetinput(void);
+E_FUNC void setprompt(char *);
-extern void setprompt(char *);
+E_FUNC BOOL inputisterminal(void);
-extern BOOL inputisterminal(void);
+E_FUNC int inputlevel(void);
-extern char *inputname(void);
+E_FUNC long calclevel(void);
-extern long linenumber(void);
+E_FUNC char *inputname(void);
-extern void runrcfiles(void);
+E_FUNC long linenumber(void);
-extern void closeinput(void);
+E_FUNC void runrcfiles(void);
-extern FILE *curstream(void);
+E_FUNC void closeinput(void);
-
 
 /*
  * Other routines.
  */
-extern NUMBER *constvalue(unsigned long index);
+E_FUNC NUMBER *constvalue(unsigned long index);
-extern long addnumber(char *str);
+E_FUNC long addnumber(char *str);
-extern long addqconstant(NUMBER *q);
+E_FUNC long addqconstant(NUMBER *q);
-extern void initstack(void);
+E_FUNC void initstack(void);
-extern void version(FILE *stream);
+E_FUNC void getcommands(BOOL toplevel);
-extern void getcommands(BOOL toplevel);
+E_FUNC void givehelp(char *type);
-extern void givehelp(char *type);
+E_FUNC void libcalc_call_me_first(void);
-extern void hash_init(void);
+E_FUNC void libcalc_call_me_last(void);
-extern void libcalc_call_me_first(void);
+E_FUNC BOOL calc_tty(int fd);
-
+E_FUNC BOOL orig_tty(int fd);
+E_FUNC void showerrors(void);
+E_FUNC char *calc_strdup(CONST char *);
 
 /*
- * Global data definitions.
+ * Initialization
  */
-extern int abortlevel;		/* current level of aborts */
+E_FUNC void initialize(void);
-extern BOOL inputwait;		/* TRUE if in a terminal input wait */
+E_FUNC void reinitialize(void);
-extern VALUE *stack;		/* execution stack */
+#if !defined (_WIN32)
-extern jmp_buf jmpbuf;		/* for errors */
+E_FUNC int isatty(int tty);	/* TRUE if fd is a tty */
-extern int start_done;		/* TRUE => start up processing finished */
-extern int dumpnames;		/* TRUE => dump names rather than indices */
-
-extern char *calcpath;		/* $CALCPATH or default */
-extern char *calcrc;		/* $CALCRC or default */
-extern char *calcbindings;	/* $CALCBINDINGS or default */
-extern char *home;		/* $HOME or default */
-extern char *shell;		/* $SHELL or default */
-
-extern int allow_read;	/* FALSE => may not open any files for reading */
-extern int allow_write;	/* FALSE => may not open any files for writing */
-extern int allow_exec;	/* FALSE => may not execute any commands */
-
-extern int post_init;	/* TRUE => setjmp for math_error is ready */
-
 #endif
+E_FUNC char *version(void);	/* return version string */
 
-/* END CODE */
+/*
+ * global flags and definitions
+ */
+EXTERN int abortlevel;	/* current level of aborts */
+EXTERN BOOL inputwait;	/* TRUE if in a terminal input wait */
+
+EXTERN int p_flag;		/* TRUE => pipe mode */
+EXTERN int q_flag;		/* TRUE => don't execute rc files */
+EXTERN int u_flag;		/* TRUE => unbuffer stdin and stdout */
+EXTERN int d_flag;		/* TRUE => disable heading, resource_debug */
+EXTERN int c_flag;		/* TRUE => continue after error if permitted */
+EXTERN int i_flag;		/* TRUE => try to go interactive after error */
+E_FUNC int s_flag;		/* TRUE => keep args as strings for argv() */
+EXTERN long stoponerror;	/* >0 => stop, <0 => continue, ==0 => use -c */
+EXTERN BOOL abort_now;	/* TRUE => try to go interactive */
+
+E_FUNC int argc_value;	/* count of argv[] strings for argv() builtin */
+E_FUNC char **argv_value;	/* argv[] strings for argv() builtin */
+
+EXTERN char *pager;		/* $PAGER or default */
+EXTERN int stdin_tty;	/* TRUE if stdin is a tty */
+EXTERN int havecommands;	/* TRUE if have cmd args) */
+EXTERN char *program;	/* our name */
+EXTERN char *base_name;	/* basename of our name */
+EXTERN char cmdbuf[];	/* command line expression */
+
+EXTERN int abortlevel;	/* current level of aborts */
+EXTERN BOOL inputwait;	/* TRUE if in a terminal input wait */
+EXTERN VALUE *stack;	/* execution stack */
+EXTERN int dumpnames;	/* TRUE => dump names rather than indices */
+
+EXTERN char *calcpath;	/* $CALCPATH or default */
+EXTERN char *calcrc;	/* $CALCRC or default */
+EXTERN char *calcbindings;	/* $CALCBINDINGS or default */
+EXTERN char *home;		/* $HOME or default */
+EXTERN char *shell;		/* $SHELL or default */
+
+EXTERN int no_env;	/* TRUE (-e) => ignore env vars on startup */
+EXTERN long errmax;	/* if >= 0, error when errcount exceeds errmax */
+EXTERN int use_old_std;	/* TRUE (-O) => use classic configuration */
+
+EXTERN int allow_read;	/* FALSE => dont open any files for reading */
+EXTERN int allow_write; 	/* FALSE => dont open any files for writing */
+EXTERN int allow_exec;	/* FALSE => may not execute any commands */
+
+/*
+ * calc startup and run state
+ */
+typedef enum {
+    RUN_ZERO,			/* unknown or unset start state */
+    RUN_BEGIN,			/* calc execution starts */
+    RUN_RCFILES,		/* rc files being evaluated */
+    RUN_PRE_CMD_ARGS,		/* prepare to evaluate cmd args */
+    RUN_CMD_ARGS,		/* cmd args being evaluated */
+    RUN_PRE_TOP_LEVEL,		/* prepare to start top level activity */
+    RUN_TOP_LEVEL,		/* running at top level */
+    RUN_EXIT,			/* normal exit from calc */
+    RUN_EXIT_WITH_ERROR		/* exit with error */
+} run;
+EXTERN run run_state;
+E_FUNC char *run_state_name(run state);
+
+/*
+ * calc version information
+ */
+#define CALC_TITLE "C-style arbitrary precision calculator"
+EXTERN int calc_major_ver;
+EXTERN int calc_minor_ver;
+EXTERN int calc_major_patch;
+EXTERN int calc_minor_patch;
+EXTERN char *Copyright;
+E_FUNC char *version(void);
+
+
+#endif /* !__CALC_H__ */

calc.spec.in

@@ -0,0 +1,163 @@
+#****h* calc/calc.spec.in
+#
+# calc.spec.in - template specfile for calc
+#
+# Copyright (C) 2003-2007  Petteri Kettunen and Landon Curt Noll
+#
+# Calc is open software; you can redistribute it and/or modify it under
+# the terms of the version 2.1 of the GNU Lesser General Public License
+# as published by the Free Software Foundation.
+#
+# Calc 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 Lesser General
+# Public License for more details.
+#
+# A copy of version 2.1 of the GNU Lesser General Public License is
+# distributed with calc under the filename COPYING-LGPL.  You should have
+# received a copy with calc; if not, write to Free Software Foundation, Inc.
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+# @(#) $Revision: 30.6 $
+# @(#) $Id: calc.spec.in,v 30.6 2007/10/16 12:22:22 chongo Exp $
+# @(#) $Source: /usr/local/src/cmd/calc/RCS/calc.spec.in,v $
+#
+# Under source code control:	2003/02/16 20:21:39
+# File existed as early as:	2003
+#
+# calculator by David I. Bell with help/mods from others
+# Makefile by Petteri Kettunen with modifications from Landon Curt Noll
+
+# BUGS
+#  - Uninstalling calc and calc-devel leaves empty dirs /usr/include/calc
+#    and /usr/share/calc and its subdirs. In case e.g. %{_includedir}/calc
+#    is defined in `%files devel' section, then rpmbuild complains that
+#    header files are defined twice - rpmbuild bug or bug in specfile conf???
+
+Summary: Arbitrary precision calculator.
+Name: calc
+Version: <<<PROJECT_VERSION>>>
+Release: 1.1
+License: LGPL
+Group: Applications/Engineering
+Source: %{name}-%{version}.tar.bz2
+URL: http://www.isthe.com/chongo/tech/comp/calc/index.html
+Requires: ncurses >= 5.2-26, readline >= 4.2, less >= 358
+BuildRequires: ncurses-devel >= 5.2-26, readline-devel >= 4.2
+BuildRoot: %{_tmppath}/%{name}-root
+
+%description
+Calc is arbitrary precision C-like arithmetic system that is a
+calculator, an algorithm prototype and mathematical research
+tool. Calc comes with a rich set of builtin mathematical and
+programmatic functions.
+
+For the latest calc release, see the calc project home page:
+
+    http://www.isthe.com/chongo/tech/comp/calc/index.html
+
+%package devel
+Summary: Development files and documentation for calc.
+Group: Development/Libraries
+PreReq: %{name} = %{version}-%{release}
+
+%description devel
+This package contains the header files and static libraries for developing
+calc (arbitrary precision calculator).
+
+For the latest calc release, see the project home page:
+
+    http://www.isthe.com/chongo/tech/comp/calc/index.html
+
+%prep
+%setup -q
+
+%build
+echo '-=- calc.spec beginning make clobber -=-'
+make %{?_smp_mflags} T=%{buildroot} BINDIR=%{_bindir} LIBDIR=%{_libdir} CALC_SHAREDIR=%{_datadir}/%{name} CALC_INCDIR=%{_includedir}/calc MANDIR=%{_mandir}/man1 EXT= V=@ clobber
+echo '-=- calc.spec ending make clobber -=-'
+echo '-=- calc.spec beginning make calc-static-only -=-'
+make %{?_smp_mflags} T=%{buildroot} BINDIR=%{_bindir} LIBDIR=%{_libdir} CALC_SHAREDIR=%{_datadir}/%{name} CALC_INCDIR=%{_includedir}/calc MANDIR=%{_mandir}/man1 EXT= V=@ calc-static-only BLD_TYPE=calc-static-only
+echo '-=- calc.spec ending make calc-static-only -=-'
+echo '-=- calc.spec beginning make rpm-hide-static -=-'
+make %{?_smp_mflags} T=%{buildroot} BINDIR=%{_bindir} LIBDIR=%{_libdir} CALC_SHAREDIR=%{_datadir}/%{name} CALC_INCDIR=%{_includedir}/calc MANDIR=%{_mandir}/man1 EXT= V=@ rpm-hide-static
+echo '-=- calc.spec ending make rpm-hide-static -=-'
+echo '-=- calc.spec beginning make clobber (again) -=-'
+make %{?_smp_mflags} T=%{buildroot} BINDIR=%{_bindir} LIBDIR=%{_libdir} CALC_SHAREDIR=%{_datadir}/%{name} CALC_INCDIR=%{_includedir}/calc MANDIR=%{_mandir}/man1 EXT= V=@ clobber
+echo '-=- calc.spec ending make clobber (again) -=-'
+echo '-=- calc.spec beginning make calc-dynamic-only -=-'
+make %{?_smp_mflags} T=%{buildroot} BINDIR=%{_bindir} LIBDIR=%{_libdir} CALC_SHAREDIR=%{_datadir}/%{name} CALC_INCDIR=%{_includedir}/calc MANDIR=%{_mandir}/man1 EXT= V=@ calc-dynamic-only BLD_TYPE=calc-dynamic-only LD_SHARE=
+echo '-=- calc.spec ending make calc-dynamic-only -=-'
+echo '-=- calc.spec beginning make chk -=-'
+make %{?_smp_mflags} T=%{buildroot} BINDIR=%{_bindir} LIBDIR=%{_libdir} CALC_SHAREDIR=%{_datadir}/%{name} CALC_INCDIR=%{_includedir}/calc MANDIR=%{_mandir}/man1 EXT= V=@ chk
+echo '-=- calc.spec ending make chk -=-'
+echo '-=- calc.spec beginning make rpm-unhide-static -=-'
+make %{?_smp_mflags} T=%{buildroot} BINDIR=%{_bindir} LIBDIR=%{_libdir} CALC_SHAREDIR=%{_datadir}/%{name} CALC_INCDIR=%{_includedir}/calc MANDIR=%{_mandir}/man1 EXT= V=@ rpm-unhide-static
+echo '-=- calc.spec ending make rpm-unhide-static -=-'
+echo '-=- calc.spec beginning make rpm-clean-static -=-'
+make %{?_smp_mflags} T=%{buildroot} BINDIR=%{_bindir} LIBDIR=%{_libdir} CALC_SHAREDIR=%{_datadir}/%{name} CALC_INCDIR=%{_includedir}/calc MANDIR=%{_mandir}/man1 EXT= V=@ rpm-clean-static
+echo '-=- calc.spec ending make rpm-clean-static -=-'
+echo '-=- calc.spec beginning make rpm-chk-static -=-'
+make %{?_smp_mflags} T=%{buildroot} BINDIR=%{_bindir} LIBDIR=%{_libdir} CALC_SHAREDIR=%{_datadir}/%{name} CALC_INCDIR=%{_includedir}/calc MANDIR=%{_mandir}/man1 EXT= V=@ rpm-chk-static
+echo '-=- calc.spec ending make rpm-chk-static -=-'
+
+%install
+rm -rf %{buildroot}
+mkdir -p %{buildroot}
+echo '-=- calc.spec beginning make install -=-'
+make T=%{buildroot} BINDIR=%{_bindir} LIBDIR=%{_libdir} CALC_SHAREDIR=%{_datadir}/%{name} CALC_INCDIR=%{_includedir}/calc MANDIR=%{_mandir}/man1 EXT= V=@ install
+echo '-=- calc.spec ending make install -=-'
+
+%clean
+rm -rf %{buildroot}
+
+%files
+%defattr(-, root, root)
+%doc BUGS CHANGES COPYING COPYING-LGPL
+%attr(755, root, root) %{_bindir}/calc
+%attr(755, root, root) %{_bindir}/cscript/*
+%attr(644, root, root) %{_mandir}/man1/calc.1.gz
+%attr(644, root, root) %{_datadir}/%{name}/README
+%attr(644, root, root) %{_datadir}/%{name}/bindings
+%attr(644, root, root) %{_datadir}/%{name}/custhelp/*
+%attr(644, root, root) %{_datadir}/%{name}/custom/*.cal
+%attr(644, root, root) %{_datadir}/%{name}/help/*
+%attr(644, root, root) %{_datadir}/%{name}/*.cal
+%attr(644, root, root) %{_datadir}/%{name}/*.line
+%attr(644, root, root) %{_libdir}/libcalc.so.%{version}
+%attr(644, root, root) %{_libdir}/libcustcalc.so.%{version}
+
+%files devel
+%defattr(-, root, root)
+%doc BUGS COPYING COPYING-LGPL LIBRARY
+%attr(755, root, root) %{_bindir}/calc-static
+%attr(644, root, root) %{_includedir}/calc/*
+%attr(644, root, root) %{_libdir}/libcalc.a
+%attr(644, root, root) %{_libdir}/libcustcalc.a
+
+%changelog
+* Sun Sep 01 2007 Landon Curt Noll http://www.isthe.com/chongo
+- Release of calc-2.12.2
+- Calc builds with shared libraries
+* Sun Jun 25 2006 Landon Curt Noll http://www.isthe.com/chongo
+- Changed Copyright to License as per new rpm v4.4 syntax
+* Sun May 20 2006 Landon Curt Noll http://www.isthe.com/chongo
+- Release of calc-2.12.0
+- Added *.line set files to the list of packaged files
+* Sun Dec 11 2005 Landon Curt Noll http://www.isthe.com/chongo
+- Release of calc-2.11.11
+- Fixed description in spec file
+* Wed Feb 26 2003 Landon Curt Noll http://www.isthe.com/chongo
+- Release of calc-2.11.7-2
+- Fixed attributes on include and lib calc-devel files
+- Added BUGS to calc-devel as well as calc
+* Tue Feb 25 2003 Landon Curt Noll http://www.isthe.com/chongo
+- Release of calc-2.11.7-1
+- Require ncurses, readline and less to install.
+- Require ncurses-devel and readline-devel to build.
+* Tue Feb 18 2003 Landon Curt Noll http://www.isthe.com/chongo
+- Misc changes to fit local directory setup
+* Sun Feb 16 2003 Petteri Kettunen <petterik@users.sourceforge.net>
+- initial RPM build
+
+#****

calcerr.tbl

@@ -1,3 +1,31 @@
+#
+# calcerr - error codes and messages
+#
+# Copyright (C) 1999-2006  Ernest Bowen
+#
+# Calc is open software; you can redistribute it and/or modify it under
+# the terms of the version 2.1 of the GNU Lesser General Public License
+# as published by the Free Software Foundation.
+#
+# Calc 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 Lesser General
+# Public License for more details.
+#
+# A copy of version 2.1 of the GNU Lesser General Public License is
+# distributed with calc under the filename COPYING-LGPL.  You should have
+# received a copy with calc; if not, write to Free Software Foundation, Inc.
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+# @(#) $Revision: 30.1 $
+# @(#) $Id: calcerr.tbl,v 30.1 2007/03/16 11:09:46 chongo Exp $
+# @(#) $Source: /usr/local/src/cmd/calc/RCS/calcerr.tbl,v $
+#
+# Under source code control:	1996/05/23 17:38:44
+# File existed as early as:	1996
+#
+# Share and enjoy!  :-)		http://www.isthe.com/chongo/tech/comp/calc/
+
 # This file is used to build calcerr.h include file.
 #
 # Lines should be of the form:
@@ -80,8 +108,8 @@ E_FGETSTR1	Non-file first argument for fgetstr
 E_FGETSTR2	File not open for reading for fgetstr
 E_FGETLINE1	Non-file  argument for fgetline
 E_FGETLINE2	File not open for reading for fgetline
-E_FGETWORD1	Non-file argument for fgetword
+E_FGETFIELD1	Non-file argument for fgetfield
-E_FGETWORD2	File not open for reading for fgetword
+E_FGETFIELD2	File not open for reading for fgetfield
 E_REWIND1	Non-file argument for rewind
 E_FILES		Non-integer argument for files
 E_PRINTF1	Non-string fmt argument for fprint
@@ -120,17 +148,23 @@ E_UNGETC1	Non-file argument for ungetc
 E_UNGETC2	File not open for reading for ungetc
 E_UNGETC3	Bad second argument or other error for ungetc
 E_BIGEXP	Exponent too big in scanning
-E_ISATTY1	Non-file argument for isatty
+E_ISATTY1	E_ISATTY1 is no longer used
-E_ISATTY2	File not open for isatty
+E_ISATTY2	E_ISATTY2 is no longer used
 E_ACCESS1	Non-string first argument for access
 E_ACCESS2	Bad second argument for access
 E_SEARCH1	Bad first argument for search
 E_SEARCH2	Bad second argument for search
 E_SEARCH3	Bad third argument for search
+E_SEARCH4	Bad fourth argument for search
+E_SEARCH5	Cannot find fsize or fpos for search
+E_SEARCH6	File not readable for search
 E_RSEARCH1	Bad first argument for rsearch
 E_RSEARCH2	Bad second argument for rsearch
 E_RSEARCH3	Bad third argument for rsearch
-E_FOPEN3	Too many open files
+E_RSEARCH4	Bad fourth argument for rsearch
+E_RSEARCH5	Cannot find fsize or fpos for rsearch
+E_RSEARCH6	File not readable for rsearch
+E_MANYOPEN	Too many open files
 E_REWIND2	Attempt to rewind a file that is not open
 E_STRERROR1	Bad argument type for strerror
 E_STRERROR2	Index out of range for strerror
@@ -148,7 +182,7 @@ E_MATFILL1	Non-variable first argument for matfill
 E_MATFILL2	Non-matrix first argument-value for matfill
 E_MATDIM	Non-matrix argument for matdim
 E_MATSUM	Non-matrix argument for matsum
-E_ISIDENT	Non-matrix argument for isident
+E_ISIDENT	E_ISIDENT is no longer used
 E_MATTRANS1	Non-matrix argument for mattrans
 E_MATTRANS2	Non-two-dimensional matrix for mattrans
 E_DET1		Non-matrix argument for det
@@ -191,3 +225,227 @@ E_RM2		Unable to remove a file
 E_RDPERM	Operation allowed because calc mode disallows read operations
 E_WRPERM	Operation allowed because calc mode disallows write operations
 E_EXPERM	Operation allowed because calc mode disallows exec operations
+E_MIN		Unordered arguments for min
+E_MAX		Unordered arguments for max
+E_LISTMIN	Unordered items for minimum of list
+E_LISTMAX	Unordered items for maximum of list
+E_SIZE		Size undefined for argument type
+E_NO_C_ARG	Calc must be run with a -C argument to use custom function
+E_NO_CUSTOM	Calc was built with custom functions disabled
+E_UNK_CUSTOM	Custom function unknown, try: show custom
+E_BLK1		Non-integral length for block
+E_BLK2		Negative or too-large length for block
+E_BLK3		Non-integral chunksize for block
+E_BLK4		Negative or too-large chunksize for block
+E_BLKFREE1	Named block does not exist for blkfree
+E_BLKFREE2	Non-integral id specification for blkfree
+E_BLKFREE3	Block with specified id does not exist
+E_BLKFREE4	Block already freed
+E_BLKFREE5	No-realloc protection prevents blkfree
+E_BLOCKS1	Non-integer argument for blocks
+E_BLOCKS2	Non-allocated index number for blocks
+E_COPY1		Non-integer or negative source index for copy
+E_COPY2		Source index too large for copy
+E_COPY3		E_COPY3 is no longer used
+E_COPY4		Non-integer or negative number for copy
+E_COPY5		Number too large for copy
+E_COPY6		Non-integer or negative destination index for copy
+E_COPY7		Destination index too large for copy
+E_COPY8		Freed block source for copy
+E_COPY9		Unsuitable source type for copy
+E_COPY10	Freed block destinction for copy
+E_COPY11	Unsuitable destination type for copy
+E_COPY12	Incompatible source and destination for copy
+E_COPY13	No-copy-from source variable
+E_COPY14	No-copy-to destination variable
+E_COPY15	No-copy-from source named block
+E_COPY16	No-copy-to destination named block
+E_COPY17	No-relocate destination for copy
+E_COPYF1	File not open for copy
+E_COPYF2	fseek or fsize failure for copy
+E_COPYF3	fwrite error for copy
+E_COPYF4	fread error for copy
+E_PROTECT1	Non-variable first argument for protect
+E_PROTECT2	Bad second argument for protect
+E_PROTECT3	Bad third argument for protect
+E_MATFILL3	No-copy-to destination for matfill
+E_MATFILL4	No-assign-from source for matfill
+E_MATTRACE1	Non-matrix argument for mattrace
+E_MATTRACE2	Non-two-dimensional argument for mattrace
+E_MATTRACE3	Non-square argument for mattrace
+E_TAN1		Bad epsilon for tan
+E_TAN2		Bad argument for tan
+E_COT1		Bad epsilon for cot
+E_COT2		Bad argument for cot
+E_SEC1		Bad epsilon for sec
+E_SEC2		Bad argument for sec
+E_CSC1		Bad epsilon for csc
+E_CSC2		Bad argument for csc
+E_SINH1		Bad epsilon for sinh
+E_SINH2		Bad argument for sinh
+E_COSH1		Bad epsilon for cosh
+E_COSH2		Bad argument for cosh
+E_TANH1		Bad epsilon for tanh
+E_TANH2		Bad argument for tanh
+E_COTH1		Bad epsilon for coth
+E_COTH2		Bad argument for coth
+E_SECH1		Bad epsilon for sech
+E_SECH2		Bad argument for sech
+E_CSCH1		Bad epsilon for csch
+E_CSCH2		Bad argument for csch
+E_ASIN1		Bad epsilon for asin
+E_ASIN2		Bad argument for asin
+E_ACOS1		Bad epsilon for acos
+E_ACOS2		Bad argument for acos
+E_ATAN1		Bad epsilon for atan
+E_ATAN2		Bad argument for atan
+E_ACOT1		Bad epsilon for acot
+E_ACOT2		Bad argument for acot
+E_ASEC1		Bad epsilon for asec
+E_ASEC2		Bad argument for asec
+E_ACSC1		Bad epsilon for acsc
+E_ACSC2		Bad argument for acsc
+E_ASINH1	Bad epsilon for asin
+E_ASINH2	Bad argument for asinh
+E_ACOSH1	Bad epsilon for acosh
+E_ACOSH2	Bad argument for acosh
+E_ATANH1	Bad epsilon for atanh
+E_ATANH2	Bad argument for atanh
+E_ACOTH1	Bad epsilon for acoth
+E_ACOTH2	Bad argument for acoth
+E_ASECH1	Bad epsilon for asech
+E_ASECH2	Bad argument for asech
+E_ACSCH1	Bad epsilon for acsch
+E_ACSCH2	Bad argument for acsch
+E_GD1		Bad epsilon for gd
+E_GD2		Bad argument for gd
+E_AGD1		Bad epsilon for agd
+E_AGD2		Bad argument for agd
+E_LOGINF	Log of zero or infinity
+E_STRADD	String addition failure
+E_STRMUL	String multiplication failure
+E_STRNEG	String reversal failure
+E_STRSUB	String subtraction failure
+E_BIT1		Bad argument type for bit
+E_BIT2		Index too large for bit
+E_SETBIT1	Non-integer second argument for setbit
+E_SETBIT2	Out-of-range index for setbit
+E_SETBIT3	Non-string first argument for setbit
+E_OR		Bad argument for or
+E_AND		Bad argument for and
+E_STROR		Allocation failure for string or
+E_STRAND	Allocation failure for string and
+E_XOR		Bad argument for xorvalue
+E_COMP		Bad argument for comp
+E_STRDIFF	Allocation failure for string diff
+E_STRCOMP	Allocation failure for string comp
+E_SEG1		Bad first argument for segment
+E_SEG2		Bad second argument for segment
+E_SEG3		Bad third argument for segment
+E_STRSEG	Failure for string segment
+E_HIGHBIT1	Bad argument type for highbit
+E_HIGHBIT2	Non-integer argument for highbit
+E_LOWBIT1	Bad argument type for lowbit
+E_LOWBIT2	Non-integer argument for lowbit
+E_CONTENT	Bad argument type for unary hash op
+E_HASHOP	Bad argument type for binary hash op
+E_HEAD1		Bad first argument for head
+E_HEAD2		Bad second argument for head
+E_STRHEAD	Failure for strhead
+E_TAIL1		Bad first argument for tail
+E_TAIL2		Bad second argument for tail
+E_STRTAIL	Failure for strtail
+E_STRSHIFT	Failure for strshift
+E_STRCMP	Non-string argument for strcmp
+E_STRNCMP	Bad argument type for strncmp
+E_XOR1		Varying types of argument for xor
+E_XOR2		Bad argument type for xor
+E_STRCPY	Bad argument type for strcpy
+E_STRNCPY	Bad argument type for strncpy
+E_BACKSLASH	Bad argument type for unary backslash
+E_SETMINUS	Bad argument type for setminus
+E_INDICES1	Bad first argument type for indices
+E_INDICES2	Bad second argument for indices
+E_EXP3		Too-large re(argument) for exp
+E_SINH3		Too-large re(argument) for sinh
+E_COSH3		Too-large re(argument) for cosh
+E_SIN3		Too-large im(argument) for sin
+E_COS3		Too-large im(argument) for cos
+E_GD3		Infinite or too-large result for gd
+E_AGD3		Infinite or too-large result for agd
+E_POWER4	Too-large value for power
+E_ROOT4		Too-large value for root
+E_DGT1		Non-real first arg for digit
+E_DGT2		Non-integral second arg for digit
+E_DGT3		Bad third arg for digit
+E_PLCS1		Bad first argument for places
+E_PLCS2		Bad second argument for places
+E_DGTS1		Bad first argument for digits
+E_DGTS2		Bad second argument for digits
+E_ILOG		Bad first argument for ilog
+E_ILOGB		Bad second argument for ilog
+E_ILOG10	Bad argument for ilog10
+E_ILOG2		Bad argument for ilog2
+E_COMB1		Non-integer second arg for comb
+E_COMB2		Too-large second arg for comb
+E_CTLN		Bad argument for catalan
+E_BERN		Bad argument for bern
+E_EULER		Bad argument for euler
+E_SLEEP		Bad argument for sleep
+E_TTY		calc_tty failure
+E_ASSIGN1	No-copy-to destination for octet assign
+E_ASSIGN2	No-copy-from source for octet assign
+E_ASSIGN3	No-change destination for octet assign
+E_ASSIGN4	Non-variable destination for assign
+E_ASSIGN5	No-assign-to destination for assign
+E_ASSIGN6	No-assign-from source for assign
+E_ASSIGN7	No-change destination for assign
+E_ASSIGN8	No-type-change destination for assign
+E_ASSIGN9	No-error-value destination for assign
+E_SWAP1		No-copy argument for octet swap
+E_SWAP2		No-assign-to-or-from argument for swap
+E_SWAP3		Non-lvalue argument for swap
+E_QUOMOD1	Non-lvalue argument 3 or 4 for quomod
+E_QUOMOD2	Non-real-number arg 1 or 2 or bad arg 5 for quomod
+E_QUOMOD3	No-assign-to argument 3 or 4 for quomod
+E_PREINC1	No-copy-to or no-change argument for octet preinc
+E_PREINC2	Non-variable argument for preinc
+E_PREINC3	No-assign-to or no-change argument for preinc
+E_PREDEC1	No-copy-to or no-change argument for octet predec
+E_PREDEC2	Non-variable argument for predec
+E_PREDEC3	No-assign-to or no-change argument for predec
+E_POSTINC1	No-copy-to or no-change argument for octet postinc
+E_POSTINC2	Non-variable argument for postinc
+E_POSTINC3	No-assign-to or no-change argument for postinc
+E_POSTDEC1	No-copy-to or no-change argument for octet postdec
+E_POSTDEC2	Non-variable argument for postdec
+E_POSTDEC3	No-assign-to or no-change argument for postdec
+E_INIT1		Error-type structure for initialization
+E_INIT2		No-copy-to structure for initialization
+E_INIT3		Too many initializer values
+E_INIT4		Attempt to initialize freed named block
+E_INIT5		Bad structure type for initialization
+E_INIT6		No-assign-to element for initialization
+E_INIT7		No-change element for initialization
+E_INIT8		No-type-change element for initialization
+E_INIT9		No-error-value element for initialization
+E_INIT10	No-assign-or-copy-from source for initialization
+E_LIST1		No-relocate for list insert
+E_LIST2		No-relocate for list delete
+E_LIST3		No-relocate for list push
+E_LIST4		No-relocate for list append
+E_LIST5		No-relocate for list pop
+E_LIST6		No-relocate for list remove
+E_MODIFY1	Non-variable first argument for modify
+E_MODIFY2	Non-string second argument for modify
+E_MODIFY3	No-change first argument for modify
+E_MODIFY4	Undefined function for modify
+E_MODIFY5	Unacceptable type first argument for modify
+E_FPATHOPEN1	Non-string arguments for fpathopen
+E_FPATHOPEN2	Unrecognized mode for fpathopen
+E_LOG1		Bad epsilon argument for log
+E_LOG2		Non-numeric first argument for log
+E_FGETFILE1	Non-file argument for fgetfile
+E_FGETFILE2	File argument for fgetfile not open for reading
+E_FGETFILE3	Unable to set file position in fgetfile
+E_ESTR		Non-representable type for estr

calcerr_c.awk

@@ -1,3 +1,33 @@
+#!/usr/bin/sed
+#
+# calcerr_c - help produce calcerr.c from calcerr.tbl
+#
+# Copyright (C) 1999  Landon Curt Noll
+#
+# Calc is open software; you can redistribute it and/or modify it under
+# the terms of the version 2.1 of the GNU Lesser General Public License
+# as published by the Free Software Foundation.
+#
+# Calc 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 Lesser General
+# Public License for more details.
+#
+# A copy of version 2.1 of the GNU Lesser General Public License is
+# distributed with calc under the filename COPYING-LGPL.  You should have
+# received a copy with calc; if not, write to Free Software Foundation, Inc.
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+# @(#) $Revision: 30.1 $
+# @(#) $Id: calcerr_c.awk,v 30.1 2007/03/16 11:09:46 chongo Exp $
+# @(#) $Source: /usr/local/src/cmd/calc/RCS/calcerr_c.awk,v $
+#
+# Under source code control:	1996/05/24 03:15:35
+# File existed as early as:	1996
+#
+# chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+# Share and enjoy!  :-) http://www.isthe.com/chongo/tech/comp/calc/
+#
 BEGIN {
     printf("#include <stdio.h>\n");
     printf("#include \"calcerr.h\"\n\n");
@@ -6,12 +36,12 @@ BEGIN {
     printf(" * names of calc error values\n");
     printf(" */\n");
     printf("CONST char *error_table[E__COUNT+2] = {\n");
-    printf("    \"No error\",\n");
+    printf("	\"No error\",\n");
 }
 {
     print $0;
 }
 END {
-    printf("    NULL\n");
+    printf("	NULL\n");
     printf("};\n");
 }

calcerr_c.sed

@@ -1,3 +1,33 @@
+#!/usr/bin/sed
+#
+# calcerr_c - help produce calcerr.c from calcerr.tbl
+#
+# Copyright (C) 1999  Landon Curt Noll
+#
+# Calc is open software; you can redistribute it and/or modify it under
+# the terms of the version 2.1 of the GNU Lesser General Public License
+# as published by the Free Software Foundation.
+#
+# Calc 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 Lesser General
+# Public License for more details.
+#
+# A copy of version 2.1 of the GNU Lesser General Public License is
+# distributed with calc under the filename COPYING-LGPL.  You should have
+# received a copy with calc; if not, write to Free Software Foundation, Inc.
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+# @(#) $Revision: 30.1 $
+# @(#) $Id: calcerr_c.sed,v 30.1 2007/03/16 11:09:46 chongo Exp $
+# @(#) $Source: /usr/local/src/cmd/calc/RCS/calcerr_c.sed,v $
+#
+# Under source code control:	1996/05/24 03:15:35
+# File existed as early as:	1996
+#
+# chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+# Share and enjoy!  :-)		http://www.isthe.com/chongo/tech/comp/calc/
+#
 s/#.*//
 s/[	 ][	 ]*$//
 /^$/d

calcerr_h.awk

@@ -1,3 +1,33 @@
+#!/usr/bin/awk
+#
+# calcerr_h - help produce calcerr.h from calcerr.tbl
+#
+# Copyright (C) 1999  Landon Curt Noll
+#
+# Calc is open software; you can redistribute it and/or modify it under
+# the terms of the version 2.1 of the GNU Lesser General Public License
+# as published by the Free Software Foundation.
+#
+# Calc 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 Lesser General
+# Public License for more details.
+#
+# A copy of version 2.1 of the GNU Lesser General Public License is
+# distributed with calc under the filename COPYING-LGPL.  You should have
+# received a copy with calc; if not, write to Free Software Foundation, Inc.
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+# @(#) $Revision: 30.1 $
+# @(#) $Id: calcerr_h.awk,v 30.1 2007/03/16 11:09:46 chongo Exp $
+# @(#) $Source: /usr/local/src/cmd/calc/RCS/calcerr_h.awk,v $
+#
+# Under source code control:	1996/05/23 17:38:44
+# File existed as early as:	1996
+#
+# chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+# Share and enjoy!  :-) http://www.isthe.com/chongo/tech/comp/calc/
+#
 BEGIN {
     ebase = 10000;
     printf("#define E__BASE %d\t/* calc errors start above here */\n\n", ebase);

calcerr_h.sed

@@ -1,3 +1,33 @@
+#!/usr/bin/sed
+#
+# calcerr_h - help produce calcerr.h from calcerr.tbl
+#
+# Copyright (C) 1999  Landon Curt Noll
+#
+# Calc is open software; you can redistribute it and/or modify it under
+# the terms of the version 2.1 of the GNU Lesser General Public License
+# as published by the Free Software Foundation.
+#
+# Calc 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 Lesser General
+# Public License for more details.
+#
+# A copy of version 2.1 of the GNU Lesser General Public License is
+# distributed with calc under the filename COPYING-LGPL.  You should have
+# received a copy with calc; if not, write to Free Software Foundation, Inc.
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+# @(#) $Revision: 30.1 $
+# @(#) $Id: calcerr_h.sed,v 30.1 2007/03/16 11:09:46 chongo Exp $
+# @(#) $Source: /usr/local/src/cmd/calc/RCS/calcerr_h.sed,v $
+#
+# Under source code control:	1996/05/23 17:38:44
+# File existed as early as:	1996
+#
+# chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+# Share and enjoy!  :-)		http://www.isthe.com/chongo/tech/comp/calc/
+#
 s/#.*//
 s/[	 ][	 ]*$//
 /^$/d

check.awk

@@ -1,74 +1,114 @@
+#!/usr/bin/awk
+#
+# check - check the regression output for problems
+#
+# Copyright (C) 1999-2006  Landon Curt Noll
+#
+# Calc is open software; you can redistribute it and/or modify it under
+# the terms of the version 2.1 of the GNU Lesser General Public License
+# as published by the Free Software Foundation.
+#
+# Calc 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 Lesser General
+# Public License for more details.
+#
+# A copy of version 2.1 of the GNU Lesser General Public License is
+# distributed with calc under the filename COPYING-LGPL.  You should have
+# received a copy with calc; if not, write to Free Software Foundation, Inc.
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+# @(#) $Revision: 30.1 $
+# @(#) $Id: check.awk,v 30.1 2007/03/16 11:09:46 chongo Exp $
+# @(#) $Source: /usr/local/src/cmd/calc/RCS/check.awk,v $
+#
+# Under source code control:	1996/05/25 22:07:58
+# File existed as early as:	1996
+#
+# chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+# Share and enjoy!  :-)		http://www.isthe.com/chongo/tech/comp/calc/
+#
 # This awk script will print 3 lines before and after any non-blank line that
-# does not begin with a number.  This allows the 'make debug' rule to remove
+# does not begin with a number.	 This allows the 'make debug' rule to remove
 # all non-interest lines the the 'make check' regression output while providing
 # 3 lines of context around unexpected output.
 #
 BEGIN {
-    havebuf0=0;
+	havebuf0=0;
-    buf0=0;
+	buf0=0;
-    havebuf1=0;
+	havebuf1=0;
-    buf1=0;
+	buf1=0;
-    havebuf2=0;
+	havebuf2=0;
-    buf2=0;
+	buf2=0;
-    error = 0;
+	error = 0;
+	end_seen = 0;
 }
 
 NF == 0 {
-    if (error > 0) {
+	if (error > 0) {
-	if (havebuf2) {
+		if (havebuf2) {
-	    print buf2;
+			print buf2;
+		}
+		--error;
 	}
-	--error;
+	buf2 = buf1;
-    }
+	havebuf2 = havebuf1;
-    buf2 = buf1;
+	buf1 = buf0;
-    havebuf2 = havebuf1;
+	havebuf1 = havebuf0;
-    buf1 = buf0;
+	buf0 = $0;
-    havebuf1 = havebuf0;
+	havebuf0 = 1;
-    buf0 = $0;
+	next;
-    havebuf0 = 1;
-    next;
 }
 
-$1 ~ /^[0-9]/ {
+/: Ending regression tests$/ {
-    if (error > 0) {
+	end_seen = 1;
-	if (havebuf2) {
+}
-	    print buf2;
+
+$1 ~ /^[0-9]+:/ || $1 ~ /^[0-9]+-[0-9]*:/ || $1 ~ /^"\)\)$/ {
+	if (error > 0) {
+		if (havebuf2) {
+			print buf2;
+		}
+		--error;
 	}
-	--error;
+	buf2 = buf1;
-    }
+	havebuf2 = havebuf1;
-    buf2 = buf1;
+	buf1 = buf0;
-    havebuf2 = havebuf1;
+	havebuf1 = havebuf0;
-    buf1 = buf0;
+	buf0 = $0;
-    havebuf1 = havebuf0;
+	havebuf0 = 1;
-    buf0 = $0;
+	next;
-    havebuf0 = 1;
-    next;
 }
 
 {
-    error = 6;
+	error = 6;
-    if (havebuf2) {
+	if (havebuf2) {
-	print buf2;
+		print buf2;
-    }
+	}
-    buf2 = buf1;
+	buf2 = buf1;
-    havebuf2 = havebuf1;
+	havebuf2 = havebuf1;
-    buf1 = buf0;
+	buf1 = buf0;
-    havebuf1 = havebuf0;
+	havebuf1 = havebuf0;
-    buf0 = $0;
+	buf0 = $0;
-    havebuf0 = 1;
+	havebuf0 = 1;
-    next;
+	next;
 }
 
 END {
-    if (error > 0 && havebuf2) {
+	if (error > 0 && havebuf2) {
-	print buf2;
+		print buf2;
-	--error;
+		--error;
-    }
+	}
-    if (error > 0 && havebuf1) {
+	if (error > 0 && havebuf1) {
-	print buf1;
+		print buf1;
-	--error;
+		--error;
-    }
+	}
-    if (error > 0 && havebuf0) {
+	if (error > 0 && havebuf0) {
-	print buf0;
+		print buf0;
-    }
+	}
+	if (error > 0 || !end_seen) {
+		exit(1);
+	} else {
+		exit(0);
+	}
 }

cmath.h

@@ -1,15 +1,42 @@
 /*
- * Copyright (c) 1993 David I. Bell
+ * cmath - data structures for extended precision complex arithmetic
- * Permission is granted to use, distribute, or modify this source,
- * provided that this copyright notice remains intact.
  *
- * Data structure declarations for extended precision complex arithmetic.
+ * Copyright (C) 1999-2007  David I. Bell
+ *
+ * Calc is open software; you can redistribute it and/or modify it under
+ * the terms of the version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * Calc 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 Lesser General
+ * Public License for more details.
+ *
+ * A copy of version 2.1 of the GNU Lesser General Public License is
+ * distributed with calc under the filename COPYING-LGPL.  You should have
+ * received a copy with calc; if not, write to Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @(#) $Revision: 30.1 $
+ * @(#) $Id: cmath.h,v 30.1 2007/03/16 11:09:46 chongo Exp $
+ * @(#) $Source: /usr/local/src/cmd/calc/RCS/cmath.h,v $
+ *
+ * Under source code control:	1993/07/30 19:42:45
+ * File existed as early as:	1993
+ *
+ * Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/
  */
 
-#ifndef	CMATH_H
-#define	CMATH_H
 
-#include "qmath.h"
+#if !defined(__CMATH_H__)
+#define __CMATH_H__
+
+
+#if defined(CALC_SRC)	/* if we are building from the calc source tree */
+# include "qmath.h"
+#else
+# include <calc/qmath.h>
+#endif
 
 
 /*
@@ -25,64 +52,84 @@ typedef struct {
 /*
  * Input, output, and conversion routines.
  */
-extern COMPLEX *comalloc(void);
+E_FUNC COMPLEX *comalloc(void);
-extern COMPLEX *qqtoc(NUMBER *q1, NUMBER *q2);
+E_FUNC COMPLEX *qqtoc(NUMBER *q1, NUMBER *q2);
-extern void comfree(COMPLEX *c);
+E_FUNC void comfree(COMPLEX *c);
-extern void comprint(COMPLEX *c);
+E_FUNC void comprint(COMPLEX *c);
-extern void cprintfr(COMPLEX *c);
+E_FUNC void cprintfr(COMPLEX *c);
 
 
 /*
  * Basic numeric routines.
  */
-extern COMPLEX *cadd(COMPLEX *c1, COMPLEX *c2);
+
-extern COMPLEX *csub(COMPLEX *c1, COMPLEX *c2);
+E_FUNC COMPLEX *c_add(COMPLEX *c1, COMPLEX *c2);
-extern COMPLEX *cmul(COMPLEX *c1, COMPLEX *c2);
+E_FUNC COMPLEX *c_sub(COMPLEX *c1, COMPLEX *c2);
-extern COMPLEX *cdiv(COMPLEX *c1, COMPLEX *c2);
+E_FUNC COMPLEX *c_mul(COMPLEX *c1, COMPLEX *c2);
-extern COMPLEX *caddq(COMPLEX *c, NUMBER *q);
+E_FUNC COMPLEX *c_div(COMPLEX *c1, COMPLEX *c2);
-extern COMPLEX *csubq(COMPLEX *c, NUMBER *q);
+E_FUNC COMPLEX *c_addq(COMPLEX *c, NUMBER *q);
-extern COMPLEX *cmulq(COMPLEX *c, NUMBER *q);
+E_FUNC COMPLEX *c_subq(COMPLEX *c, NUMBER *q);
-extern COMPLEX *cdivq(COMPLEX *c, NUMBER *q);
+E_FUNC COMPLEX *c_mulq(COMPLEX *c, NUMBER *q);
-extern COMPLEX *cscale(COMPLEX *c, long i);
+E_FUNC COMPLEX *c_divq(COMPLEX *c, NUMBER *q);
-extern COMPLEX *cshift(COMPLEX *c, long i);
+E_FUNC COMPLEX *c_scale(COMPLEX *c, long i);
-extern COMPLEX *csquare(COMPLEX *c);
+E_FUNC COMPLEX *c_shift(COMPLEX *c, long i);
-extern COMPLEX *cconj(COMPLEX *c);
+E_FUNC COMPLEX *c_square(COMPLEX *c);
-extern COMPLEX *creal(COMPLEX *c);
+E_FUNC COMPLEX *c_conj(COMPLEX *c);
-extern COMPLEX *cimag(COMPLEX *c);
+E_FUNC COMPLEX *c_real(COMPLEX *c);
-extern COMPLEX *cneg(COMPLEX *c);
+E_FUNC COMPLEX *c_imag(COMPLEX *c);
-extern COMPLEX *cinv(COMPLEX *c);
+E_FUNC COMPLEX *c_neg(COMPLEX *c);
-extern COMPLEX *cint(COMPLEX *c);
+E_FUNC COMPLEX *c_inv(COMPLEX *c);
-extern COMPLEX *cfrac(COMPLEX *c);
+E_FUNC COMPLEX *c_int(COMPLEX *c);
-extern BOOL ccmp(COMPLEX *c1, COMPLEX *c2);
+E_FUNC COMPLEX *c_frac(COMPLEX *c);
+E_FUNC BOOL c_cmp(COMPLEX *c1, COMPLEX *c2);
 
 
 /*
  * More complicated functions.
  */
-extern COMPLEX *cpowi(COMPLEX *c, NUMBER *q);
+E_FUNC COMPLEX *c_powi(COMPLEX *c, NUMBER *q);
+E_FUNC NUMBER *c_ilog(COMPLEX *c, ZVALUE base);
 
 
 /*
  * Transcendental routines.  These all take an epsilon argument to
  * specify how accurately these are to be calculated.
  */
-extern COMPLEX *cpower(COMPLEX *c1, COMPLEX *c2, NUMBER *epsilon);
+E_FUNC COMPLEX *c_power(COMPLEX *c1, COMPLEX *c2, NUMBER *epsilon);
-extern COMPLEX *csqrt(COMPLEX *c, NUMBER *epsilon, long R);
+E_FUNC COMPLEX *c_sqrt(COMPLEX *c, NUMBER *epsilon, long R);
-extern COMPLEX *croot(COMPLEX *c, NUMBER *q, NUMBER *epsilon);
+E_FUNC COMPLEX *c_root(COMPLEX *c, NUMBER *q, NUMBER *epsilon);
-extern COMPLEX *cexp(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_exp(COMPLEX *c, NUMBER *epsilon);
-extern COMPLEX *cln(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_ln(COMPLEX *c, NUMBER *epsilon);
-extern COMPLEX *ccos(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_log(COMPLEX *c, NUMBER *epsilon);
-extern COMPLEX *csin(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_cos(COMPLEX *c, NUMBER *epsilon);
-extern COMPLEX *cpolar(NUMBER *q1, NUMBER *q2, NUMBER *epsilon);
+E_FUNC COMPLEX *c_sin(COMPLEX *c, NUMBER *epsilon);
-extern COMPLEX *crel(COMPLEX *c1, COMPLEX *c2);
+E_FUNC COMPLEX *c_cosh(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_sinh(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_polar(NUMBER *q1, NUMBER *q2, NUMBER *epsilon);
+E_FUNC COMPLEX *c_rel(COMPLEX *c1, COMPLEX *c2);
+E_FUNC COMPLEX *c_asin(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_acos(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_atan(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_acot(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_asec(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_acsc(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_asinh(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_acosh(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_atanh(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_acoth(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_asech(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_acsch(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_gd(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_agd(COMPLEX *c, NUMBER *epsilon);
+
 
 
 /*
  * external functions
  */
-extern COMPLEX *swap_b8_in_COMPLEX(COMPLEX *dest, COMPLEX *src, BOOL all);
+E_FUNC COMPLEX *swap_b8_in_COMPLEX(COMPLEX *dest, COMPLEX *src, BOOL all);
-extern COMPLEX *swap_b16_in_COMPLEX(COMPLEX *dest, COMPLEX *src, BOOL all);
+E_FUNC COMPLEX *swap_b16_in_COMPLEX(COMPLEX *dest, COMPLEX *src, BOOL all);
-extern COMPLEX *swap_HALF_in_COMPLEX(COMPLEX *dest, COMPLEX *src, BOOL all);
+E_FUNC COMPLEX *swap_HALF_in_COMPLEX(COMPLEX *dest, COMPLEX *src, BOOL all);
 
 
 /*
@@ -95,7 +142,7 @@ extern COMPLEX *swap_HALF_in_COMPLEX(COMPLEX *dest, COMPLEX *src, BOOL all);
 #define cisnegone(c)	(cisreal(c) && qisnegone((c)->real))
 #define cisrunit(c)	(cisreal(c) && qisunit((c)->real))
 #define cisiunit(c)	(qiszero((c)->real) && qisunit((c)->imag))
-#define	cisunit(c)	(cisrunit(c) || cisiunit(c))
+#define cisunit(c)	(cisrunit(c) || cisiunit(c))
 #define cistwo(c)	(cisreal(c) && qistwo((c)->real))
 #define cisint(c)	(qisint((c)->real) && qisint((c)->imag))
 #define ciseven(c)	(qiseven((c)->real) && qiseven((c)->imag))
@@ -106,8 +153,7 @@ extern COMPLEX *swap_HALF_in_COMPLEX(COMPLEX *dest, COMPLEX *src, BOOL all);
 /*
  * Pre-defined values.
  */
-extern COMPLEX _czero_, _cone_, _conei_;
+EXTERN COMPLEX _czero_, _cone_, _conei_;
 
-#endif
 
-/* END CODE */
+#endif /* !__CMATH_H__ */