update GitHub workflows to use actions/checkout@v5

In preparation to fix issue #47, we:

Fix a minor typo in `Makefile.config`.

Move `stringindex(char *format, char *test)` from `str.c` into `codegen.c`
as static function.

Expand `STR_TABLECHUNK` from `1<<10` to `1<<16`.

Identify with an XXX comment, a problematic `realloc()` call in the
`addstr(STRINGHEAD *hp, char *str)` function of `str.c`.

Move the `charstr(int ch)` in `str.c` above the only function that uses
it, `addliteral(char *str)`, and make it a static function.

Improved comments about return values for `str.c` functions that
work on STRINGHEAD pointers.

.github/ISSUE_TEMPLATE/calc-bug-report.md

@@ -0,0 +1,70 @@
+---
+name: Calc bug report
+about: Create a report to help us improve
+title: 'Bug: XXX-change-this-part-XXX'
+labels: bug
+assignees: ''
+
+---
+
+Calc bug report template version: 1.3 2022-11-27
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+
+0. How you started calc
+    I.e., provide the command line you used to launch calc
+
+1. Calc commands and their output
+    Please provide any calc commands you entered on the terminal.
+    Please provide the calc command line output inline as well.
+    If the above is long, please attach a file.
+
+    Or if you cannot compile calc: The make command you used try and compile calc
+    and all error and warning messages produced during that action.  If long, consider
+    attaching a file.
+
+2. Indicate where the problem is
+    Referring to the information for step 1 above,  indicate where the problem is to be found
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Attach debug.out**
+IMPORTANT: Please run `make debug` and then attach the `debug.out` file.
+
+**Screen shots**
+If applicable, attach screen shots to help explain your problem.
+
+**Execution environment (please complete the following information):**
+ - OS:
+        E.g., macOS, FreeBSD, Linux, Windows 11, etc.
+
+ - OS version:
+        E.g., Preferred: give the output of `uname -a`
+                 or if no uname command, a description of the OS version/release you are using
+
+ - OS distribution:
+        E.g., macOS 13.0.1, contents of /etc/redhat-release, or /etc/os-release, etc.
+
+ - Calc Version
+        E.g., output of calc -v
+                 or if you cannot compile calc, the version you downloaded and from where it came from
+
+ - Shell and shell version
+        E.g., bash, zsh, power shell, etc.
+                 and the version of the shell you are using, if known
+
+**Calc mods**
+If you have modified the calc source for some reason, please description what you modified.
+Please consider attaching a patch (diff -u) between an official calc release and the source
+you are using.
+
+**Patch**
+If you have a recommended code patch to address the problem, please attach your file
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/dependabot.yml

@@ -0,0 +1,12 @@
+# Set update schedule for GitHub Actions
+#
+# See https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot
+
+version: 2
+updates:
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      # Check for updates to GitHub Actions every week
+      interval: "weekly"

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,80 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "master" ]
+  schedule:
+    - cron: '41 1 * * 6'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'cpp' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Use only 'java' to analyze code written in Java, Kotlin or both
+        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v5
+    - name: Setup node
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20'
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v3
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines.
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #   echo "Run, Build Application using script"
+    #   ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
+      with:
+        category: "/language:${{matrix.language}}"

.github/workflows/dependency-review.yml

@@ -0,0 +1,14 @@
+name: 'Dependency Review'
+on: [pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  dependency-review:
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Checkout Repository'
+        uses: actions/checkout@v5
+      - name: 'Dependency Review'
+        uses: actions/dependency-review-action@v4

.gitignore

@@ -0,0 +1,184 @@
+# generic excluded patterns
+#
+# We sort the list below via: sort -d -u
+#
+*~
+*.BAK
+core*
+.DS_Store
+*.dSYM/
+*.exe
+*.[oa]
+*.o.tmp
+.*.swp
+*,v
+
+# files and directories created during the building of calc and other Makefile actions
+#
+# NOTE: While many of these might be part of a released calc tarball, they are
+#       not consider development source.  Some other file(s) and/or programs
+#       generate these files.
+#
+# We sort the list below via: sort -d -u
+#
+align32
+align32.h
+align32_tmp
+arc4random_tmp
+args.h
+cal/.all
+calc
+calc.1
+calc.cat1
+calc.spec
+calc-static
+calc.usage
+cal/test082.cal
+charbit.h
+chatbit
+chk_c
+conf.h
+const_tmp
+cscript/4dsphere
+cscript/.all
+cscript/fproduct
+cscript/mersenne
+cscript/piforever
+cscript/plus
+cscript/powerterm
+cscript/README
+cscript/simple
+cscript/square
+custom/.all
+custom/libcustcalc*
+debug.out
+.dynamic
+endian
+endian_calc.h
+environ_tmp
+errcode
+errsym.h
+fpos_tmp
+fposval
+fposval.h
+fposval_tmp
+func.show
+func.sort
+getpgid_tmp
+getprid_tmp
+getsid_tmp
+gettime_tmp
+have_arc4random
+have_arc4random.h
+have_ban_pragma
+have_ban_pragma.h
+have_const
+have_const.h
+have_environ
+have_environ.h
+have_fgetsetpos.h
+have_fpos
+have_fpos_pos
+have_fpos_pos.h
+have_getpgid
+have_getpgid.h
+have_getprid
+have_getprid.h
+have_getsid
+have_getsid.h
+have_gettime
+have_gettime.h
+have_inttypes.h
+have_limits.h
+have_newstr
+have_newstr.h
+have_offscl
+have_offscl.h
+have_posscl
+have_posscl.h
+have_rusage
+have_rusage.h
+have_statfs
+have_statfs.h
+have_stdbool.h
+have_stdint.h
+have_stdlib.h
+have_stdvs
+have_strdup
+have_strdup.h
+have_string.h
+have_strlcat
+have_strlcat.h
+have_strlcpy
+have_strlcpy.h
+have_sys_mount.h
+have_sys_param.h
+have_sys_vfs.h
+have_times.h
+have_uid_t
+have_uid_t.h
+have_unistd.h
+have_unused
+have_unused.h
+have_urandom.h
+have_ustat
+have_ustat.h
+have_varvs
+help/.all
+help/binding
+help/bindings
+help/bug
+help/bugs
+help/builtin
+help/change
+help/changes
+help/contrib
+help/copy
+help/COPYING
+help/COPYING-LGPL
+help/cscript
+help/custom_cal
+help/errorcode
+help/errorcodes
+help/full
+help/funclist
+help/funclist.c
+help/ilogn
+help/libcalc
+help/man
+help/new_custom
+help/question
+help/questions
+help/releases
+help/resource
+help/type
+help/usage
+.hsrc
+libcalc.*
+libcustcalc.*
+ll_tmp
+longbits
+longbits.h
+Makefile.our
+newstr_tmp
+NOTES
+offscl_tmp
+outfile
+posscl_tmp
+rusage_tmp
+sample_many
+sample_many-static
+sample_rand
+sample_rand-static
+statfs_tmp
+.static
+status.chk_c.h
+strdup_tmp
+tags
+terminal.h
+uid_tmp
+unused_tmp
+ustat_tmp
+ver_calc
+vs_tmp
+win32/

.lldbinit

@@ -0,0 +1,23 @@
+#
+# lldb calc
+#
+# IMPORTANT: Under macOS, use this local ./lldbinit file, your home directory file:
+#
+#	~/.lldbinit
+#
+# must contain this line (w/o the leading # and whitespace):
+#
+#	settings set target.load-cwd-lldbinit true
+#
+# Optimizing calc may make it harder to trace what calc is doing,
+# To turn off optimization while debugging, try:
+#
+#	make clobber all DEBUG="-g3"
+#
+# To debug calc with lldb from this directory, just run:
+#
+#	lldb
+#
+target create "./calc"
+process launch -tty --environment CALCPATH=./cal --environment LD_LIBRARY_PATH=. --environment DYLD_LIBRARY_PATH=. --environment CALCHELP=./help --environment CALCCUSTOMHELP=./custom -- -q -d
+b main

BUGS

@@ -1,12 +1,12 @@
 If you notice something wrong, strange or broken, try rereading:
 
-   README.FIRST
-   HOWTO.INSTALL
-   BUGS (this file)
+    README.FIRST
+    HOWTO.INSTALL
+    BUGS (this file)
 
 If that does not help, cd to the calc source directory and try:
 
-   make check
+    make check
 
 Look at the end of the output, it should say something like:
 
@@ -15,153 +15,161 @@ Look at the end of the output, it should say something like:
 
 If it does not, then something is really broken!
 
+To be sure that your version of calc is up to date.
+Look for the latest release on GitHub:
+
+    https://github.com/lcn2/calc/releases
+
+Just below latest GitHub release sectiop is something called:
+
+    > Assets
+
+Click in the triangle to open up the Assets then click on
+the approptiate package to download.
+
 If you made and modifications to calc beyond the simple Makefile
-configuration, try backing them out and see if things get better.
-
-To be sure that your version of calc is up to date, check out:
-
-	http://reality.sgi.com/chongo/tech/comp/calc/calc-download.html
-
-The calc web site is located at:
-
-	http://reality.sgi.com/chongo/tech/comp/calc/index.html
-
-=-=
+configuration, try backing those changes out and see if things get
+better.
 
 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:
-
-    calc-bugs at postofc dot corp dot sgi dot com
-
-    [[ Replace 'at' with @, 'dot' is with . and remove the spaces ]]
-
-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)
-    * 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)
-	make debug >& debug.out			(csh, tcsh users)
-
-      and send the contents of the 'debug.out' file.
-
-Stack traces from core dumps are useful to send as well.
+then it may be time to send in a bug report.
 
 =-=
 
-Send any comments, compiler warning messages, suggestions and most
-importantly, fixes (in the form of a context diff patch) to:
+If you encounter a warning or error in compiling, or if you
+find a calc bug and you wish to send is a fix, we recommend
+that you submit your change using the GitHub pull request:
 
-    calc-tester at postofc dot corp dot sgi dot com
-
-    [[ Replace 'at' with @, 'dot' is with . and remove the spaces ]]
-
-You should use the above calc-bugs address for bug reports, if you are
-not currently a member of the calc-tester mailing list.
+    https://github.com/lcn2/calc/pulls
 
 =-=
 
-Known bugs:
+If you just want to send us a bug report, we recommend
+doing so via the GitHub issue process:
+
+    https://github.com/lcn2/calc/issues
+
+If you see an existing issue that matches your problem, look
+over the notes and if needed, add your own observation,
+even if you just add to an existing issue:
+
+    I have this issue too
+
+If you don't see your issue addressed, then on the above
+GitHub web page, click on this button:
+
+    ((New Issue))
+
+Please include the following information in the new issue:
+
+    * A description of the problem
+
+    * Version of calc you are using
+
+        If you cannot compile calc, then look at version.c
+        and report the #define that start with:
+
+            #define MAJOR_VER
+            #define MINOR_VER
+            #define MAJOR_PATCH
+            #define MINOR_PATCH
+
+    * If you modified calc from an official patch,
+      send us the mods you made
+
+    * Type and version of the operating system
+
+    * Type and version of compiler
+
+    * Send us all compiler warnings or errors you find
+
+    * If calc dumped core, try to send us a core dump stack trace
+
+    * cd to the calc source directory, and send the contents
+      of debug.out.txt produced by this command:
+
+        make debug
+
+PLEASE attach the debug.out.txt file to your GitHub issue (bug report)!!
+
+Please be patient as we cannot always respond to pull requests quickly.
+
+=-=
+
+Known bugs in calc:
+
+    The output of the alg_config.cal resource file is bogus.
+    We would welcome a replacement for this code.
+
+    Calc may not compile natively under Windows 11, however with
+    MSYS2 Software Distribution (a fork of Cygwin) people compile
+    calc under Windiws just fine.  See README.WINDOWS.
 
     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.
+    Email your bug reports and hopefully patches to fix them.
 
 =-=
 
-Problems with known work-a-rounds:
+mis-features in calc:
 
-    * There is a bug in gcc-2.95 that causes calc, when compiled with -O2,
-      to fail the regression test.  The work-a-round is to compile with -O
-      or to use gcc-2.96 or later.
+    Some problems are not bugs but rather mis-features / things that could
+    work better.  The following is a list of mis-features that should be
+    addressed and improved someday.
 
-    * Solaris cc somtimes barfs while compiling zrand.c.  In particular, calc
-      barfs on on the SVAL macro.  The work-a-round is to use the Solaric cc
-      Makefile set sets -DFORCE_STDC.  I.e,:
+    * When statement is of the form { ... }, the leading { MUST BE ON
+      THE SAME LINE as the if, for, while or do keyword.
 
-	    CCWARN=
-	    CCOPT= ${DEBUG} ${NO_SHARED}
-	    CCMISC= -DFORCE_STDC
-	    #
-	    CFLAGS= ${CCWARN} ${CCOPT} ${CCMISC}
-	    ICFLAGS= ${CCWARN} ${CCMISC}
-	    #
-	    LCFLAGS=
-	    LDFLAGS= ${NO_SHARED} ${LD_NO_SHARED}
-	    ILDFLAGS=
-	    #
-	    LCC= cc
-	    CC= ${PURIFY} ${LCC}
+      This works as expected:
 
-    * There is a bug in some versions of the Dec/Compaq cc for the Alpha
-      where the following:
+        if (expr) {
+            ...
+        }
 
-	    #include <stdio.h>
-	    #define SVAL(a,b) (unsigned long)(0x ## a ## b ## ULL)
-	    main(){SVAL(b8a8aeb0,8168eadc);}
+      However this WILL NOT WORK AS EXPECTED:
 
-      fails because it puts a space inside the concatenated hex.  Calc
-      has code that is affected by this bug.  This bug has been reported
-      to Compaq and may be fixed in the future.	 A work-a-round is to
-      compile with cc -std0 or to use a later version of their compiler.
+        if (expr)
+        {
+            ...
+        }
 
-    * On a Digital UNIX V4.0F (Rev. 1229) on a 500 Mhz 21264, make check
-      dies a horrible death starting in test 600 and 622 gives 100s of
-      messages for calc version 2.11.0t9.4 using the Dec's cc with -O2:
+      This needs to be changed.  See also "help statement", "help unexpected",
+      and "help todo".
 
-	600: Beginning test_bignums
-	601: muldivcheck 1
-	**** abc != acb: 602: muldivcheck 2
-	**** acb != bac: 602: muldivcheck 2
-	...
-	**** t4 != a4: 622: algcheck 1
-	**** t5 != a5: 622: algcheck 1
-	**** t6 != a6: 622: algcheck 1
-	**** t4 != a4: 622: algcheck 1
-	...
+    * The chi.cal resource file does not work well with odd degrees
+      of freedom.  Can someone improve this algorithm?
 
-	it finally hangs at test 2000.
+    * 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:
 
-      The work-a-round is to compile calc without the optimizer.  If this
-      happens to you, try compiling without -O and without -O2.	 I.e., in
-      the Makefile, set:
+        i = (ord("\n") << 16) | (ord("i") << 8) | ord("H")
+        b = blk()
+        copy(i, b)
+        fd = fopen("file", "w")
+        copy(b, fd);
+        fclose(fd)
 
-	DEBUG= -g
+      will write an extra NUL octet to the file.  Where as:
 
-    * There are problems compiling calc on the sparcv9 under 64 bit
-      Solaris.	On that platform, gcc-2.96 is able to compile calc, but
-      calc dumps core very early on in startup.	 It is said that sparcv9
-      support in gcc-2.96 is very unofficial and thus there is no
-      work-a-round for gcc-2-96.
+        read intfile
+        i = (ord("\n") << 16) | (ord("i") << 8) | ord("H")
+        be2file(i, "file2")
 
-      There is a work-a-round for this architecture us one is using the
-      Solaris CC on the sparcv9.  It has been reported that setting the
-      following Makefile variables will produce a working version of
-      calc on the sparcv9 under 64 bit Solaris:
+      will not.
 
-	    LCC="cc -xarch=v9"
-	    CCWARN="-DFORCE_STDC -w"
-	    DEBUG="-fast -xarch=v9"
+    * The numerator is assumed
 
-    * Under BSDI v4, the warnings of the form:
+        The numerator value of 1 appears to be assumed.  In calc:
 
-	/usr/include/ctype.h:147: warning: `__runetype' defined but not used
-	/usr/include/ctype.h:161: warning: `__isctype' defined but not used
-	/usr/include/ctype.h:170: warning: `toupper' defined but not used
-	/usr/include/ctype.h:177: warning: `tolower' defined but not used
+             / 2
 
-      are seen.	 These warnings are the result of mis-features in BSDI
-      include files.  They do not have an impact on the operation
-      or performance.  The work-a-round is to ignore these warnings
-      under BSDI.
+        will produce a value of 0.5 as if the numerator 1 was given.
 
-## Copyright (C) 1999  Landon Curt Noll
+
+=-=
+
+## Copyright (C) 1999-2014,2021,2023  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
@@ -169,20 +177,16 @@ Problems with known work-a-rounds:
 ##
 ## 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
+## 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.
-## 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+## 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 ##
-## @(#) $Revision: 29.4 $
-## @(#) $Id: BUGS,v 29.4 1999/12/15 09:13:29 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
 ##
-## Under source code control:	1994/03/18 14:06:13
-## File existed as early as:	1994
-##
-## chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
-## Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+## chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+## Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+https://github.com/lcn2/calc/blob/master/QUESTIONS.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

CONTRIB-CODE

@@ -0,0 +1,64 @@
+Calc is open source. Contributions of code are welcome.
+
+In order to consider integrating your contributions, we need:
+
+    * your changes applied agsinst the top of the calc master branch:
+
+          https://github.com/lcn2/calc/
+
+    * new help files or help file patches, if applicable (documentation)
+
+    * Update CHANGES file (brief description of what it does)
+
+    * regress.cal test patch as needed
+
+If you add functionality to calc, please be sure to modify
+Makefiles, help files, cal/regress.cal test code as well.
+Regression test cases are vital to maintaining calc's level
+of correctness and helps us avoid code bug regression.
+
+The best way contribute to calc bug is to generate calc
+GitHub pull request against the calc GitHub repo:
+
+    https://github.com/lcn2/calc/pulls
+
+Please be patient as we cannot always respond pull requests quickly.
+
+=-=
+
+IMPORTANT:
+
+Your code needs to be contributed under either the 2.1 of the GNU
+Lesser General Public License (LGPL 2.1) or under "The Unlicense":
+
+    https://unlicense.org
+
+=-=
+
+See also the calc wishlist by running the calc command:
+
+    ; help wishlist
+
+=-=
+
+## Copyright (C) 1999,2014,2021,2023  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.
+##
+## Under source code control:   1997/03/09 16:33:22
+## 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/

CONTRIBUTING.md

@@ -0,0 +1,7 @@
+# How to contribue code to calc
+
+## CONTRIB-CODE
+
+See the file
+<A HREF="https://github.com/lcn2/calc/blob/master/CONTRIB-CODE">CONTRIB-CODE</A>
+for how to contribue code to calc.

COPYING

@@ -1,22 +1,18 @@
-		calc - arbitrary precision calculator
-
+                calc - arbitrary precision calculator
 
 This file is Copyrighted
 ------------------------
 
+    This file is not covered under version 2.1 of the GNU LGPL.
     This file is covered under the following Copyright:
 
-	Copyright (C) 1999  Landon Curt Noll
-	All rights reserved.
+        Copyright (C) 1999-2023  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.
+        Everyone is permitted to copy and distribute verbatim copies
+        of this license document, but changing it is not allowed.
 
-    # @(#) $Revision: 29.1 $
-    # @(#) $Id: COPYING,v 29.1 1999/12/14 09:15:29 chongo Exp $
-    # @(#) $Source: /usr/local/src/cmd/calc/RCS/COPYING,v $
-
-=-=
+-=-
 
 Calc is covered by the GNU Lesser General Public License
 --------------------------------------------------------
@@ -37,36 +33,21 @@ Calc is covered by the GNU Lesser General Public License
     A copy of the GNU Lesser General Public License is distributed with
     calc under the filename:
 
-	    COPYING-LGPL
+            COPYING-LGPL
 
-    You may display this file by the calc command:	help copying
+    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
+    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:
+    Public License with calc; if not, write to the following address:
 
-	    Free Software Foundation, Inc.
-	    59 Temple Place
-	    Suite 330
-	    Boston, MA	02111-1307
-	    USA
-
-    The contact addresses for calc is as follows:
-
-	Web:	http://reality.sgi.com/chongo/tech/comp/calc/index.html
-		http://www.isthe.com/chongo/tech/comp/calc/index.html
-
-	EMail:	calc-tester at postofc dot corp dot sgi dot com
-		calc-tester at isthe dot com
-
-		[[ Replace 'at' with @, 'dot' is with . and remove spaces ]]
-
-    The 2nd address set is provided in case the 1st address set no
-    longer functions.
-
-=-=
+            Free Software Foundation, Inc.
+            51 Franklin Street
+            Fifth Floor
+            Boston, MA  02110-1301
+            USA
 
 Calc's relationship to the GNU Lesser General Public License
 ------------------------------------------------------------
@@ -74,76 +55,78 @@ 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.
+        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.
+        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
+        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:
+    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
+        * 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:
+     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
+        * 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
+        * 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.
+     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 Copyrights:
+    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  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
+        Copyright (C) year  Christoph Zurnieden
+        Copyright (C) year  Landon Curt Noll and Thomas Jones-Low
+        Copyright (C) year  Klaus Alexander Seistrup and Landon Curt Noll
 
-    A few files are not covered under the GNU Lesser General Public
-    License.  The source files not covered are:
+    These files are not covered under one of the Copyrights listed above:
 
-	    shs1.c	    shs1.h	shs.c		 shs.h
-	    md5.c	    md5.h	lib/qtime.cal	 COPYING
-	    COPYING-LGPL
+            sha1.c              sha1.h          COPYING
+            COPYING-LGPL        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
@@ -155,21 +138,59 @@ Calc copyrights and exception files
     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.
 
-=-=
+    These files are covered under "The Unlicense":
+
+            sha1.c
+            sha1.h
+            cal/dotest.cal
+            cal/screen.cal
+
+    "The Unlicense" is as follows:
+
+        This is free and unencumbered software released into the public domain.
+
+        Anyone is free to copy, modify, publish, use, compile, sell, or
+        distribute this software, either in source code form or as a compiled
+        binary, for any purpose, commercial or non-commercial, and by any
+        means.
+
+        In jurisdictions that recognize copyright laws, the author or authors
+        of this software dedicate any and all copyright interest in the
+        software to the public domain. We make this dedication for the benefit
+        of the public at large and to the detriment of our heirs and
+        successors. We intend this dedication to be an overt act of
+        relinquishment in perpetuity of all present and future rights to this
+        software under copyright law.
+
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+        IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+        OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+        ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+        OTHER DEALINGS IN THE SOFTWARE.
+
+        For more information, please refer to <http://unlicense.org/>
+
+    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/
+        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
+        http://www.gnu.org/copyleft/lesser.html
+        http://www.gnu.org/copyleft/lesser.txt
 
-=-=
+-=-
 
 Why calc did not use the GNU General Public License
 ---------------------------------------------------
@@ -177,10 +198,10 @@ 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
+        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
+    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.

COPYING-LGPL

@@ -1,8 +1,8 @@
-		  GNU LESSER GENERAL PUBLIC LICENSE
-		       Version 2.1, February 1999
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
 
  Copyright (C) 1991, 1999 Free Software Foundation, Inc.
-     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ 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.
 
@@ -10,7 +10,7 @@
  as the successor of the GNU Library Public License, version 2, hence
  the version number 2.1.]
 
-			    Preamble
+                            Preamble
 
   The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
@@ -112,7 +112,7 @@ modification follow.  Pay close attention to the difference between a
 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
+                  GNU LESSER GENERAL PUBLIC LICENSE
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
   0. This License Agreement applies to any software library or other
@@ -146,7 +146,7 @@ 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
@@ -432,7 +432,7 @@ 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
+                            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.
@@ -455,7 +455,7 @@ 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
+                     END OF TERMS AND CONDITIONS
 
            How to Apply These Terms to Your New Libraries
 
@@ -476,7 +476,7 @@ convey the exclusion of warranty; and each file should have at least the
     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 of the License, or (at your option) any later version.
+    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
@@ -485,7 +485,8 @@ convey the exclusion of warranty; and each file should have at least the
 
     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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+    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.
 
@@ -500,5 +501,3 @@ necessary.  Here is a sample; alter the names:
   Ty Coon, President of Vice
 
 That's all there is to it!
-
-

HOWTO.INSTALL

@@ -1,55 +1,390 @@
-Installing calc in 4 easy steps:
+# Installing a pre-compiled calc from an RPM
 
-    1) Look at the makefile, and adjust it to suit your needs.
+If your platform supports RPMs, you may want to go to:
 
-       Here are some Makefile hints:
+    https://github.com/lcn2/calc/releases
 
-	   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.
+and see if there is a pre-compiled version of calc that you may install.
 
-	   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.
+Open up the 'Assets' tag below a given release and download these RPMs:
 
-	   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.
+    * calc*.rpm
 
-	   Set TOPDIR to be the place under which help files, calc,
-	   include files and calc libs are to be installed.  As shipped
-	   the Makefile assumes a TOPDIR of /usr/local/lib.
+        - all that is needed if you just want to use calc
 
-	   Set BINDIR to the place where calc is installed.  As shipped
-	   the Makefile assumes a BINDIR /usr/local/bin.
+If your platform supports rpm and matches one of the "calc*.rpm" files, you
+may just install that "calc*.rpm".  For exammple on an x86_64 system:
 
-	   Adjust other Makefile variables as needed.
+    dnf install calc-x.y.z.cv-ww.x86_64.rpm
 
-    2) build calc:
+where "calc-x.y.z.cv-ww.x86_64.rpm" is the name of the calc RPM.
 
-	make all
+In addition, if your platform supports rpm and matches one of the
+"calc*.rpm" files, you may also install the calc *.h header and *.a lib
+files for use in other programs:
 
-	==> 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.
+    * calc-devel-*.rpm
 
-    3) test calc:
+        - calc *.h header and *.a lib files for use in other programs
 
-	make check
+Alternately to the above github link, you might try looking at the RPMs under:
 
-	==> If you run into problems, follow the BUGS file instructions.
+    http://www.isthe.com/chongo/src/calc/
 
-    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.
+# Building calc from a source tree
 
-## Copyright (C) 1999  Landon Curt Noll
+
+
+## Step 0: Obtain the calc source tree
+
+Go to the site:
+
+    https://github.com/lcn2/calc/releases
+
+Look for release with a file of the form:
+
+    calc-x.y.z.v.tar.bz2
+
+A release marked with a green "(Latest)" is a production release
+that as undergone a fair amount of testing.
+
+A release marked with an orange "(Pre-release)" is likly to be
+more stable than the top of the master branch, as they do undergo
+thru a reasonable level of regression testing, just not to
+the level of a  "(Latest)" production release.
+
+Use the followig command to uncompress the bzip2 compressed tarball:
+
+    bunzip2 -c calc-*.tar.bz2 | tar -xvf -
+
+NOTE: An alternate location for calc bzip2 compressed tarballs is:
+
+    http://www.isthe.com/chongo/src/calc/
+
+
+
+### Obtaining the experimental top of the master branch calc source
+
+You may also fetch the top of the master branch of the GitHub repo
+if you wish to see what the latest source code looks like:
+
+    git clone https://github.com/lcn2/calc.git
+
+IMPORTANT:
+
+The latest source code may be "experimental in nature".   You may be
+better off using a released bzip2 compressed tarball instead.
+Released bzip2 compressed tarballs tend to be more well tested
+than the top of the master branch.
+
+
+
+## Step 1: Makefile considerations
+
+
+### IMPORTANT: Make support of conditional syntax required:
+
+To compile calc, you must use a make that supports the use of
+"Conditional syntax".  As nearly all modern make tools
+support "Conditional syntax", thus should not be a problem
+for you.  If for some reason your make tool does not support
+"Conditional syntax", consider upgraded to a make that does,
+such as the Gnu Make tool:
+
+    https://www.gnu.org/software/make/
+
+The Gnu Make is not required per-se, just a modern make tool
+that supports "Conditional syntax".
+
+
+### Review Makefiles
+
+Review Makefile.config and Makefile.target.
+
+If you are curious, review Makefile as well, although
+there may be little in the main Makefile that you may
+want to change.
+
+Consider modifying Makefile.local by replace values or
+appending values found in Makefile.config and Makefile.target.
+
+If you are adding custom functions, review custom/Makefile
+and modify custom/Makefile as needed.
+
+
+
+### Suggestion: Modify Makefile.local
+
+All Makefiles include Makefile.local just before the
+first and default all rule.  So Makefile.local may be
+used to modify, replace or append values to Makefile variables.
+
+In most cases, to change the way that calc is made, consider
+adding lines to Makefile.local instead of modifying other Makefiles.
+
+A recommended way to adjust it is to add lines to: Makefile.local
+using the := syntax to replace values such as:
+
+    DEBUG:= -O0 -g
+
+or by using the += syntax to append to values such as:
+
+    DEBUG+= -ipa
+
+You can, of course, modify other Makefiles.  We only
+suggest using Makefile.local to minimize the number
+of source files you modify.
+
+And finally, you can always just add arguments to your
+make command line instead of modifying a Makefile.  For example:
+
+    make clobber all DEBUG="-O0 -g"
+
+
+## readline package assumed by default:
+
+By "readline package" we refer to the combination of the
+readline library, the history library, and the ncurses library.
+
+By default, calc assumes you have the readline package installed.
+The readline package (-lreadline, -lhistory, -lncurses) used by and
+linked into calc by default.
+
+If your system (such as macOS) does NOT have those libaraies, then
+you have two options:
+
+
+
+### Install the readline package:
+
+We recommend that you install the readline package first, then compile calc.
+
+For information on the readline package, see:
+
+    https://tiswww.case.edu/php/chet/readline/rltop.html
+
+MacOS users can use MacPorts or HomeBrew to install readline:
+
+    https://www.macports.org
+    https://brew.sh
+
+Or compile from the readline.git repo:
+
+    http://git.savannah.gnu.org/cgit/readline.git/
+
+
+
+### Compile calc without readline:
+
+Why do we not recommend this option because using calc with readline
+provides a beter user experience.
+
+If you feel you must use calc without the readline package, then you
+will need to compile with:
+
+    make clobber all USE_READLINE= READLINE_EXTRAS= READLINE_INCLUDE= READLINE_LIB=
+
+or add to Makefile.local, these lines:
+
+    USE_READLINE=
+    READLINE_EXTRAS=
+    READLINE_INCLUDE=
+    READLINE_LIB=
+
+See the "Suggestion: Modify Makefile.local" section above for
+information on the Makefile.local file.
+
+
+### Windows or a Windows-like environments:
+
+Currently Windows is not a well supported platform for calc.  There are
+people within Microsoft who plan to assist us in being able to allow
+the standard Microsoft Windows developor environment to compile calc.
+
+
+
+### Makefile variables to consider:
+
+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.
+
+Again, consider adding replacement lines or append linbes to
+the Makefile.local file.  See "Suggestion Modify Makefile.local
+instead of Makefile" above.  For example:
+
+    T:= /var/tmp/testing
+
+See the "Suggestion: Modify Makefile.local" section above for
+information on the Makefile.local file.
+
+
+### platform target section
+
+The file, Makefile.target, contains information about various platforms.
+The current list of targets in Makefile.target are:
+
+- Linux target
+- Apple macOS / Darwin target
+- FreeBSD target
+- OpenBSD target
+- Cygwin target (as well as Msys2 / Msys OSNAME)
+- simple target
+- default target (when target is empty)
+
+If you wish to modiy your target platform, consider doing
+so via the Makefile.local file.  See "Suggestion Modify Makefile.local
+instead of Makefile" above.
+
+
+
+## Step 2: compile calc
+
+Remove any previous compile attempts and compile by default:
+
+    make clobber all
+
+
+
+### Force calc to build with only static libs:
+
+You may force calc to build with only static libs:
+
+    make clobber calc-static-only BLD_TYPE=calc-static-only
+
+
+
+### Force calc to build with only dynamic shared libs:
+
+You may force calc to build with only dynamic libs:
+
+    make clobber calc-dynamic-only BLD_TYPE=calc-dynamic-only
+
+
+
+### Reports of compiler warnings (and errors) as welcome
+
+We are interested learning about any compiler warnings (and errors) that you may find.
+See the BUGS file if you find any compiler warning or errors.
+
+
+
+### Step 3: test calc
+
+You may run the calc regression test suite, after successfully compiling, by:
+
+    make check
+
+For a more quiet check which only prints if something goes wrong, use:
+
+    make chk
+
+
+
+### Step 4: install calc
+
+Depending on permissions, you may need to become the super-user:
+
+    sudo -s
+
+before you install:
+
+    make install
+
+
+
+### Step n: calc help - getting started
+
+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.
+
+For list of help topics:
+
+    ; 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 with 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
+
+We suggest that you might want to read the README.FIRST file and look at
+the calc help subsystem.  See also the README.md file.
+
+In general, if you run into problems, read the BUGS file and follow the instructions.
+
+# IMPORTANT: parallel make not supported
+
+We do not support making calc using a parallel make as most parallel
+make systems fail to understand the depedency relationships between
+a numner of important make rules and thus fail to properly compile calc.
+
+
+
+## Copyright (C) 1999-2007,2021,2023  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
@@ -57,20 +392,16 @@ the calc help subsystem.  See the README file for details.
 ##
 ## 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
+## 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.
-## 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+## 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 ##
-## @(#) $Revision: 29.1 $
-## @(#) $Id: HOWTO.INSTALL,v 29.1 1999/12/14 09:15:29 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
 ##
-## Under source code control:	1999/09/27 20:48:44
-## File existed as early as:	1999
-##
-## chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
-## Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+## chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+## Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/

LIBRARY

@@ -1,4 +1,4 @@
-	USING THE ARBITRARY PRECISION ROUTINES IN A C PROGRAM
+USING THE ARBITRARY PRECISION ROUTINES IN A C PROGRAM
 
 Part of the calc release consists of an arbitrary precision math link library.
 This link library is used by the calc program to perform its own calculations.
@@ -19,9 +19,9 @@ FIRST THINGS FIRST
 ------------------
 
 ...............................................................................
-.									      .
+.                                                                             .
 . 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
@@ -34,92 +34,259 @@ INCLUDE FILES
 To use any of these routines in your own programs, you need to include the
 appropriate include file.  These include files are:
 
-	zmath.h		(for integer arithmetic)
-	qmath.h		(for rational arithmetic)
-	cmath.h		(for complex number arithmetic)
+        zmath.h         (for integer arithmetic)
+        qmath.h         (for rational arithmetic)
+        cmath.h         (for complex number arithmetic)
 
 You never need to include more than one of the above files, even if you wish
 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
-libcalc.a along with the link library itself are installed into ${LIBDIR}.
+When calc is installed, all of libraries are installed into ${LIBDIR}.
+All of the calc header files are installed under ${INCDIRCALC}.
+
+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
 
---------------
-ERROR HANDLING
---------------
+If custom functions are also used, they may want to compile with:
 
-Your program MUST provide a function called math_error.	 This is called by
-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:
+        -I${INCDIR} -L${LIBDIR} -lcalc -lcustcalc
 
-	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
-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.
+        -UCALC_SRC
 
-For convenience, the link library libcalc.a contains a math_error routine.
-By default, this routine simply prints a message to stderr and then exits.
-By simply linking in this link library, any calc errors will result in a
-error message on stderr followed by an exit.
+as well.
 
-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
-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.
+            void math_error(char *fmt, ...);
 
-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;
-    extern int calc_jmp;
-    extern char *calc_error;
-    int error;
+        There is a math_error() function supplied with the calc library.
+        By default, this routine simply prints a message to stderr and
+        then exits.  By simply linking in this link library, any calc
+        errors will result in a error message on stderr followed by
+        an exit.
 
-    ...
+    2) Use setjmp and longjmp in your program
 
-    if ((error = setjmp(calc_jmp_buf)) != 0) {
+        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.
 
-	    /* reinitialize calc after a longjmp */
-	    reinitialize();
+        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
 
-	    /* report the error */
-	    printf("Ouch: %s\n", calc_error);
-    }
-    calc_jmp = 1;
 
 ---------------
 OUTPUT ROUTINES
 ---------------
 
-The output from the routines in the link library normally goes to stdout.  You
-can divert that output to either another FILE handle, or else to a string.
-Read the routines in zio.c to see what is available.  Diversions can be
-nested.
+The output from the routines in the link library normally goes to stdout.
+You can divert that output to either another FILE handle, or else
+to a string.  Read the routines in zio.c to see what is available.
+Diversions can be nested.
 
 You use math_setfp to divert output to another FILE handle.  Calling
 math_setfp with stdout restores output to stdout.
@@ -141,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.
 
@@ -153,20 +320,20 @@ 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
-(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.
+ZVALUE.  To do this, you should call zfree() with the ZVALUE as an argument
+and never try to free the array yourself using free().  The reason for this
+is that sometimes the pointer points to a statically allocated arrays which
+should NOT be freed.
 
 The ZVALUE structures are passed to routines by value, and are returned
 through pointers.  For example, to multiply two small integers together,
 you could do the following:
 
-	ZVALUE	z1, z2, z3;
+        ZVALUE  z1, z2, z3;
 
-	itoz(3L, &z1);
-	itoz(4L, &z2);
-	zmul(z1, z2, &z3);
+        itoz(3L, &z1);
+        itoz(4L, &z2);
+        zmul(z1, z2, &z3);
 
 Use zcopy to copy one ZVALUE to another.  There is no sharing of arrays
 between different ZVALUEs even if they have the same value, so you MUST
@@ -177,7 +344,7 @@ values of 0 and 1 are so common that special checks are made for them.
 
 For initial values besides 0 or 1, you need to call itoz to convert a long
 value into a ZVALUE, as shown in the above example.  Or alternatively,
-for larger numbers you can use the atoz routine to convert a string which
+for larger numbers you can use the str2z routine to convert a string which
 represents a number into a ZVALUE.  The string can be in decimal, octal,
 hex, or binary according to the leading digits.
 
@@ -187,72 +354,84 @@ address to a routine as a destination value, otherwise memory will be
 lost.  The following shows an example of the correct way to free memory
 over a long sequence of operations.
 
-	ZVALUE z1, z2, z3;
+        ZVALUE z1, z2, z3;
 
-	z1 = _one_;
-	atoz("12345678987654321", &z2);
-	zadd(z1, z2, &z3);
-	zfree(z1);
-	zfree(z2);
-	zsquare(z3, &z1);
-	zfree(z3);
-	itoz(17L, &z2);
-	zsub(z1, z2, &z3);
-	zfree(z1);
-	zfree(z2);
-	zfree(z3);
+        z1 = _one_;
+        str2z("12345678987654321", &z2);
+        zadd(z1, z2, &z3);
+        zfree(z1);
+        zfree(z2);
+        zsquare(z3, &z1);
+        zfree(z3);
+        itoz(17L, &z2);
+        zsub(z1, z2, &z3);
+        zfree(z1);
+        zfree(z2);
+        zfree(z3);
 
 There are some quick checks you can make on integers.  For example, whether
 or not they are zero, negative, even, and so on.  These are all macros
 defined in zmath.h, and should be used instead of checking the parts of the
 ZVALUE yourself.  Examples of such checks are:
 
-	ziseven(z)	(number is even)
-	zisodd(z)	(number is odd)
-	ziszero(z)	(number is zero)
-	zisneg(z)	(number is negative)
-	zispos(z)	(number is positive)
-	zisunit(z)	(number is 1 or -1)
-	zisone(z)	(number is 1)
-	zisnegone(z)	(number is -1)
-	zistwo(z)	(number is 2)
-	zisabstwo(z)	(number is 2 or -2)
-	zisabsleone(z)	(number is -1, 0 or 1)
-	zislezero(z)	(number is <= 0)
-	zisleone(z)	(number is <= 1)
-	zge16b(z)	(number is >= 2^16)
-	zge24b(z)	(number is >= 2^24)
-	zge31b(z)	(number is >= 2^31)
-	zge32b(z)	(number is >= 2^32)
-	zge64b(z)	(number is >= 2^64)
+        ziseven(z)      (number is even)
+        zisodd(z)       (number is odd)
+        ziszero(z)      (number is zero)
+        zisneg(z)       (number is negative)
+        zispos(z)       (number is positive)
+        zisunit(z)      (number is 1 or -1)
+        zisone(z)       (number is 1)
+        zisnegone(z)    (number is -1)
+        zistwo(z)       (number is 2)
+        zisabstwo(z)    (number is 2 or -2)
+        zisabsleone(z)  (number is -1, 0 or 1)
+        zislezero(z)    (number is <= 0)
+        zisleone(z)     (number is <= 1)
+        zge16b(z)       (number is >= 2^16)
+        zge24b(z)       (number is >= 2^24)
+        zge31b(z)       (number is >= 2^31)
+        zge32b(z)       (number is >= 2^32)
+        zge64b(z)       (number is >= 2^64)
 
 Typically the largest unsigned long is typedefed to FULL.  The following
 macros are useful in dealing with this data type:
 
-	MAXFULL		(largest positive FULL value)
-	MAXUFULL	(largest unsigned FULL value)
-	zgtmaxfull(z)	(number is > MAXFULL)
-	zgtmaxufull(z)	(number is > MAXUFULL)
-	zgtmaxlong(z)	(number is > MAXLONG, largest long value)
-	zgtmaxulong(z)	(number is > MAXULONG, largest unsigned long value)
+        MAXFULL         (largest positive FULL value)
+        MAXUFULL        (largest unsigned FULL value)
+        zgtmaxfull(z)   (number is > MAXFULL)
+        zgtmaxufull(z)  (number is > MAXUFULL)
+        zgtmaxlong(z)   (number is > MAXLONG, largest long value)
+        zgtmaxulong(z)  (number is > MAXULONG, largest unsigned long value)
 
 If zgtmaxufull(z) is false, then one may quickly convert the absolute
 value of number into a full with the macro:
 
-	ztofull(z)	(convert abs(number) to FULL)
-	ztoulong(z)	(convert abs(number) to an unsigned long)
-	ztolong(z)	(convert abs(number) to a long)
+        ztofull(z)      (convert abs(number) to FULL)
+        ztoulong(z)     (convert abs(number) to an unsigned long)
+        ztolong(z)      (convert abs(number) to a long)
 
 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
-function tests whether two ZVALUEs are equal, returning TRUE if they differ.
+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
 is larger.
 
+To determine if z is an integer power of 2, use zispowerof2:
+
+        ZVALUE z;               /* value to check if it is a power of */
+        FULL log2;              /* set to log base 2 of z when is_power_of_2 is true */
+        bool is_power_of_2;
+
+        is_power_of_2 = zispowerof2(z, &log2)
+
+Returns true if z an integer power of 2: set log2 to log base 2 of z.
+Returns false if z is NOT integer power of 2 and leave log2 untouched.
+The log2 arg must be a non-NULL pointer to a ZVALUE.
+
 ---------------
 USING FRACTIONS
 ---------------
@@ -266,34 +445,35 @@ 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
 returned value can simply be overwritten with new ZVALUEs without needing
 to free them first.  The following illustrates this:
 
-	NUMBER *q;
+        NUMBER *q;
 
-	q = qalloc();
-	itoz(55L, &q->num);
+        q = qalloc();
+        itoz(55L, &q->num);
 
 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,
+iitoq, or str2q 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
+NUMBER (reducing them first if needed), and str2q converts a string representing
+a number into the corresponding NUMBER.  The str2q function accepts input in
 integral, fractional, real, or exponential formats.  Examples of allocating
 numbers are:
 
-	NUMBER *q1, *q2, *q3;
+        NUMBER *q1, *q2, *q3, *q4;
 
-	q1 = itoq(66L);
-	q2 = iitoq(2L, 3L);
-	q3 = atoq("456.78");
+        q1 = itoq(66L);
+        q2 = iitoq(2L, 3L);
+        q3 = str2q("456.78");
+        q4 = utoq((FULL) 1234567890L);
 
 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
@@ -306,14 +486,16 @@ the ZVALUEs contained within the NUMBER, and then puts the NUMBER structure
 onto a free list for quick reuse.  The following is an example of allocating
 NUMBERs, copying them, adding them, and finally deleting them again.
 
-	NUMBER *q1, *q2, *q3;
+        NUMBER *q1, *q2, *q3, *q4;
 
-	q1 = itoq(111L);
-	q2 = qlink(q1);
-	q3 = qqadd(q1, q2);
-	qfree(q1);
-	qfree(q2);
-	qfree(q3);
+        q1 = itoq(111L);
+        q2 = qlink(q1);
+        q3 = qqadd(q1, q2);
+        q4 = qnum(q2, q3);
+
+        qfree(q1);
+        qfree(q2);
+        qfree(q3);
 
 Because of the passing of pointers and the ability to copy numbers easily,
 you might wish to use the rational number routines even for integral
@@ -331,52 +513,66 @@ There are some transcendental functions in the link library, such as sin
 and cos.  These cannot be evaluated exactly as fractions.  Therefore,
 they accept another argument which tells how accurate you want the result.
 This is an "epsilon" value, and the returned value will be within that
-quantity of the correct value.	This is usually an absolute difference,
+quantity of the correct value.  This is usually an absolute difference,
 but for some functions (such as exp), this is a relative difference.
 For example, to calculate sin(0.5) to 100 decimal places, you could do:
 
-	NUMBER *q, *ans, *epsilon;
+        NUMBER *q, *ans, *epsilon;
 
-	q = atoq("0.5");
-	epsilon = atoq("1e-100");
-	ans = qsin(q, epsilon);
+        q = str2q("0.5");
+        epsilon = str2q("1e-100");
+        ans = qsin(q, epsilon);
 
 There are many convenience macros similar to the ones for ZVALUEs which can
 give quick information about NUMBERs.  In addition, there are some new ones
 applicable to fractions.  These are all defined in qmath.h.  Some of these
 macros are:
 
-	qiszero(q)	(number is zero)
-	qisneg(q)	(number is negative)
-	qispos(q)	(number is positive)
-	qisint(q)	(number is an integer)
-	qisfrac(q)	(number is fractional)
-	qisunit(q)	(number is 1 or -1)
-	qisone(q)	(number is 1)
-	qisnegone(q)	(number is -1)
-	qistwo(q)	(number is 2)
-	qiseven(q)	(number is an even integer)
-	qisodd(q)	(number is an odd integer)
-	qistwopower(q)	(number is a power of 2 >= 1)
+        qiszero(q)              (number is zero)
+        qisneg(q)               (number is negative)
+        qispos(q)               (number is positive)
+        qisint(q)               (number is an integer)
+        qisfrac(q)              (number is fractional)
+        qisunit(q)              (number is 1 or -1)
+        qisone(q)               (number is 1)
+        qisnegone(q)            (number is -1)
+        qistwo(q)               (number is 2)
+        qiseven(q)              (number is an even integer)
+        qisodd(q)               (number is an odd integer)
+        qisreciprocal(q)        (number is 1 / an integer and q != 0)
 
 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:
 
-	NUMBER *q1, *q2;
+        NUMBER *q1, *q2;
 
-	q1 = qlink(&_qonehalf_);
-	q2 = qlink(&_qone_);
+        q1 = qlink(&_qonehalf_);
+        q2 = qlink(&_qone_);
+
+To determine if q is an integer power of 2, use qispowerof2:
+
+        NUMBER *q;              /* value to check if it is a power of */
+        NUMBER *qlog2;          /* set to log base 2 of q when is_power_of_2 is true */
+        bool is_power_of_2;
+
+        q = utoq((FULL) 1234567890L);
+        qlog2 = qalloc();
+        is_power_of_2 = qispowerof2(q, &qlog2);
+
+Returns true if q an integer power of 2: set *qlog2 to log base 2 of q.
+Returns false if q is NOT integer power of 2 and leave *qlog2 untouched.
+Use qalloc() to setup the qlog2 arg before calling.
 
 ---------------------
 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.
 
@@ -387,19 +583,19 @@ fractional parts using qqtoc.  You can copy COMPLEX values using clink
 which increments the link count.  And you free a COMPLEX value using cfree.
 The following example illustrates this:
 
-	NUMBER *q1, *q2;
-	COMPLEX *c1, *c2, *c3;
+        NUMBER *q1, *q2;
+        COMPLEX *c1, *c2, *c3;
 
-	q1 = itoq(3L);
-	q2 = itoq(4L);
-	c1 = qqtoc(q1, q2);
-	qfree(q1);
-	qfree(q2);
-	c2 = clink(c1);
-	c3 = cmul(c1, c2);
-	cfree(c1);
-	cfree(c2);
-	cfree(c3);
+        q1 = itoq(3L);
+        q2 = itoq(4L);
+        c1 = qqtoc(q1, q2);
+        qfree(q1);
+        qfree(q2);
+        c2 = clink(c1);
+        c3 = cmul(c1, c2);
+        cfree(c1);
+        cfree(c2);
+        cfree(c3);
 
 As a shortcut, when you want to manipulate a COMPLEX value by a real value,
 you can use the caddq, csubq, cmulq, and cdivq routines.  These accept one
@@ -409,53 +605,77 @@ 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:
 
-	COMPLEX *c;
-	NUMBER *rp, *ip;
+        COMPLEX *c;
+        NUMBER *rp, *ip;
 
-	c = calloc();
-	rp = qlink(c->real);
-	ip = qlink(c->imag);
+        c = calloc();
+        rp = qlink(c->real);
+        ip = qlink(c->imag);
 
 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)
-	ciszero(c)	(number is zero)
-	cisnegone(c)	(number is -1)
-	cisone(c)	(number is 1)
-	cisrunit(c)	(number is 1 or -1)
-	cisiunit(c)	(number is i or -i)
-	cisunit(c)	(number is 1, -1, i, or -i)
-	cistwo(c)	(number is 2)
-	cisint(c)	(number is has integer real and imaginary parts)
-	ciseven(c)	(number is has even real and imaginary parts)
-	cisodd(c)	(number is has odd real and imaginary parts)
+        cisreal(c)      (number is real)
+        cisimag(c)      (number is pure imaginary)
+        ciszero(c)      (number is zero)
+        cisnegone(c)    (number is -1)
+        cisone(c)       (number is 1)
+        cisrunit(c)     (number is 1 or -1)
+        cisiunit(c)     (number is i or -i)
+        cisunit(c)      (number is 1, -1, i, or -i)
+        cistwo(c)       (number is 2)
+        cisint(c)       (number is has integer real and imaginary parts)
+        ciseven(c)      (number is has even real and imaginary parts)
+        cisodd(c)       (number is has odd real and imaginary parts)
 
 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.
+for equality.  The ccmp function returns true if two complex numbers differ.
 
-There are three predefined values for complex numbers.	You should clink
-them when you want to use them.	 They are _czero_, _cone_, and _conei_.
+Sometimes to results of a COMPLEX based calculation is a real number.
+That is, the imaginary part of the COMPLEX is 0.  You may convert the
+COMPLEX into a new allocated NUMBER that is real part of the COMPLEX value.
+For example:
+
+        COMPLEX *c;
+        NUMBER *q;
+        bool ok_to_free;        /* true ==> free COMPLEX value, false ==> do not */
+
+        if (cisreal(c)) {
+                q = c_to_q(c, ok_to_free);
+        }
+
+The 2nd argument to c_to_q() determines if the complex argument should be freed
+or not.  Pass a false value as the 2nd arg if you wish to continue to use the
+COMPLEX value.
+
+To convert a NUMBER into a COMPLEX value, use:
+
+        COMPLEX *c;
+        NUMBER *q;
+
+        c = q_to_c(q);
+
+There are three predefined values for complex numbers.  You should clink
+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()
+If you wish, when you are all done 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
+## Copyright (C) 1999,2021,2023  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
@@ -463,20 +683,16 @@ need call libcalc_call_me_last() only once.
 ##
 ## 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
+## 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.
-## 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+## 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 ##
-## @(#) $Revision: 29.1 $
-## @(#) $Id: LIBRARY,v 29.1 1999/12/14 09:15:29 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
 ##
-## Under source code control:	1993/07/30 19:44:49
-## File existed as early as:	1993
-##
-## chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
-## Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+## chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+## Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/

Makefile.local

@@ -0,0 +1,100 @@
+#!/usr/bin/env make
+#
+# Makefile.local - modify, replace or append calc Makefile variables
+#
+# Copyright (C) 2023  Landon Curt Noll
+#
+# Suggestion: Read the HOWTO.INSTALL file.
+#
+# Calc is open software; you can redistribute it and/or modify it under
+# the terms of 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.
+# 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+#
+# This calculator first developed by David I. Bell with help/mods from others.
+#
+# chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+# Share and enjoy!  :-)		http://www.isthe.com/chongo/tech/comp/calc/
+
+####
+# This file is included all calc Makefiles after the last Makefile variable
+# is set and before the first make rule.  This makes this file suitable to
+# modify, replace or append Makefile variables.
+#
+# To replace a Makefile variable, use := symbols.  For example:
+#
+#	CCWERR:= -Werror
+#	DEBUG:= -O0 -g
+#
+# You can append to an existing Makefile variable using '+=' symbols.
+# For example:
+#
+#	CCOPT+= -Ofast
+#	COMMON_CFLAGS+= -std=gnu2x
+####
+
+###################################################################
+# NOTE: For this and other commended out examples in this file,	  #
+# you need to remove the leading '#<whitespaces>' to take effect. #
+#								  #
+# Comments start with a #-character.				  #
+###################################################################
+
+####
+# Force calc to install under /usr/local
+#
+# PREFIX:= /usr/local
+# BINDIR:= ${PREFIX}/bin
+# LIBDIR:= ${PREFIX}/lib
+# CALC_SHAREDIR:= ${PREFIX}/share/calc
+# CALC_INCDIR:= ${PREFIX}/include/calc
+####
+
+####
+# macOS Address Sanitizer (ASAN)
+#
+# This comment block was tested under:
+#
+# 	macOS 14.0 with Apple clang version 15.0.0 (clang-1500.0.40.1) for arm64
+#
+# See the FSANITIZE comment block in Makefile.config for common FSANITIZE values and more info.
+#
+# To use the Address Sanitizer, uncomment this set set of lines and recompile (make clobber all):
+#
+# FSANITIZE+= -fsanitize=nullability-arg
+# FSANITIZE+= -fsanitize=nullability-assign
+# FSANITIZE+= -fsanitize=nullability-return
+# CFLAGS+= ${FSANITIZE}
+# LDFLAGS+= ${FSANITIZE}
+# DEBUG:= -O0 -g3
+####
+
+####
+# RHEL (Linux) Address Sanitizer (ASAN)
+#
+# This comment block was tested under:
+#
+#	RHEL9.2 with clang version 15.0.7 (Red Hat 15.0.7-2.el9) for x86_64
+#
+# with these RPMs installed:
+#
+# 	libasan-11.3.1-4.3.el9.x86_64 libubsan-11.3.1-4.3.el9.x86_64
+#
+# See the FSANITIZE comment block in Makefile.config for common FSANITIZE values and more info.
+#
+# To use the Address Sanitizer, uncomment this set set of lines and recompile (make clobber all):
+#
+# FSANITIZE+= -fsanitize=bounds
+# CFLAGS+= ${FSANITIZE}
+# LDFLAGS+= ${FSANITIZE}
+# DEBUG:= -O0 -g3
+###

Makefile.target

@@ -0,0 +1,432 @@
+#!/usr/bin/env make
+#
+# Makefile.target - platform target section
+#
+# Copyright (C) 2023  Landon Curt Noll
+#
+# Suggestion: Read the HOWTO.INSTALL file.
+#
+# Calc is open software; you can redistribute it and/or modify it under
+# the terms of 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.
+# 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+#
+# This calculator first developed by David I. Bell with help/mods from others.
+#
+# chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+# Share and enjoy!  :-)		http://www.isthe.com/chongo/tech/comp/calc/
+
+
+# SUGGESTION: Instead of modifying this file, consider adding
+#	      statements to modify, replace or append Makefile
+#	      variables in the Makefile.local file.
+
+
+#######################################################################
+# NOTE: These lines are included by both Makefile and custom/Makefile #
+#######################################################################
+
+##################################################################################
+#-=-=-=-=-=- platform target section - targets that override defaults -=-=-=-=-=-#
+##################################################################################
+
+# Common values set in targets
+#
+# BLD_TYPE determines if calc is built with static and/or dynamic libs.
+#	       Set this value to one of:
+#
+#	BLD_TYPE= calc-dynamic-only
+#	BLD_TYPE= calc-static-only
+#
+# CC_SHARE are flags given to ${CC} to build .o files suitable for shared libs
+# DEFAULT_LIB_INSTALL_PATH is where calc programs look for calc shared libs
+# LD_SHARE are common flags given to ${CC} to link with shared libraries
+# LIBCALC_SHLIB are flags given to ${CC} to build libcalc shared libraries
+# LIBCUSTCALC_SHLIB are flags given to ${CC} to build libcustcalc shared lib
+#
+#	NOTE: The above 5 values are unused if BLD_TYPE= calc-static-only
+#
+# CC_STATIC are flags given to ${CC} to build .o files suitable for static libs
+# LD_STATIC are common flags given to ${CC} to link with static libraries
+# LIBCALC_STATIC are flags given to ${CC} to build libcalc static libraries
+# LIBCUSTCALC_STATIC are flags given to ${CC} to build libcustcalc static lib
+#
+#	NOTE: The above 4 values are unused if BLD_TYPE= calc-dynamic-only
+#
+# CCOPT are flags given to ${CC} for optimization
+# CCWARN are flags given to ${CC} for warning message control
+#
+# The following are given to ${CC}:
+#
+#	WNO_IMPLICT
+#	WNO_ERROR_LONG_LONG
+#	WNO_LONG_LONG
+#
+# when compiling special .o files that may need special compile options:
+#
+#	NOTE: These flags simply turn off certain compiler warnings,
+#	      which is useful only when CCWERR is set to -Werror.
+#
+#	NOTE: If your compiler does not have these -Wno files, just
+#	      set these variables to nothing as in:
+#
+#		WNO_IMPLICT=
+#		WNO_ERROR_LONG_LONG=
+#		WNO_LONG_LONG=
+#
+# CCWERR are flags given to ${CC} to make warnings fatal errors
+#	NOTE: CCWERR is only set in development Makefiles and must only be
+#	      used with ${CC}, not ${LCC}.  If you do not want the compiler
+#	      to abort on warnings, then leave CCWERR blank.
+# CCMISC are misc flags given to ${CC}
+#
+# CCBAN is given to ${CC} in order to control if banned.h is in effect.
+#	NOTE: See where CCBAN is defined above for details.
+#
+# LCC is how the C compiler is invoked on locally executed intermediate programs
+# CC is how the C compiler is invoked (with an optional Purify)
+#
+# Specific target overrides or modifications to default values
+
+
+################
+# Linux target #
+################
+
+ifeq ($(target),Linux)
+
+# default build type for this target
+#
+BLD_TYPE= calc-dynamic-only
+
+# target specific library parameters
+#
+CC_SHARE= -fPIC
+DEFAULT_LIB_INSTALL_PATH= ${PWD}:/lib:/usr/lib:${LIBDIR}:${PREFIX}/lib
+LD_SHARE= "-Wl,-rpath,${DEFAULT_LIB_INSTALL_PATH}" \
+    "-Wl,-rpath-link,${DEFAULT_LIB_INSTALL_PATH}"
+LIBCALC_SHLIB= -shared "-Wl,-soname,libcalc${LIB_EXT_VERSION}"
+LIBCUSTCALC_SHLIB= -shared "-Wl,-soname,libcustcalc${LIB_EXT_VERSION}"
+
+# static library option
+#
+CC_STATIC=
+LD_STATIC=
+LIBCALC_STATIC=
+LIBCUSTCALC_STATIC=
+
+# common values set for this target
+#
+#CCWARN= -Wall
+CCWARN= -Wall -Wextra -pedantic
+WNO_IMPLICT= -Wno-implicit
+WNO_ERROR_LONG_LONG= -Wno-error=long-long
+WNO_LONG_LONG= -Wno-long-long
+CCWERR=
+CCOPT= ${DEBUG}
+CCMISC=
+LCC= gcc
+CC= ${PURIFY} ${LCC} ${CCWERR}
+
+endif	# ($(target),Linux)
+
+
+###############################
+# Apple macOS / Darwin target #
+###############################
+
+ifeq ($(target),Darwin)
+
+# default build type for this target
+#
+BLD_TYPE= calc-dynamic-only
+
+# For old Apple Power PC systems, we need to add:
+#
+#	-std=gnu99 -arch ppc
+#
+ifeq ($(arch),powerpc)
+COMMON_ADD+= -std=gnu99
+ARCH_CFLAGS+= -arch ppc
+endif	# ($(arch),powerpc)
+
+# target specific library parameters
+#
+CC_SHARE= -fPIC
+DEFAULT_LIB_INSTALL_PATH= ${PWD}:${LIBDIR}:${PREFIX}/lib
+LD_SHARE= ${ARCH_CFLAGS}
+LIBCALC_SHLIB= -dynamiclib -undefined dynamic_lookup \
+    -install_name ${LIBDIR}/libcalc${LIB_EXT_VERSION} \
+    -current_version ${VER} \
+    ${ARCH_CFLAGS}
+LIBCUSTCALC_SHLIB= -dynamiclib -undefined dynamic_lookup \
+    -install_name ${LIBDIR}/libcustcalc${LIB_EXT_VERSION} \
+    -current_version ${VER} \
+    ${ARCH_CFLAGS}
+
+# To reduce dependency chains under macOS, we remove functions and
+# data that are unreachable by the entry point or exported symbols.
+#
+COMMON_LDFLAGS+= -Wl,-dead_strip
+COMMON_LDFLAGS+= -Wl,-dead_strip_dylibs
+
+# static library option
+#
+CC_STATIC=
+LD_STATIC= ${ARCH_CFLAGS}
+LIBCALC_STATIC=
+LIBCUSTCALC_STATIC=
+
+# common values set for this target
+#
+#CCWARN= -Wall
+CCWARN= -Wall -Wextra -pedantic
+WNO_IMPLICT= -Wno-implicit
+WNO_ERROR_LONG_LONG= -Wno-error=long-long
+WNO_LONG_LONG= -Wno-long-long
+CCWERR=
+CCOPT= ${DEBUG}
+CCMISC= ${ARCH_CFLAGS}
+LCC= cc
+CC= ${PURIFY} ${LCC} ${CCWERR}
+
+# Darwin dynamic shared lib filenames
+#
+LIB_EXT:= .dylib
+LIB_EXT_VERSION:= .${VERSION}${LIB_EXT}
+
+# LDCONFIG not required on this platform, so we redefine it to an empty string
+#
+LDCONFIG:=
+
+endif	# ($(target),Darwin)
+
+
+##################
+# FreeBSD target #
+##################
+
+ifeq ($(target),FreeBSD)
+
+# default build type for this target
+#
+BLD_TYPE= calc-dynamic-only
+
+# target specific library parameters
+#
+CC_SHARE= -fPIC
+DEFAULT_LIB_INSTALL_PATH= ${PWD}:/lib:/usr/lib:${LIBDIR}:${PREFIX}/lib
+LD_SHARE= "-Wl,-rpath,${DEFAULT_LIB_INSTALL_PATH}" \
+    "-Wl,-rpath-link,${DEFAULT_LIB_INSTALL_PATH}"
+LIBCALC_SHLIB= -shared "-Wl,-soname,libcalc${LIB_EXT_VERSION}"
+LIBCUSTCALC_SHLIB= -shared "-Wl,-soname,libcustcalc${LIB_EXT_VERSION}"
+
+CC_STATIC=
+LD_STATIC=
+LIBCALC_STATIC=
+LIBCUSTCALC_STATIC=
+
+# common values set for this target
+#
+#CCWARN= -Wall
+CCWARN= -Wall -Wextra -pedantic
+WNO_IMPLICT= -Wno-implicit
+WNO_ERROR_LONG_LONG= -Wno-error=long-long
+WNO_LONG_LONG= -Wno-long-long
+CCWERR=
+CCOPT= ${DEBUG}
+CCMISC=
+LCC= gcc
+CC= ${PURIFY} ${LCC} ${CCWERR}
+
+# We must use gmake as the FreeBSD target because under some older
+# releases of FreeBSD, make not support conditional syntax.
+#
+MAKE= gmake
+
+endif	# ($(target),FreeBSD)
+
+
+##################
+# OpenBSD target #
+##################
+
+ifeq ($(target),OpenBSD)
+
+# default build type for this target
+#
+BLD_TYPE= calc-dynamic-only
+
+# default build type for this target
+#
+CC_SHARE= -fPIC
+DEFAULT_LIB_INSTALL_PATH= ${PWD}:/lib:/usr/lib:${LIBDIR}:${PREFIX}/lib
+LD_SHARE= "-Wl,-rpath,${DEFAULT_LIB_INSTALL_PATH}" \
+    "-Wl,-rpath-link,${DEFAULT_LIB_INSTALL_PATH}"
+LIBCALC_SHLIB= -shared "-Wl,-soname,libcalc${LIB_EXT_VERSION}"
+LIBCUSTCALC_SHLIB= -shared "-Wl,-soname,libcustcalc${LIB_EXT_VERSION}"
+
+# static library option
+#
+CC_STATIC=
+LD_STATIC=
+LIBCALC_STATIC=
+LIBCUSTCALC_STATIC=
+
+# common values set for this target
+#
+#CCWARN= -Wall
+CCWARN= -Wall -Wextra -pedantic
+WNO_IMPLICT= -Wno-implicit
+WNO_ERROR_LONG_LONG= -Wno-error=long-long
+WNO_LONG_LONG= -Wno-long-long
+CCWERR=
+CCOPT= ${DEBUG}
+CCMISC=
+#
+LCC= gcc
+CC= ${PURIFY} ${LCC} ${CCWERR}
+#
+MAKE= gmake
+#
+endif	# ($(target),OpenBSD)
+
+
+#################
+# Cygwin target #
+#################
+
+ifeq ($(target),Cygwin)
+
+BLD_TYPE= calc-static-only
+
+# target specific library parameters
+#
+CC_SHARE= -fPIC
+DEFAULT_LIB_INSTALL_PATH= ${PWD}:/lib:/usr/lib:${LIBDIR}:${PREFIX}/lib
+LD_SHARE= "-Wl,-rpath,${DEFAULT_LIB_INSTALL_PATH}" \
+    "-Wl,-rpath-link,${DEFAULT_LIB_INSTALL_PATH}"
+LIBCALC_SHLIB= -shared "-Wl,-soname,libcalc${LIB_EXT_VERSION}"
+LIBCUSTCALC_SHLIB= -shared "-Wl,-soname,libcustcalc${LIB_EXT_VERSION}"
+
+# static library option
+#
+CC_STATIC=
+LIBCALC_STATIC=
+LIBCUSTCALC_STATIC=
+LD_STATIC=
+
+# common values set for this target
+#
+#CCWARN= -Wall
+CCWARN= -Wall -Wextra -pedantic
+WNO_IMPLICT= -Wno-implicit
+WNO_ERROR_LONG_LONG= -Wno-error=long-long
+WNO_LONG_LONG= -Wno-long-long
+CCWERR=
+CCOPT= ${DEBUG}
+CCMISC=
+LCC= cc
+CC= ${PURIFY} ${LCC} ${CCWERR}
+
+endif	# ($(target),Cygwin)
+
+
+###########################################
+# default target - (when target is empty) #
+###########################################
+
+# NOTE: This is the default generic host target.  Used when no other
+#	host target matches.
+
+ifeq ($(target),)
+
+# default build type for this target
+#
+BLD_TYPE= calc-static-only
+
+# target specific library parameters
+#
+CC_SHARE= -fPIC
+DEFAULT_LIB_INSTALL_PATH= ${PWD}:/lib:/usr/lib:${LIBDIR}:${PREFIX}/lib
+LD_SHARE= "-Wl,-rpath,${DEFAULT_LIB_INSTALL_PATH}" \
+    "-Wl,-rpath-link,${DEFAULT_LIB_INSTALL_PATH}"
+LIBCALC_SHLIB= -shared "-Wl,-soname,libcalc${LIB_EXT_VERSION}"
+LIBCUSTCALC_SHLIB= -shared "-Wl,-soname,libcustcalc${LIB_EXT_VERSION}"
+
+# static library option
+#
+CC_STATIC=
+LIBCALC_STATIC=
+LIBCUSTCALC_STATIC=
+LD_STATIC=
+
+# common values set for this target
+#
+#CCWARN= -Wall
+CCWARN= -Wall -Wextra -pedantic
+WNO_IMPLICT= -Wno-implicit
+WNO_ERROR_LONG_LONG= -Wno-error=long-long
+WNO_LONG_LONG= -Wno-long-long
+CCWERR=
+CCOPT= ${DEBUG}
+CCMISC=
+LCC= gcc
+CC= ${PURIFY} ${LCC} ${CCWERR}
+
+endif	# ($(target),)
+
+
+###########################################
+# Set the default compile flags for ${CC} #
+###########################################
+
+# If you want to add flags to all compiler and linker
+# run (via ${COMMON_CFLAGS} and ${COMMON_LDFLAGS}),
+# set ${COMMON_ADD}.
+#
+# For example to use gcc's -Werror to force warnings
+# to become errors, call make with:
+#
+#   make .. COMMON_ADD='-Werror'
+#
+# This facility requires a Gnu Makefile, or a make command
+# that understands the += make operand.
+#
+COMMON_CFLAGS+= ${COMMON_ADD}
+COMMON_LDFLAGS+= ${COMMON_ADD}
+
+# Required flags to compile C files for calc
+#
+# ICFLAGS are given to ${CC} for intermediate programs used to help compile calc
+# CFLAGS are given to ${CC} for calc programs other than intermediate programs
+#
+# NOTE: This does not work for: make-XYZ-only and BLD_TYPE != make-XYZ-only
+#
+ifeq ($(BLD_TYPE),calc-static-only)
+ICFLAGS= ${COMMON_CFLAGS} ${CCBAN} ${CC_STATIC}
+else	# ($(BLD_TYPE),calc-static-only)
+ICFLAGS= ${COMMON_CFLAGS} ${CCBAN} ${CC_SHARE}
+endif	# ($(BLD_TYPE),calc-static-only)
+CFLAGS= ${ICFLAGS} ${CCOPT}
+
+# Required flags to link files for calc
+#
+# ILDFLAGS for ${CC} in linking intermediate programs used to help compile calc
+# LDFLAGS for ${CC} in linking calc programs other than intermediate programs
+#
+ILDFLAGS= ${COMMON_LDFLAGS}
+LDFLAGS= ${LD_DEBUG} ${ILDFLAGS}
+
+#######################################################################
+#-=-=-=-=-=- end of target section - only make rules below -=-=-=-=-=-#
+#######################################################################

QUESTIONS

@@ -0,0 +1,45 @@
+If you have a general question about calc, consider opening
+a new Github discussion under:
+
+        https://github.com/lcn2/calc/discussions
+
+Look over the existing discussions to see of your question fits
+under one of those exiting discussions.
+
+You may wish to add your question as a comment to an existing discussion.
+Otherwise click on:
+
+    ((New discussion))
+
+and ask your question in that new discussion.
+
+Please limit your questions to general questions about calc.  We
+cannot go into great detail in our answers, nor can we do your
+homework, nor can we do much more than answer general questions
+about calc.
+
+Please be patient as we cannot always respond to discussion messages quickly.
+
+=-=
+
+## Copyright (C) 2021,2023  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.
+##
+## Under source code control:   2021/02/10 00:15:05
+## File existed as early as:    2021
+##
+## chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+## Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/

README.FIRST

@@ -4,7 +4,7 @@ See the HOWTO.INSTALL file for information on how to build and install calc.
 
 To be sure that your version of calc is up to date, check out:
 
-	http://reality.sgi.com/chongo/tech/comp/calc/calc-download.html
+        http://www.isthe.com/chongo/tech/comp/calc/calc-download.html
 
 We are interested in any/all feedback on recent versions of calc.
 In particular we would like to hear about:
@@ -27,35 +27,35 @@ If you run into problems, see the BUGS file.
 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
+installed calc.  In these examples, the "; " is the calc prompt, not
 something that you type in.
 
 For list of help topics:
 
-    > help
+    ; help
 
 For overview of calc overview:
 
-    > help intro
-    > help overview
-    > help command
-    > help define
-    > help statement
-    > help variable
-    > help usage
+    ; help intro
+    ; help overview
+    ; help command
+    ; help define
+    ; help statement
+    ; help variable
+    ; help usage
 
 For list of builtin functions:
 
-    > help builtin
+    ; help builtin
 
-C programmers should note some unexpected differences in the calc syntax:
+C programmers should note some unexpected differences with the calc syntax:
 
-    > help unexpected
+    ; help unexpected
 
 Calc is shipped with a standard collection of calc resource files.
 For a list of calc standard resource files see:
 
-    > help resource
+    ; help resource
 
 =-=
 
@@ -71,36 +71,33 @@ or run:
 
 for a wish/todo list.  Code contributions are welcome.
 
-=-=
+-=-
 
-To join the calc-tester mailing list.  Send a request to:
+If you you notice something wrong, strange or broken, see the file:
 
-    calc-tester-request at postofc dot corp dot sgi dot com
+    BUGS
 
-    [[ Replace 'at' with @, 'dot' is with . and remove the spaces ]]
+or run:
 
-Your message body (not the subject) should consist of:
+    calc help bugs
 
-     subscribe calc-tester address
-     end
-     name your_full_name
+for information about how to report a bug.
 
-where ``address'' is your EMail address and ``your_full_name'' is
-your full name.
+-=-
 
-Calc bug reports, however should be sent to:
+If you have a general question about calc, see the file:
 
-    calc-bugs at postofc dot corp dot sgi dot com
+    QUESTIONS
 
-    [[ Replace 'at' with @, 'dot' is with . and remove the spaces ]]
+or run:
 
-but see the BUGS file first.
+    calc help questions
 
-The calc web site is located at:
+for information about how to ask a question.
 
-	http://reality.sgi.com/chongo/tech/comp/calc/
+-=-
 
-## Copyright (C) 1999  Landon Curt Noll
+## Copyright (C) 1999,2014,2017,2021  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
@@ -108,20 +105,16 @@ The calc web site is located at:
 ##
 ## 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
+## 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.
-## 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+## 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 ##
-## @(#) $Revision: 29.1 $
-## @(#) $Id: README,v 29.1 1999/12/14 09:15:29 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
 ##
-## Under source code control:	1995/10/25 05:27:59
-## File existed as early as:	1995
-##
-## chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
-## Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+## chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+## Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/

README.RELEASE

@@ -0,0 +1,158 @@
+On calc versions and releases
+
+Calc version numbers have 4 levels.  For example:
+
+         ++=== top 2 levels: calc builtin functions compatibility
+         ||
+        vvvv
+
+        2.14.0.8
+         \\\\\\
+        ^  \\\\----> top 3 levels: calc important code base change
+        |
+        +--- top version level: internal representation compatibility
+
+The top version level (e.g., 2) refers to the internal representation
+of values.  Any library or hardware linked/built for calc 2 will be able
+to use values from other 2.x.y.z versions.
+
+The top 2 levels (e.g., 2.14) refers to a specific compatible set of
+builtin functions.  Calc interpreted code (such as calc resource files)
+written for, say calc 2.14, will be able to use the same set of builtin
+functions for any other 2.14.y.z version.  Any new builtin functions or
+significant changes to existing builtin functions would be introduced in
+a later release such as version 2.15.y.z.  While calc scripts written for
+2.14.y.z will highly likely be able to run under version 2.15.y.z, any
+new builtin functions added in calc 2.15 may collide with an identically
+named used defined function.
+
+The top 3 levels (e.g., 2.14.0) change to reflect an important change to
+the code base such as a bug fix or performance improvement.  There was
+neither a change to the internal representation format (a top level
+version change), nor were there new calc builtins introduced in such
+a top 3 level release.
+
+
+The file, "version.h" defines the 4 version levels:
+
+    MAJOR_VER           /* level 1: major library version */
+    MINOR_VER           /* level 2: minor library version */
+    MAJOR_PATCH         /* level 3: major software version level */
+    MINOR_PATCH         /* level 4: minor software version level */
+
+
+The program "ver_calc" will print information about the compiled
+calc version as defined "version.h" when "ver_calc" was compiled:
+
+    usage: ./ver_calc [-h] [-V]
+
+        -h      print this message and exit non-zero
+        -V      print 3-level version (def: print 4-level version)
+
+Also "calc -v" will print the calc version as defined "version.h" when
+"calc" was compiled.
+
+The master branch:
+
+    The public repository of calc source code is:
+
+        http://github.com/lcn2/calc
+
+    On that GitHub site you may find released version of calc,
+    "production", "tested" and "alpha".  All commits on the master
+    branch that are not associated with a release are "alpha".
+
+    Any "alpha" commit is likely future code for a future
+    "tested" or "production" version of calc.
+
+alpha           ==> untagged GitHub commit
+
+        Any untagged commit to the GitHub master branch should be
+        considered as alpha code that may make calc unstable.
+
+        While we try to avoid breaking the calc code with commits,
+        there is a risk that picking up such a change could
+        negatively impact the code.
+
+        NOTE: The calc version found in "version.h", and printed
+              by both "ver_calc [-V]" and "calc -v" for an untagged
+              commit is the previous "tested" or "production" version
+              of calc.  Any "alpha" changes that remain are code
+              for some future version of calc.
+
+              At the last stage of the release process, "version.h"
+              will be updated as well as the top level version range
+              listed in "CHANGES".
+
+tested          ==> tagged GitHub pre-release commit
+
+        A new version of calc has been released and has recently passed
+        regression testing on at least to different platforms and chip
+        architectures.
+
+        The "tested" class was historically called "untested",
+        however this term was misleading as such releases ARE tested.
+        Since 2.14.0.13 we have used the term "tested".
+
+        All tested releases are tagged with a new version number.
+        Such releases have GitHub assets such as a source tarball,
+        zip file, source rpm, development rpm and binary rpm.  See the
+        orange "Pre-release" GitHub releases under:
+
+            https://github.com/lcn2/calc/releases
+
+         At the bottom of a given release is a "> Assets" that may
+         be opened to reveal down-loadable files.
+
+production      ==> tagged GitHub release commit
+
+        A new version of calc has been released and has undergone
+        extensive testing over time over a number of platforms.
+        Sometimes a "tested" release that is found work well over
+        a period of time will be re-released with a new version
+        number as a "production" release.
+
+        The latest production GitHub release is marked with green
+        "Latest" label under:
+
+            https://github.com/lcn2/calc/releases
+
+        A release that has neither an orange "Pre-release" nor
+        a green "Latest" label is a prior production class release.
+
+        At the bottom of a given release is a "> Assets" that may
+        be opened to reveal down-loadable files.
+
+        Production class code where stability is critical should use a
+        "production" release.
+
+A historical note and apology:
+
+    In the past, some version number changes were made that did not
+    fully reflect the above version number or change class.  Moreover
+    older terms such as "stable" and "unstable" were misleading and
+    did not properly reflect the nature of the change.  Sorry!  The
+    purpose of this document is to try and bring a better level of
+    conformity to source code updates, tagged releases and version numbers.
+
+## Copyright (C) 2021,2023  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.
+##
+## Under source code control:   2021/12/12 19:36:26
+## File existed as early as:    2021
+##
+## chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+## Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/

README.WINDOWS

@@ -0,0 +1,183 @@
+Dear calc user on a Windows based system,
+
+See the HOWTO.INSTALL file for information on how to build and install calc.
+See also the README file.
+
+     Please also add notes to the 'Compiling calc under Windows 11'
+     and 'Compiling with Cygwin' section in README.WINDOWS file.
+
+NOTE: The main developers do not have access to a Windows based platform.
+      While we will make an effort to not break calc Windows based system,
+      our lack of a Windows test environment will mean we will make mistakes
+      from time to time.  Hopefully Windows users can overcome these mistakes.
+      Of course you are welcome to send us any patches that fix your
+      Windows build environment.
+
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+=-= Compiling calc under Windows 11 =-=
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+BTW: While we are unable to use Windows 11, we welcome Windows 11
+     developers to try compiling calc natively (instead of via a Linux
+     virtual machine).  If you are able to compile Windows 11 natively,
+     we would welcome GitHub pull requests showing any needed modifications:
+
+        https://github.com/lcn2/calc/pulls
+
+We were given this advice from a Windows 11 developer:
+
+    Windows 11 users could use Cygwin:
+
+        https://cygwin.com/install.html
+
+    IMPORTANT: While installing Cygwin, and during Cygwin Setup, be sure to
+               select all the MinGW64 packages relating to gcc.
+
+               See the "Compiling with Cygwin" section below.
+
+NOTE: Compiling calc under Windows 11 is work in progress.  If you run into
+      problems, consider the "Compiling with Cygwin" section below.
+
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=
+=-= Compiling with Msys =-=
+=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+The MSYS2 Software Distribution and Building Platform for Windows:
+
+    https://www.msys2.org
+
+is a fork of Cygwin.  In `Makefile.config`, when the OSNAME is "Msys",
+the Cygwin target it set.  MSYS2 Software Distribution users should be
+sure that the following command prints "Msys".
+
+    uname -o
+
+Or call make with OSNAME set as in:
+
+    make ... OSNAME=Msys
+
+Follow the "Compiling with Cygwin" instructions below.
+
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+=-= 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 Unix tools for Windows.
+
+The major porting work for Cygwin was performed by Thomas Jones-Low
+(tjoneslo at softstart dot com).
+
+In December 2022, GitHub user @Leoongithub successfully compiled
+calc-2.14.1.2 under cygwin 2.924 (64 bit). The following are the
+compilation steps that GitHub user @Leoongithub recommends:
+
+0. Install the latest version of cygwin (https://cygwin.com/install.html).
+
+    NOTE: In addition to the default packages, you also need to check these
+          three packages: gcc-core, make, and libreadline-devel. The version
+          of these packages does not matter. Just choose the latest version.
+
+    NOTE: The addition of "target=Cygwin" to make commands below
+          is done just in case the target is not set properly by make.
+
+1. Change (cd) into the top of the source code directory of calc.
+
+   NOTE: The make command assume you are at the top of the calc source directory.
+
+2. make clobber target=Cygwin
+
+   NOTE: This helps ensure that you are starting from a so-called "clean slate",
+         and that you have nothing hanging around from previous attempts to compile.
+
+3. make all target=Cygwin
+
+   NOTE: If successful, you should have a calc executable.  However that executable
+         may not be working properly.  Advance to step (4) to test.
+
+4. make chk target=Cygwin
+
+   NOTE: If you want this command be be verbose, try:
+
+            make check target=Cygwin
+
+   NOTE: This will run calc with the regress.cal regression suite.  This step could take
+         for a while to run, depending on the speed/performance of your machine.
+         If all is well (all regression tests pass), you will see at the end:
+
+            chk OK
+
+         Otherwise you may see calc exit non-zero after it prints some lines with '****'
+         error messages followed by a line including a final error count of the form:
+
+           **** 2 error(s) found  \/++\/
+
+         If you see some errors that may relate to files and I/O, all may not be lost.
+         It could simply mean that your Windows environment is not conforming to standard
+         I/O and file operations.  The calc mathematical engine may be just fine.  On the
+         other hand if you see mathematical related regression test failures, this is
+         bad sign that your calc executable under Windows is not usable.
+
+5. make install target=Cygwin
+
+   NOTE: This step is optional.  While calc is usable at the top of the source code directory
+         of calc, installing calc may be of benefit so you can use calc elsewhere on your system.
+
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+=-= Compiling calc via virtual machine under Windows 11 =-=
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+We would prefer a Windows 11 solution that does not require a Windows 11
+developer to install a Linux virtual machine.  Nevertheless, a Windows 11
+user might want to use the Microsoft Windows Subsystem (WSL) for Linux:
+
+        https://docs.microsoft.com/en-us/windows/wsl/
+
+    We have been told that you will need to turn on virtualization
+    to use this WSL subsystem.
+
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+=-= Compiling calc under Windows 10 via Windows Subsystem for Linux (WSL) =-=
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+It has been reported that calc version 2.12.6.4 has been successfully
+compiled, installed and running on Windows 10 on 2018 Jan 21.
+
+We were told:
+
+  "The Windows Subsystem for Linux (WSL) is a new Windows 10 feature that
+   enables you to run native Linux command-line tools directly on Windows"
+
+   https://docs.microsoft.com/cs-cz/windows/wsl/about
+
+NOTE: The use of calc under Windows 10 has been deprecated in favor of one
+      of the Windows 11 methods above.
+
+
+## Copyright (C) 2002-2009,2021-2023  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.
+##
+## 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/

README.md

@@ -0,0 +1,290 @@
+# TL;DR Try calc
+
+## TL;DR Install calc
+
+```
+misc linux: sudo yum install calc
+on Debian:  sudo apt install calc
+on RHEL:    sudo dnf install calc
+on Ubuntu:  sudo apt install calc
+via Termux: apt install calc
+via src:    sudo make clobber all chk install
+```
+
+## TL;DR Run calc
+
+```
+misc shell:   calc
+via bash:     calc
+via misc app: launch calc via Termux
+via zsh:      calc
+```
+
+# What is calc?
+
+Calc is an interactive calculator which provides for easy large
+numeric calculations, but which also can be easily programmed
+for difficult or long calculations.      It can accept a command line
+argument, in which case it executes that single command and exits.
+Otherwise, it enters interactive mode.  In this mode, it accepts
+commands one at a time, processes them, and displays the answers.
+In the simplest case, commands are simply expressions which are
+evaluated.  For example, the following line can be input:
+
+```sh
+3 * (4 + 1)
+```
+
+and the calculator will print:
+
+```sh
+15
+```
+
+Calc has the usual collection of arithmetic operators +, -, /, * as
+well as ^ (exponentiation), % (modulus) and // (integer divide).
+For example:
+
+```sh
+3 * 19^43 - 1
+```
+
+will produce:
+
+```sh
+29075426613099201338473141505176993450849249622191102976
+```
+
+Notice that calc values can be very large.  For example:
+
+```sh
+2^23209-1
+```
+
+will print:
+
+```sh
+402874115778988778181873329071 ... many digits ... 3779264511
+```
+
+The special '.' symbol (called dot), represents the result of the
+last command expression, if any.  This is of great use when a series
+of partial results are calculated, or when the output mode is changed
+and the last result needs to be redisplayed.  For example, the above
+result can be modified by typing:
+
+```sh
+. % (2^127-1)
+```
+
+and the calculator will print:
+
+```sh
+47385033654019111249345128555354223304
+```
+
+For more complex calculations, variables can be used to save the
+intermediate results.  For example, the result of adding 7 to the
+previous result can be saved by typing:
+
+```sh
+curds = 15
+whey = 7 + 2*curds
+```
+
+Functions can be used in expressions.  There are a great number of
+pre-defined functions.  For example, the following will calculate
+the factorial of the value of 'whey':
+
+```sh
+fact(whey)
+```
+
+and the calculator prints:
+
+```sh
+13763753091226345046315979581580902400000000
+```
+
+The calculator also knows about complex numbers, so that typing:
+
+```sh
+(2+3i) * (4-3i)
+cos(.)
+```
+
+will print:
+
+```sh
+17+6i
+-55.50474777265624667147+193.9265235748927986537i
+```
+
+The calculator can calculate transcendental functions, and accept and
+display numbers in real or exponential format. For example, typing:
+
+```sh
+config("display", 70),
+epsilon(1e-70),
+sin(1)
+```
+
+prints:
+
+```sh
+0.8414709848078965066525023216302989996225630607983710656727517099919104
+```
+
+Calc can output values in terms of fractions, octal or hexadecimal.
+For example:
+
+```sh
+config("mode", "fraction"),
+(17/19)^23
+print
+base(16),
+(19/17)^29
+print
+log(79.3i)
+```
+
+ will print:
+
+```sh
+19967568900859523802559065713/257829627945307727248226067259
+
+0x9201e65bdbb801eaf403f657efcf863/0x5cd2e2a01291ffd73bee6aa7dcf7d1
+
+0x17b5164ac24ee836bf/0xc7b7a8e3ef5fcf752+0x883eaf5adadd26be3/0xc7b7a8e3ef5fcf752i
+```
+
+All numbers are represented as fractions with arbitrarily large
+numerators and denominators which are always reduced to lowest terms.
+Real or exponential format numbers can be input and are converted
+to the equivalent fraction.  Hex, binary, or octal numbers can be
+input by using numbers with leading '0x', '0b' or '0' characters.
+Complex numbers can be input using a trailing 'i', as in '2+3i'.
+Strings and characters are input by using single or double quotes.
+
+Commands are statements in a C-like language, where each input
+line is treated as the body of a procedure.  Thus the command
+line can contain variable declarations, expressions, labels,
+conditional tests, and loops.  Assignments to any variable name
+will automatically define that name as a global variable.  The
+other important thing to know is that all non-assignment expressions
+which are evaluated are automatically printed.  Thus, you can evaluate
+an expression's value by simply typing it in.
+
+Many useful built-in mathematical functions are available.  Use the:
+
+```sh
+help builtin
+```
+
+command to list them.
+
+You can also define your own functions by using the 'define' keyword,
+followed by a function declaration very similar to C.
+
+```sh
+define f2(n)
+{
+        local ans;
+
+        ans = 1;
+        while (n > 1)
+                ans *= (n -= 2);
+        return ans;
+}
+```
+
+Thus the input:
+
+```sh
+f2(79)
+```
+
+will produce:
+
+```sh
+1009847364737869270905302433221592504062302663202724609375
+```
+
+Functions which only need to return a simple expression can be defined
+using an equals sign, as in the example:
+
+```sh
+define sc(a,b) = a^3 + b^3
+```
+
+Thus the input:
+
+```sh
+sc(31, 61)
+```
+
+will produce:
+
+```sh
+256772
+```
+
+Variables in functions can be defined as either 'global', 'local',
+or 'static'.  Global variables are common to all functions and the
+command line, whereas local variables are unique to each function
+level, and are destroyed when the function returns.  Static variables
+are scoped within single input files, or within functions, and are
+never destroyed.  Variables are not typed at definition time, but
+dynamically change as they are used.
+
+For more information about the calc language and features, try:
+
+```sh
+help overview
+```
+
+Calc has a help command that will produce information about
+every builtin function, command as well as a number of other
+aspects of calc usage.  Try the command:
+
+```sh
+help help
+```
+
+for and overview of the help system.  The command:
+
+```sh
+help builtin
+```
+
+provides information on built-in mathematical functions, whereas:
+
+```sh
+help asinh
+```
+
+will provides information a specific function.  The following
+help files:
+
+```sh
+help command
+help define
+help operator
+help statement
+help variable
+```
+
+provide a good overview of the calc language.  If you are familiar
+with C, you should also try:
+
+```sh
+help unexpected
+```
+
+It contains information about differences between C and calc
+that may surprise C programmers.
+
+
+# Reporting Security Issues
+
+To report a security issue, please visit "[Reporting Security Issues](https://github.com/lcn2/calc/security/policy)".

SECURITY.md

@@ -0,0 +1,23 @@
+# Reporting Security Issues
+
+We take security bugs seriously.  We appreciate your efforts to responsibly
+disclose your findings, and will make every effort to acknowledge your
+contributions for any verified security issues when they have been fixed.
+
+To report a security issue, click on: "[Open a draft security advisory](https://github.com/lcn2/calc/security/advisories/new)"
+
+We will send a response indicating the next steps in handling your
+report. After the initial reply to your report, we will keep you informed
+of the progress towards a fix and full announcement, and may ask for
+additional information or guidance.
+
+
+## Supported Versions
+
+The most recent version of calc is supported with security updates.
+
+If the most recent stable of calc is also supported with security updates.
+
+FYI: please review the BUGS file, or enter the calc command:
+
+    ; help BUGS

align32.c

@@ -1,7 +1,7 @@
 /*
  * align32 - determine if 32 bit accesses must be aligned
  *
- * Copyright (C) 1999  Landon Curt Noll
+ * Copyright (C) 1999,2021  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
@@ -9,28 +9,29 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: align32.c,v 29.1 1999/12/14 09:15:29 chongo Exp $
- * @(#) $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
  *
- * Under source code control:	1995/11/23 05:18:06
- * File existed as early as:	1995
- *
- * chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * 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 "have_stdlib.h"
+#if defined(HAVE_STDLIB_H)
+#include <stdlib.h>
+#endif
+
 #include "longbits.h"
 
 #include "have_unistd.h"
@@ -38,39 +39,45 @@
 #include <unistd.h>
 #endif
 
-static void buserr(void);	/* catch alignment errors */
+#include "have_unused.h"
+
+
+#include "banned.h"     /* include after system header <> includes */
+
+
+static void buserr(int arg);    /* catch alignment errors */
 
 
 int
 main(void)
 {
-	char byte[2*sizeof(USB32)];	/* mis-alignment buffer */
-	USB32 *p;			/* mis-alignment pointer */
-	int i;
+        char byte[2*sizeof(USB32)];     /* mis-alignment buffer */
+        USB32 *p;                       /* mis-alignment pointer */
+        unsigned long i;
 
 #if defined(MUST_ALIGN32)
-	/* force alignment */
-	printf("#define MUST_ALIGN32\t%c* forced to align 32 bit values *%c\n",
-	   '/', '/');
+        /* force alignment */
+        printf("#define MUST_ALIGN32\t%c* forced to align 32 bit values *%c\n",
+           '/', '/');
 #else
-	/* setup to catch alignment bus errors */
-	signal(SIGBUS, buserr);
-	signal(SIGSEGV, buserr);  /* some systems will generate SEGV instead! */
+        /* setup to catch alignment bus errors */
+        signal(SIGBUS, buserr);
+        signal(SIGSEGV, buserr);  /* some systems will generate SEGV instead! */
 
-	/* mis-align our long fetches */
-	for (i=0; i < sizeof(USB32); ++i) {
-		p = (USB32 *)(byte+i);
-		*p = i;
-		*p += 1;
-	}
+        /* mis-align our long fetches */
+        for (i=0; i < sizeof(USB32); ++i) {
+                p = (USB32 *)(byte+i);
+                *p = i;
+                *p += 1;
+        }
 
-	/* if we got here, then we can mis-align longs */
-	printf("#undef MUST_ALIGN32\t%c* can mis-align 32 bit values *%c\n",
-	   '/', '/');
+        /* if we got here, then we can mis-align longs */
+        printf("#undef MUST_ALIGN32\t%c* can mis-align 32 bit values *%c\n",
+           '/', '/');
 
 #endif
-	/* exit(0); */
-	return 0;
+        /* exit(0); */
+        return 0;
 }
 
 
@@ -78,14 +85,14 @@ main(void)
  * buserr - catch an alignment error
  *
  * given:
- *	arg		to keep ANSI C happy
+ *      arg             to keep ANSI C happy
  */
 /*ARGSUSED*/
 static void
-buserr(int arg)
+buserr(int UNUSED(arg))
 {
-	/* alignment is required */
-	printf("#define MUST_ALIGN32\t%c* must align 32 bit values *%c\n",
-	  '/', '/');
-	exit(0);
+        /* alignment is required */
+        printf("#define MUST_ALIGN32\t%c* must align 32 bit values *%c\n",
+          '/', '/');
+        exit(0);
 }

alloc.h

@@ -1,7 +1,7 @@
 /*
  * alloc - storage allocation and storage debug macros
  *
- * Copyright (C) 1999  David I. Bell
+ * Copyright (C) 1999-2007,2014,2025  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
@@ -9,71 +9,62 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: alloc.h,v 29.1 1999/12/14 09:15:29 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
  *
- * Under source code control:	1990/02/15 01:48:29
- * File existed as early as:	before 1990
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 
-#if !defined(__ALLOC_H__)
-#define __ALLOC_H__
+#if !defined(INCLUDE_ALLOC_H)
+#define INCLUDE_ALLOC_H
 
 
-#include "have_malloc.h"
-#include "have_newstr.h"
-#include "have_string.h"
-#include "have_memmv.h"
-
-#ifdef HAVE_MALLOC_H
-# include <malloc.h>
+#if defined(CALC_SRC)   /* if we are building from the calc source tree */
+# include "decl.h"
+# include "have_newstr.h"
+# include "have_string.h"
+# include "have_const.h"
 #else
-#if defined(FORCE_STDC) || (defined(__STDC__) && __STDC__ != 0) || defined(__cplusplus)
-   extern void *malloc();
-   extern void *realloc();
-   extern void free();
-# else
-   extern char *malloc();
-   extern char *realloc();
-   extern void free();
-# endif
+# include <calc/decl.h>
+# include <calc/have_newstr.h>
+# include <calc/have_string.h>
+# include <calc/have_const.h>
 #endif
 
 #ifdef HAVE_STRING_H
 # include <string.h>
 
 #else
+#include <stdio.h>
 
 # if defined(HAVE_NEWSTR)
-extern void *memcpy();
-extern void *memset();
-#if defined(FORCE_STDC) || (defined(__STDC__) && __STDC__ != 0) || defined(__cplusplus)
-extern size_t strlen();
+E_FUNC void *memcpy();
+E_FUNC void *memset();
+#if defined(FORCE_STDC) || \
+   (defined(__STDC__) && __STDC__ != 0) || defined(__cplusplus)
+E_FUNC size_t strlen();
 #  else
-extern long strlen();
+E_FUNC long strlen();
 #  endif
 # else /* HAVE_NEWSTR */
-extern void bcopy();
-extern void bfill();
-extern char *index();
+E_FUNC void bcopy();
+E_FUNC void bfill();
+E_FUNC char *index();
 # endif /* HAVE_NEWSTR */
-extern char *strchr();
-extern char *strcpy();
-extern char *strncpy();
-extern char *strcat();
-extern int strcmp();
+E_FUNC char *strchr();
+E_FUNC char *strcpy();
+E_FUNC char *strncpy();
+E_FUNC char *strcat();
+E_FUNC int strcmp();
 
 #endif
 
@@ -86,14 +77,4 @@ extern int strcmp();
 #define strchr(s, c) index(s, c)
 #endif /* HAVE_NEWSTR */
 
-#if !defined(HAVE_MEMMOVE)
-# undef CALC_SIZE_T
-#if defined(FORCE_STDC) || (defined(__STDC__) && __STDC__ != 0) || defined(__cplusplus)
-#  define CALC_SIZE_T size_t
-# else
-#  define CALC_SIZE_T long
-# endif
-extern void *memmove(void *s1, const void *s2, CALC_SIZE_T n);
-#endif
-
-#endif /* !__ALLOC_H__ */
+#endif /* !INCLUDE_ALLOC_H */

assocfunc.c

@@ -1,7 +1,7 @@
 /*
  * assocfunc - association table routines
  *
- * Copyright (C) 1999  David I. Bell
+ * Copyright (C) 1999-2007,2021-2023  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
@@ -9,22 +9,18 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: assocfunc.c,v 29.1 1999/12/14 09:15:29 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
  *
- * Under source code control:	1993/07/20 23:04:27
- * File existed as early as:	1993
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -40,94 +36,98 @@
 #include "value.h"
 
 
-#define MINHASHSIZE	31	/* minimum size of hash tables */
-#define GROWHASHSIZE	50	/* approximate growth for hash tables */
-#define CHAINLENGTH	10	/* desired number of elements on a hash chain */
-#define ELEMSIZE(n)	(sizeof(ASSOCELEM) + (sizeof(VALUE) * ((n) - 1)))
+#include "errtbl.h"
+#include "banned.h"     /* include after system header <> includes */
 
 
-static ASSOCELEM *elemindex(ASSOC *ap, long index);
-static BOOL compareindices(VALUE *v1, VALUE *v2, long dim);
-static void resize(ASSOC *ap, long newsize);
-static void assoc_elemfree(ASSOCELEM *ep);
+#define MINHASHSIZE     31      /* minimum size of hash tables */
+#define GROWHASHSIZE    50      /* approximate growth for hash tables */
+#define CHAINLENGTH     10      /* desired number of elements on a hash chain */
+#define ELEMSIZE(n)     (sizeof(ASSOCELEM) + (sizeof(VALUE) * ((n) - 1)))
+
+
+S_FUNC ASSOCELEM *elemindex(ASSOC *ap, long index);
+S_FUNC bool compareindices(VALUE *v1, VALUE *v2, long dim);
+S_FUNC void resize(ASSOC *ap, long newsize);
+S_FUNC void assoc_elemfree(ASSOCELEM *ep);
 
 
 /*
  * Return the address of the value specified by normal indexing of
- * an association.  The create flag is TRUE if a value is going to be
- * assigned into the specified indexing location.  If create is FALSE and
+ * an association.  The create flag is true if a value is going to be
+ * assigned into the specified indexing location.  If create is false and
  * the index value doesn't exist, a pointer to a NULL value is returned.
  *
  * given:
- *	ap		association to index into
- *	create		whether to create the index value
- *	dim		dimension of the indexing
- *	indices		table of values being indexed by
+ *      ap              association to index into
+ *      create          whether to create the index value
+ *      dim             dimension of the indexing
+ *      indices         table of values being indexed by
  */
 VALUE *
-associndex(ASSOC *ap, BOOL create, long dim, VALUE *indices)
+associndex(ASSOC *ap, bool create, long dim, VALUE *indices)
 {
-	ASSOCELEM **listhead;
-	ASSOCELEM *ep;
-	static VALUE val;
-	QCKHASH hash;
-	int i;
+        ASSOCELEM **listhead;
+        ASSOCELEM *ep;
+        STATIC VALUE val;
+        QCKHASH hash;
+        int i;
 
-	if (dim < 0) {
-		math_error("Negative dimension for indexing association");
-		/*NOTREACHED*/
-	}
+        if (dim < 0) {
+                math_error("Negative dimension for indexing association");
+                not_reached();
+        }
 
-	/*
-	 * Calculate the hash value to use for this set of indices
-	 * so that we can first select the correct hash chain, and
-	 * also so we can quickly compare each element for a match.
-	 */
-	hash = FNV1_32_BASIS;
-	for (i = 0; i < dim; i++)
-		hash = hashvalue(&indices[i], hash);
+        /*
+         * Calculate the hash value to use for this set of indices
+         * so that we can first select the correct hash chain, and
+         * also so we can quickly compare each element for a match.
+         */
+        hash = QUICKHASH_BASIS;
+        for (i = 0; i < dim; i++)
+                hash = hashvalue(&indices[i], hash);
 
-	/*
-	 * Search the correct hash chain for the specified set of indices.
-	 * If found, return the address of the found element's value.
-	 */
-	listhead = &ap->a_table[hash % ap->a_size];
-	for (ep = *listhead; ep; ep = ep->e_next) {
-		if ((ep->e_hash != hash) || (ep->e_dim != dim))
-			continue;
-		if (compareindices(ep->e_indices, indices, dim))
-			return &ep->e_value;
-	}
+        /*
+         * Search the correct hash chain for the specified set of indices.
+         * If found, return the address of the found element's value.
+         */
+        listhead = &ap->a_table[hash % ap->a_size];
+        for (ep = *listhead; ep; ep = ep->e_next) {
+                if ((ep->e_hash != hash) || (ep->e_dim != dim))
+                        continue;
+                if (compareindices(ep->e_indices, indices, dim))
+                        return &ep->e_value;
+        }
 
-	/*
-	 * The set of indices was not found.
-	 * Either return a pointer to a NULL value for a read reference,
-	 * or allocate a new element in the list for a write reference.
-	 */
-	if (!create) {
-		val.v_type = V_NULL;
-		val.v_subtype = V_NOSUBTYPE;
-		return &val;
-	}
+        /*
+         * The set of indices was not found.
+         * Either return a pointer to a NULL value for a read reference,
+         * or allocate a new element in the list for a write reference.
+         */
+        if (!create) {
+                val.v_type = V_NULL;
+                val.v_subtype = V_NOSUBTYPE;
+                return &val;
+        }
 
-	ep = (ASSOCELEM *) malloc(ELEMSIZE(dim));
-	if (ep == NULL) {
-		math_error("Cannot allocate association element");
-		/*NOTREACHED*/
-	}
-	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;
-	*listhead = ep;
-	ap->a_count++;
+        ep = (ASSOCELEM *) malloc(ELEMSIZE(dim));
+        if (ep == NULL) {
+                math_error("Cannot allocate association element");
+                not_reached();
+        }
+        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;
+        *listhead = ep;
+        ap->a_count++;
 
-	resize(ap, ap->a_count / CHAINLENGTH);
+        resize(ap, ap->a_count / CHAINLENGTH);
 
-	return &ep->e_value;
+        return &ep->e_value;
 }
 
 
@@ -139,25 +139,25 @@ associndex(ASSOC *ap, BOOL create, long dim, VALUE *indices)
 int
 assocsearch(ASSOC *ap, VALUE *vp, long i, long j, ZVALUE *index)
 {
-	ASSOCELEM *ep;
+        ASSOCELEM *ep;
 
-	if (i < 0 || j > ap->a_count) {
-		math_error("This should not happen in assocsearch");
-		/*NOTREACHED*/
-	}
-	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;
+        if (i < 0 || j > ap->a_count) {
+                math_error("This should not happen in assocsearch");
+                not_reached();
+        }
+        while (i < j) {
+                ep = elemindex(ap, i);
+                if (ep == NULL) {
+                        math_error("This should not happen in assocsearch");
+                        not_reached();
+                }
+                if (acceptvalue(&ep->e_value, vp)) {
+                        utoz(i, index);
+                        return 0;
+                }
+                i++;
+        }
+        return 1;
 }
 
 
@@ -169,26 +169,26 @@ assocsearch(ASSOC *ap, VALUE *vp, long i, long j, ZVALUE *index)
 int
 assocrsearch(ASSOC *ap, VALUE *vp, long i, long j, ZVALUE *index)
 {
-	ASSOCELEM *ep;
+        ASSOCELEM *ep;
 
-	if (i < 0 || j > ap->a_count) {
-		math_error("This should not happen in assocsearch");
-		/*NOTREACHED*/
-	}
-	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;
+        if (i < 0 || j > ap->a_count) {
+                math_error("This should not happen in assocsearch");
+                not_reached();
+        }
+        j--;
+        while (j >= i) {
+                ep = elemindex(ap, j);
+                if (ep == NULL) {
+                        math_error("This should not happen in assocsearch");
+                        not_reached();
+                }
+                if (acceptvalue(&ep->e_value, vp)) {
+                        utoz(j, index);
+                        return 0;
+                }
+                j--;
+        }
+        return 1;
 }
 
 
@@ -197,29 +197,29 @@ assocrsearch(ASSOC *ap, VALUE *vp, long i, long j, ZVALUE *index)
  * double-bracket operation.
  *
  * given:
- *	ap		association to index into
- *	index		index of desired element
+ *      ap              association to index into
+ *      index           index of desired element
  */
-static ASSOCELEM *
+S_FUNC ASSOCELEM *
 elemindex(ASSOC *ap, long index)
 {
-	ASSOCELEM *ep;
-	int i;
+        ASSOCELEM *ep;
+        int i;
 
-	if ((index < 0) || (index > ap->a_count))
-		return NULL;
+        if ((index < 0) || (index > ap->a_count))
+                return NULL;
 
-	/*
-	 * This loop should be made more efficient by remembering
-	 * previously requested locations within the association.
-	 */
-	for (i = 0; i < ap->a_size; i++) {
-		for (ep = ap->a_table[i]; ep; ep = ep->e_next) {
-			if (index-- == 0)
-				return ep;
-		}
-	}
-	return NULL;
+        /*
+         * This loop should be made more efficient by remembering
+         * previously requested locations within the association.
+         */
+        for (i = 0; i < ap->a_size; i++) {
+                for (ep = ap->a_table[i]; ep; ep = ep->e_next) {
+                        if (index-- == 0)
+                                return ep;
+                }
+        }
+        return NULL;
 }
 
 
@@ -228,18 +228,18 @@ elemindex(ASSOC *ap, long index)
  * of an association.  Returns NULL if there is no such element.
  *
  * given:
- *	ap		association to index into
- *	index		index of desired element
+ *      ap              association to index into
+ *      index           index of desired element
  */
 VALUE *
 assocfindex(ASSOC *ap, long index)
 {
-	ASSOCELEM *ep;
+        ASSOCELEM *ep;
 
-	ep = elemindex(ap, index);
-	if (ep == NULL)
-		return NULL;
-	return &ep->e_value;
+        ep = elemindex(ap, index);
+        if (ep == NULL)
+                return NULL;
+        return &ep->e_value;
 }
 
 
@@ -250,64 +250,64 @@ assocfindex(ASSOC *ap, long index)
 LIST *
 associndices(ASSOC *ap, long index)
 {
-	ASSOCELEM *ep;
-	LIST *lp;
-	int i;
+        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;
+        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.
+ * Returns true if they are different.
  */
-BOOL
+bool
 assoccmp(ASSOC *ap1, ASSOC *ap2)
 {
-	ASSOCELEM **table1;
-	ASSOCELEM *ep1;
-	ASSOCELEM *ep2;
-	long size1;
-	long size2;
-	QCKHASH hash;
-	long dim;
+        ASSOCELEM **table1;
+        ASSOCELEM *ep1;
+        ASSOCELEM *ep2;
+        long size1;
+        long size2;
+        QCKHASH hash;
+        long dim;
 
-	if (ap1 == ap2)
-		return FALSE;
-	if (ap1->a_count != ap2->a_count)
-		return TRUE;
+        if (ap1 == ap2)
+                return false;
+        if (ap1->a_count != ap2->a_count)
+                return true;
 
-	table1 = ap1->a_table;
-	size1 = ap1->a_size;
-	size2 = ap2->a_size;
-	while (size1-- > 0) {
-		for (ep1 = *table1++; ep1; ep1 = ep1->e_next) {
-			hash = ep1->e_hash;
-			dim = ep1->e_dim;
-			for (ep2 = ap2->a_table[hash % size2]; ;
-				ep2 = ep2->e_next) {
-				if (ep2 == NULL)
-					return TRUE;
-				if (ep2->e_hash != hash)
-					continue;
-				if (ep2->e_dim != dim)
-					continue;
-				if (compareindices(ep1->e_indices,
-					ep2->e_indices, dim))
-						break;
-			}
-			if (comparevalue(&ep1->e_value, &ep2->e_value))
-				return TRUE;
-		}
-	}
-	return FALSE;
+        table1 = ap1->a_table;
+        size1 = ap1->a_size;
+        size2 = ap2->a_size;
+        while (size1-- > 0) {
+                for (ep1 = *table1++; ep1; ep1 = ep1->e_next) {
+                        hash = ep1->e_hash;
+                        dim = ep1->e_dim;
+                        for (ep2 = ap2->a_table[hash % size2]; ;
+                                ep2 = ep2->e_next) {
+                                if (ep2 == NULL)
+                                        return true;
+                                if (ep2->e_hash != hash)
+                                        continue;
+                                if (ep2->e_dim != dim)
+                                        continue;
+                                if (compareindices(ep1->e_indices,
+                                        ep2->e_indices, dim))
+                                                break;
+                        }
+                        if (comparevalue(&ep1->e_value, &ep2->e_value))
+                                return true;
+                }
+        }
+        return false;
 }
 
 
@@ -317,37 +317,39 @@ assoccmp(ASSOC *ap1, ASSOC *ap2)
 ASSOC *
 assoccopy(ASSOC *oldap)
 {
-	ASSOC *ap;
-	ASSOCELEM *oldep;
-	ASSOCELEM *ep;
-	ASSOCELEM **listhead;
-	int oldhi;
-	int i;
+        ASSOC *ap;
+        ASSOCELEM *oldep;
+        ASSOCELEM *ep;
+        ASSOCELEM **listhead;
+        int oldhi;
+        int i;
 
-	ap = assocalloc(oldap->a_count / CHAINLENGTH);
-	ap->a_count = oldap->a_count;
+        ap = assocalloc(oldap->a_count / CHAINLENGTH);
+        ap->a_count = oldap->a_count;
 
-	for (oldhi = 0; oldhi < oldap->a_size; oldhi++) {
-		for (oldep = oldap->a_table[oldhi]; oldep;
-			oldep = oldep->e_next) {
-			ep = (ASSOCELEM *) malloc(ELEMSIZE(oldep->e_dim));
-			if (ep == NULL) {
-				math_error("Cannot allocate association element");
-				/*NOTREACHED*/
-			}
-			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);
-			listhead = &ap->a_table[ep->e_hash % ap->a_size];
-			ep->e_next = *listhead;
-			*listhead = ep;
-		}
-	}
-	return ap;
+        for (oldhi = 0; oldhi < oldap->a_size; oldhi++) {
+                for (oldep = oldap->a_table[oldhi]; oldep;
+                        oldep = oldep->e_next) {
+                        ep = (ASSOCELEM *) malloc(ELEMSIZE(oldep->e_dim));
+                        if (ep == NULL) {
+                                math_error("Cannot allocate "
+                                           "association element");
+                                not_reached();
+                        }
+                        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);
+                        listhead = &ap->a_table[ep->e_hash % ap->a_size];
+                        ep->e_next = *listhead;
+                        *listhead = ep;
+                }
+        }
+        return ap;
 }
 
 
@@ -356,61 +358,61 @@ 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;
-	ASSOCELEM **newtable;
-	ASSOCELEM **oldlist;
-	ASSOCELEM **newlist;
-	ASSOCELEM *ep;
-	int i;
+        ASSOCELEM **oldtable;
+        ASSOCELEM **newtable;
+        ASSOCELEM **oldlist;
+        ASSOCELEM **newlist;
+        ASSOCELEM *ep;
+        int i;
 
-	if (newsize < ap->a_size + GROWHASHSIZE)
-		return;
+        if (newsize < ap->a_size + GROWHASHSIZE)
+                return;
 
-	newsize = (long) next_prime((FULL)newsize);
-	newtable = (ASSOCELEM **) malloc(sizeof(ASSOCELEM *) * newsize);
-	if (newtable == NULL) {
-		math_error("No memory to grow association");
-		/*NOTREACHED*/
-	}
-	for (i = 0; i < newsize; i++)
-		newtable[i] = NULL;
+        newsize = (long) next_prime((FULL)newsize);
+        newtable = (ASSOCELEM **) malloc(sizeof(ASSOCELEM *) * newsize);
+        if (newtable == NULL) {
+                math_error("No memory to grow association");
+                not_reached();
+        }
+        for (i = 0; i < newsize; i++)
+                newtable[i] = NULL;
 
-	oldtable = ap->a_table;
-	oldlist = oldtable;
-	for (i = 0; i < ap->a_size; i++) {
-		while (*oldlist) {
-			ep = *oldlist;
-			*oldlist = ep->e_next;
-			newlist = &newtable[ep->e_hash % newsize];
-			ep->e_next = *newlist;
-			*newlist = ep;
-		}
-		oldlist++;
-	}
+        oldtable = ap->a_table;
+        oldlist = oldtable;
+        for (i = 0; i < ap->a_size; i++) {
+                while (*oldlist) {
+                        ep = *oldlist;
+                        *oldlist = ep->e_next;
+                        newlist = &newtable[ep->e_hash % newsize];
+                        ep->e_next = *newlist;
+                        *newlist = ep;
+                }
+                oldlist++;
+        }
 
-	ap->a_table = newtable;
-	ap->a_size = newsize;
-	free((char *) oldtable);
+        ap->a_table = newtable;
+        ap->a_size = newsize;
+        free((char *) oldtable);
 }
 
 
 /*
  * Free an association element, along with any contained values.
  */
-static void
+S_FUNC void
 assoc_elemfree(ASSOCELEM *ep)
 {
-	int i;
+        int i;
 
-	for (i = 0; i < ep->e_dim; i++)
-		freevalue(&ep->e_indices[i]);
-	freevalue(&ep->e_value);
-	ep->e_dim = 0;
-	ep->e_next = NULL;
-	free((char *) ep);
+        for (i = 0; i < ep->e_dim; i++)
+                freevalue(&ep->e_indices[i]);
+        freevalue(&ep->e_value);
+        ep->e_dim = 0;
+        ep->e_next = NULL;
+        free((char *) ep);
 }
 
 
@@ -421,27 +423,27 @@ assoc_elemfree(ASSOCELEM *ep)
 ASSOC *
 assocalloc(long initsize)
 {
-	register ASSOC *ap;
-	int i;
+        register ASSOC *ap;
+        int i;
 
-	if (initsize < MINHASHSIZE)
-		initsize = MINHASHSIZE;
-	ap = (ASSOC *) malloc(sizeof(ASSOC));
-	if (ap == NULL) {
-		math_error("No memory for association");
-		/*NOTREACHED*/
-	}
-	ap->a_count = 0;
-	ap->a_size = initsize;
-	ap->a_table = (ASSOCELEM **) malloc(sizeof(ASSOCELEM *) * initsize);
-	if (ap->a_table == NULL) {
-		free((char *) ap);
-		math_error("No memory for association");
-		/*NOTREACHED*/
-	}
-	for (i = 0; i < initsize; i++)
-		ap->a_table[i] = NULL;
-	return ap;
+        if (initsize < MINHASHSIZE)
+                initsize = MINHASHSIZE;
+        ap = (ASSOC *) malloc(sizeof(ASSOC));
+        if (ap == NULL) {
+                math_error("No memory for association");
+                not_reached();
+        }
+        ap->a_count = 0;
+        ap->a_size = initsize;
+        ap->a_table = (ASSOCELEM **) malloc(sizeof(ASSOCELEM *) * initsize);
+        if (ap->a_table == NULL) {
+                free((char *) ap);
+                math_error("No memory for association");
+                not_reached();
+        }
+        for (i = 0; i < initsize; i++)
+                ap->a_table[i] = NULL;
+        return ap;
 }
 
 
@@ -451,25 +453,25 @@ assocalloc(long initsize)
 void
 assocfree(ASSOC *ap)
 {
-	ASSOCELEM **listhead;
-	ASSOCELEM *ep;
-	ASSOCELEM *nextep;
-	int i;
+        ASSOCELEM **listhead;
+        ASSOCELEM *ep;
+        ASSOCELEM *nextep;
+        int i;
 
-	listhead = ap->a_table;
-	for (i = 0; i < ap->a_size; i++) {
-		nextep = *listhead;
-		*listhead = NULL;
-		while (nextep) {
-			ep = nextep;
-			nextep = ep->e_next;
-			assoc_elemfree(ep);
-		}
-		listhead++;
-	}
-	free((char *) ap->a_table);
-	ap->a_table = NULL;
-	free((char *) ap);
+        listhead = ap->a_table;
+        for (i = 0; i < ap->a_size; i++) {
+                nextep = *listhead;
+                *listhead = NULL;
+                while (nextep) {
+                        ep = nextep;
+                        nextep = ep->e_next;
+                        assoc_elemfree(ep);
+                }
+                listhead++;
+        }
+        free((char *) ap->a_table);
+        ap->a_table = NULL;
+        free((char *) ap);
 }
 
 
@@ -480,58 +482,58 @@ assocfree(ASSOC *ap)
 void
 assocprint(ASSOC *ap, long max_print)
 {
-	ASSOCELEM *ep;
-	long index;
-	long i;
-	int savemode;
+        ASSOCELEM *ep;
+        long index;
+        long i;
+        int savemode;
 
-	if (max_print <= 0) {
-		math_fmt("assoc (%ld element%s)", ap->a_count,
-			((ap->a_count == 1) ? "" : "s"));
-		return;
-	}
-	math_fmt("\n  assoc (%ld element%s):\n", ap->a_count,
-		((ap->a_count == 1) ? "" : "s"));
+        if (max_print <= 0) {
+                math_fmt("assoc (%ld element%s)", ap->a_count,
+                        ((ap->a_count == 1) ? "" : "s"));
+                return;
+        }
+        math_fmt("\n  assoc (%ld element%s):\n", ap->a_count,
+                ((ap->a_count == 1) ? "" : "s"));
 
-	for (index = 0; ((index < max_print) && (index < ap->a_count));
-		index++) {
-		ep = elemindex(ap, index);
-		if (ep == NULL)
-			continue;
-		math_str("  [");
-		for (i = 0; i < ep->e_dim; i++) {
-			if (i)
-				math_chr(',');
-			savemode = math_setmode(MODE_FRAC);
-			printvalue(&ep->e_indices[i],
-				(PRINT_SHORT | PRINT_UNAMBIG));
-			math_setmode(savemode);
-		}
-		math_str("] = ");
-		printvalue(&ep->e_value, PRINT_SHORT | PRINT_UNAMBIG);
-		math_chr('\n');
-	}
-	if (max_print < ap->a_count)
-		math_str("  ...\n");
+        for (index = 0; ((index < max_print) && (index < ap->a_count));
+                index++) {
+                ep = elemindex(ap, index);
+                if (ep == NULL)
+                        continue;
+                math_str("  [");
+                for (i = 0; i < ep->e_dim; i++) {
+                        if (i)
+                                math_chr(',');
+                        savemode = math_setmode(MODE_FRAC);
+                        printvalue(&ep->e_indices[i],
+                                (PRINT_SHORT | PRINT_UNAMBIG));
+                        math_setmode(savemode);
+                }
+                math_str("] = ");
+                printvalue(&ep->e_value, PRINT_SHORT | PRINT_UNAMBIG);
+                math_chr('\n');
+        }
+        if (max_print < ap->a_count)
+                math_str("  ...\n");
 }
 
 
 /*
  * Compare two lists of index values to see if they are identical.
- * Returns TRUE if they are the same.
+ * Returns true if they are the same.
  */
-static BOOL
+S_FUNC bool
 compareindices(VALUE *v1, VALUE *v2, long dim)
 {
-	int i;
+        int i;
 
-	for (i = 0; i < dim; i++)
-		if (v1[i].v_type != v2[i].v_type)
-			return FALSE;
+        for (i = 0; i < dim; i++)
+                if (v1[i].v_type != v2[i].v_type)
+                        return false;
 
-	while (dim-- > 0)
-		if (comparevalue(v1++, v2++))
-			return FALSE;
+        while (dim-- > 0)
+                if (comparevalue(v1++, v2++))
+                        return false;
 
-	return TRUE;
+        return true;
 }

attribute.h

@@ -0,0 +1,69 @@
+/*
+ * attribute - control use of attributes in a backward compatible way
+ *
+ * Copyright (C) 2022  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.
+ *
+ * Under source code control:   2022/01/21 22:51:25
+ * File existed as early as:    2022
+ *
+ * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+#if !defined(INCLUDE_ATTRIBUTE_H)
+#define INCLUDE_ATTRIBUTE_H
+
+
+/*
+ * backward compatibility
+ *
+ * Not all compilers support __attribute__ nor do they suuport __has_builtin.
+ * For example, MSVC, TenDRAm and Little C Compiler doesn't support __attribute__.
+ * Early gcc does not support __attribute__.
+ *
+ * Not all compiles have __has_builtin
+ */
+#if !defined(__attribute__) && \
+    (defined(__cplusplus) || !defined(__GNUC__)  || __GNUC__ == 2 && __GNUC_MINOR__ < 8)
+#    define __attribute__(A)
+#endif
+#if !defined __has_builtin
+#    define __has_builtin(x) 0
+#endif
+
+
+/*
+ * not_reached
+ *
+ * In the old days of lint, one could give lint and friends a hint by
+ * placing the token NOTREACHED immediately between opening and closing
+ * comments.  Modern compilers do not honor such commented tokens
+ * and instead rely on features such as __builtin_unreachable
+ * and __attribute__((noreturn)).
+ *
+ * The not_reached will either yield a __builtin_unreachable() feature call,
+ * or it will call abort from stdlib.
+ */
+#if __has_builtin(__builtin_unreachable)
+#    define not_reached() __builtin_unreachable()
+#else
+#    define not_reached() abort()
+#endif /* __has_builtin(__builtin_unreachable) */
+
+
+#endif /* !INCLUDE_ATTRIBUTE_H */

banned.h

@@ -0,0 +1,180 @@
+/*
+ * banned - optionally ban dangerous functions
+ *
+ * Unless UNBAN is defined, this file will turn the use
+ * of certain dangerous functions into syntax errors.
+ *
+ * In the case of calc, we are motivated in part by the desire for
+ * calc to correctly calculate: even during extremely long calculations.
+ *
+ * If UNBAN is NOT defined, then calling certain functions
+ * will result in a syntax error.
+ *
+ * If we define UNBAN, then the effect of this file is disabled.
+ *
+ * The banned.h attempts to ban the use of certain dangerous functions
+ * that, if improperly used, could compromise the computational integrity
+ * if calculations.
+ *
+ * In the case of calc, we are motivated in part by the desire for calc
+ * to correctly calculate: even during extremely long calculations.
+ *
+ * If UNBAN is NOT defined, then calling certain functions
+ * will result in a call to a non-existent function (link error).
+ *
+ * While we do NOT encourage defining UNBAN, there may be
+ * a system / compiler environment where re-defining a
+ * function may lead to a fatal compiler complication.
+ * If that happens, consider compiling as:
+ *
+ *      make clobber all chk CCBAN=-DUNBAN
+ *
+ * as see if this is a work-a-round.
+ *
+ * If YOU discover a need for the -DUNBAN work-a-round, PLEASE tell us!
+ * Please send us a bug report.  See the file:
+ *
+ *      BUGS
+ *
+ * or the URL:
+ *
+ *      http://www.isthe.com/chongo/tech/comp/calc/calc-bugrept.html
+ *
+ * for how to send us such a bug report.
+ *
+ * Copyright (C) 2021  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.
+ *
+ * Under source code control:   2021/03/06 21:07:31
+ * File existed as early as:    2021
+ *
+ * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+#if !defined(PRE_HAVE_BAN_PRAGMA_H)
+#include "have_ban_pragma.h"
+#endif /* ! PRE_HAVE_BAN_PRAGMA_H */
+
+
+#if !defined(INCLUDE_BANNED_H)
+#define INCLUDE_BANNED_H
+
+/*
+ * If we define UNBAN, then the effect of this file is disabled.
+ */
+#if !defined(UNBAN)
+
+/*
+ * In the spirit of:
+ *
+ *      https://github.com/git/git/blob/master/banned.h
+ *
+ * we will ban the use of certain unsafe functions by turning
+ * then into function calls that do not exist.
+ *
+ * In the case of calc, we are motivated in part by the desire
+ * for calc to correctly calculate: even during extremely long
+ * calculations.
+ *
+ * If UNBAN is NOT defined, then calling certain functions
+ * will result in a syntax error.
+ *
+ * Unlike the above URL, we suggest an alternative function.
+ * In many cases, additional logic is required to use the
+ * alternative function, we cannot simply replace one function
+ * with another.
+ */
+
+/*
+ * If one is not careful, strcpy() can lead to buffer overflows.
+ * Use strlcpy() instead.
+ */
+#if defined(HAVE_PRAGMA_GCC_POSION)
+#undef strcpy
+#pragma GCC poison strcpy
+#endif /* HAVE_PRAGMA_GCC_POSION */
+
+/*
+ * If one is not careful, strcat() can lead to buffer overflows.
+ * Use strlcat() instead.
+ */
+#if defined(HAVE_PRAGMA_GCC_POSION)
+#undef strcat
+#pragma GCC poison strcat
+#endif /* HAVE_PRAGMA_GCC_POSION */
+
+/*
+ * If one is not careful, strncpy() can lead to buffer overflows.
+ * Use memccpy() instead.
+ */
+#if defined(HAVE_PRAGMA_GCC_POSION)
+#undef strncpy
+#pragma GCC poison strncpy
+#endif /* HAVE_PRAGMA_GCC_POSION */
+
+/*
+ * If one is not careful, strncat() can lead to buffer overflows.
+ * Use memccpy() instead.
+ */
+#if defined(HAVE_PRAGMA_GCC_POSION)
+#undef strncat
+#pragma GCC poison strncat
+#endif /* HAVE_PRAGMA_GCC_POSION */
+
+/*
+ * If one is not careful, sprintf() can lead to buffer overflows.
+ * Use snprintf() instead.
+ */
+#if defined(HAVE_PRAGMA_GCC_POSION)
+#undef sprintf
+#pragma GCC poison sprintf
+#endif /* HAVE_PRAGMA_GCC_POSION */
+
+/*
+ * If one is not careful, vsprintf() can lead to buffer overflows.
+ * Use vsnprintf() instead.
+ */
+#if defined(HAVE_PRAGMA_GCC_POSION)
+#undef vsprintf
+#pragma GCC poison vsprintf
+#endif /* HAVE_PRAGMA_GCC_POSION */
+
+/*
+ * XXX - As of 2021, functions such as:
+ *
+ *      gmtime_s
+ *      localtime_s
+ *      ctime_s
+ *      asctime_s
+ *
+ * are not universal.  We cannot yet ban the following
+ * functions because we do not have a portable AND
+ * widely available alternative.  Therefore we just
+ * have to be extra careful when using:
+ *
+ *      gmtime
+ *      localtime
+ *      ctime
+ *      ctime_r
+ *      asctime
+ *      asctime_r
+ */
+
+#endif /* !UNBAN */
+
+#endif /* !INCLUDE_BANNED_H */

blkcpy.h

@@ -1,7 +1,7 @@
 /*
  * blkcpy - general values and related routines used by the calculator
  *
- * Copyright (C) 1999  Landon Curt Noll and Ernest Bowen
+ * Copyright (C) 1999-2007,2014  Landon Curt Noll and Ernest Bowen
  *
  * Primary author:  Landon Curt Noll
  *
@@ -11,52 +11,48 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: blkcpy.h,v 29.1 1999/12/14 09:15:29 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
  *
- * Under source code control:	1997/04/18 20:41:25
- * File existed as early as:	1997
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 
-#if !defined(__BLKCPY_H__)
-#define __BLKCPY_H__
+#if !defined(INCLUDE_BLKCPY_H)
+#define INCLUDE_BLKCPY_H
 
 /*
  * the main copy gateway function
  */
-extern int copystod(VALUE *, long, long, VALUE *, long);
+E_FUNC int copystod(VALUE *, long, long, VALUE *, long);
 
 /*
  * specific copy functions
  */
-extern int copyblk2blk(BLOCK *, long, long, BLOCK *, long, BOOL);
-extern int copyblk2file(BLOCK *, long, long, FILEID, long);
-extern int copyblk2mat(BLOCK *, long, long, MATRIX *, long);
-extern int copyblk2num(BLOCK *, long, long, NUMBER *, long, NUMBER **);
-extern int copyblk2str(BLOCK *, long, long, STRING *, long);
-extern int copyfile2blk(FILEID, long, long, BLOCK *, long, BOOL);
-extern int copylist2list(LIST *, long, long, LIST *, long);
-extern int copylist2mat(LIST *, long, long, MATRIX *, long);
-extern int copymat2blk(MATRIX *, long, long, BLOCK *, long, BOOL);
-extern int copymat2list(MATRIX *, long, long, LIST *, long);
-extern int copymat2mat(MATRIX *, long, long, MATRIX *, long);
-extern int copynum2blk(NUMBER *, long, long, BLOCK *, long, BOOL);
-extern int copyostr2blk(char *, long, long, BLOCK *, long, BOOL);
-extern int copyostr2str(char *, long, long, STRING *, long);
-extern int copystr2blk(STRING *, long, long, BLOCK *, long, BOOL);
-extern int copystr2file(STRING *, long, long, FILEID, long);
-extern int copystr2str(STRING *, long, long, STRING *, long);
+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__ */
+#endif /* !INCLUDE_BLKCPY_H */

block.h

@@ -1,7 +1,7 @@
 /*
  * block - fixed, dynamic, fifo and circular memory blocks
  *
- * Copyright (C) 1999  Landon Curt Noll and Ernest Bowen
+ * Copyright (C) 1999-2007,2014,2021,2023  Landon Curt Noll and Ernest Bowen
  *
  * Primary author:  Landon Curt Noll
  *
@@ -11,28 +11,24 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: block.h,v 29.1 1999/12/14 09:15:30 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
  *
- * Under source code control:	1997/02/21 05:03:39
- * File existed as early as:	1997
- *
- * chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * 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__
+#if !defined(INCLUDE_BLOCK_H)
+#define INCLUDE_BLOCK_H
 
 
 /*
@@ -45,114 +41,114 @@
  *
  * Block functions and operations:
  *
- *	x[i]
- *		(i-1)th octet
+ *      x[i]
+ *              (i-1)th octet
  *
- *	blk(len [, blkchunk])
- *		unnamed block
- *		len > 0
- *		blkchunk defaults to BLK_CHUNKSIZE
+ *      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
+ *      blk(name, [len [, blkchunk]])
+ *              named block
+ *              len > 0
+ *              blkchunk defaults to BLK_CHUNKSIZE
  *
- *	blkfree(x)
- *		Reduce storage down to 0 octetes.
+ *      blkfree(x)
+ *              Reduce storage down to 0 octets.
  *
- *	size(x)
- *		The length of data stored in the block.
+ *      size(x)
+ *              The length of data stored in the block.
  *
- *	sizeof(x) == blk->maxsize
- *		Allocation size in memory
+ *      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
+ *      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
+ *      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
+ *      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
+ *      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
+ *      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
+ *      blkmove(dest, src, length [, dest_offset [, src_offset]])
+ *              0 <= length <= blksize(x)
+ *              offset's are restricted in value by block type
+ *              overlapping moves are handled correctly
  *
- *	blkccpy(dest, src, stopval, length [, dest_offset [, src_offset]])
- *		0 <= length <= blksize(x)
- *		offset's are restricted in value by block type
+ *      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
+ *      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
+ *      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
+ *      scatter(src, dest1, dest2 [, dest3 ] ...)
+ *              copy successive 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
+ *      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
+ *      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("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("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("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
+ *      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 */
+        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;
+        char *name;
+        int subtype;
+        int id;
+        BLOCK *blk;
 };
 typedef struct nblock NBLOCK;
 
@@ -160,26 +156,26 @@ typedef struct nblock NBLOCK;
 /*
  * block debug
  */
-extern int blk_debug;	/* 0 => debug off */
+EXTERN int blk_debug;   /* 0 => debug off */
 
 
 /*
  * block defaults
  */
-#define BLK_CHUNKSIZE 256	/* default allocation chunk size for blocks */
+#define BLK_CHUNKSIZE 256       /* default allocation chunk size for blocks */
 
-#define BLK_DEF_MAXPRINT 256	/* default octets to print */
+#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_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 */
+#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 */
 
 
 /*
@@ -188,7 +184,7 @@ extern int blk_debug;	/* 0 => debug off */
 /* length of data stored in a block */
 #define blklen(blk) ((blk)->datalen)
 
-/* block footpint in memory */
+/* block footprint in memory */
 #define blksizeof(blk) ((blk)->maxsize)
 
 /* block allocation chunk size */
@@ -204,22 +200,22 @@ typedef USB8 OCTET;
 /*
  * external functions
  */
-extern BLOCK *blkalloc(int, int);
-extern void blk_free(BLOCK*);
-extern BLOCK *blkrealloc(BLOCK*, int, int);
-extern void blktrunc(BLOCK*);
-extern BLOCK *blk_copy(BLOCK*);
-extern int blk_cmp(BLOCK*, BLOCK*);
-extern void blk_print(BLOCK*);
-extern void nblock_print(NBLOCK *);
-extern NBLOCK *createnblock(char *, int, int);
-extern NBLOCK *reallocnblock(int, int, int);
-extern int removenblock(int);
-extern int findnblockid(char *);
-extern NBLOCK *findnblock(int);
-extern BLOCK *copyrealloc(BLOCK*, int, int);
-extern int countnblocks(void);
-extern void shownblocks(void);
+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__ */
+#endif /* !INCLUDE_BLOCK_H */

bool.h

@@ -0,0 +1,65 @@
+/*
+ * bool - calc standard truth :-)
+ *
+ * Copyright (C) 2023  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.
+ *
+ * Under source code control:   2023/07/19 17:58:42
+ * File existed as early as:    2023
+ *
+ * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+#if !defined(INCLUDE_BOOL_H)
+#define INCLUDE_BOOL_H
+
+#include "have_stdbool.h"
+#if defined(HAVE_STDBOOL_H)
+#include <stdbool.h>
+#endif /* HAVE_STDBOOL_H */
+
+
+/*
+ * standard truth :-)
+ */
+#if !defined(HAVE_STDBOOL_H)
+
+/* fake a <stdbool.h> header file */
+typedef unsigned char bool;     /* fake boolean typedef */
+#undef true
+#define true ((bool)(1))
+#undef false
+#define false ((bool)(0))
+
+#endif /* !HAVE_STDBOOL_H */
+
+
+/*
+ * calc historic booleans
+ */
+#undef TRUE
+#define TRUE (true)
+#undef FALSE
+#define FALSE (false)
+#undef BOOL
+#define BOOL bool
+
+
+#endif /* !INCLUDE_BOOL_H*/

byteswap.h

@@ -1,7 +1,7 @@
 /*
  * byteswap - byte swapping macros
  *
- * Copyright (C) 1999  Landon Curt Noll
+ * Copyright (C) 1999,2014,2021  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
@@ -9,72 +9,72 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: byteswap.h,v 29.1 1999/12/14 09:15:30 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
  *
- * Under source code control:	1995/10/11 04:44:01
- * File existed as early as:	1995
- *
- * chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * 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__
+#if !defined(INCLUDE_BYTESWAP_H)
+#define INCLUDE_BYTESWAP_H
 
 
-#include "longbits.h"
+#if defined(CALC_SRC)   /* if we are building from the calc source tree */
+# include "longbits.h"
+#else
+# include <calc/longbits.h>
+#endif
 
 
 /*
  * SWAP_B8_IN_B16 - swap 8 bits in 16 bits
  *
- *	dest	- pointer to where the swapped src wil be put
- *	src	- pointer to a 16 bit value to swap
+ *      dest    - pointer to where the swapped src will be put
+ *      src     - pointer to a 16 bit value to swap
  *
  * This macro will either switch to the opposite byte sex (Big Endian vs.
  * Little Endian) a 16 bit value.
  */
-#define SWAP_B8_IN_B16(dest, src) (					\
-	*((USB16*)(dest)) =						\
-	  (((*((USB16*)(src))) << 8) | ((*((USB16*)(src))) >> 8))	\
+#define SWAP_B8_IN_B16(dest, src) (                                     \
+        *((USB16*)(dest)) =                                             \
+          (((*((USB16*)(src))) << 8) | ((*((USB16*)(src))) >> 8))       \
 )
 
 /*
  * SWAP_B16_IN_B32 - swap 16 bits in 32 bits
  *
- *	dest	- pointer to where the swapped src wil be put
- *	src	- pointer to a 32 bit value to swap
+ *      dest    - pointer to where the swapped src will be put
+ *      src     - pointer to a 32 bit value to swap
  */
-#define SWAP_B16_IN_B32(dest, src) (					\
-	*((USB32*)(dest)) =						\
-	  (((*((USB32*)(src))) << 16) | ((*((USB32*)(src))) >> 16))	\
+#define SWAP_B16_IN_B32(dest, src) (                                    \
+        *((USB32*)(dest)) =                                             \
+          (((*((USB32*)(src))) << 16) | ((*((USB32*)(src))) >> 16))     \
 )
 
 /*
  * SWAP_B8_IN_B32 - swap 8 & 16 bits in 32 bits
  *
- *	dest	- pointer to where the swapped src wil be put
- *	src	- pointer to a 32 bit value to swap
+ *      dest    - pointer to where the swapped src will be put
+ *      src     - pointer to a 32 bit value to swap
  *
  * This macro will either switch to the opposite byte sex (Big Endian vs.
  * Little Endian) a 32 bit value.
  */
-#define SWAP_B8_IN_B32(dest, src) (					\
-	SWAP_B16_IN_B32(dest, src),					\
-	(*((USB32*)(dest)) =						\
-	  ((((*((USB32*)(dest))) & (USB32)0xff00ff00) >> 8) |		\
-	  (((*((USB32*)(dest))) & (USB32)0x00ff00ff) << 8)))		\
+#define SWAP_B8_IN_B32(dest, src) (                                     \
+        SWAP_B16_IN_B32(dest, src),                                     \
+        (*((USB32*)(dest)) =                                            \
+          ((((*((USB32*)(dest))) & (USB32)0xff00ff00) >> 8) |           \
+          (((*((USB32*)(dest))) & (USB32)0x00ff00ff) << 8)))            \
 )
 
 #if defined(HAVE_B64)
@@ -82,41 +82,41 @@
 /*
  * SWAP_B32_IN_B64 - swap 32 bits in 64 bits
  *
- *	dest	- pointer to where the swapped src wil be put
- *	src	- pointer to a 64 bit value to swap
+ *      dest    - pointer to where the swapped src will be put
+ *      src     - pointer to a 64 bit value to swap
  */
-#define SWAP_B32_IN_B64(dest, src) (					\
-	*((USB64*)(dest)) =						\
-	  (((*((USB64*)(src))) << 32) | ((*((USB64*)(src))) >> 32))	\
+#define SWAP_B32_IN_B64(dest, src) (                                    \
+        *((USB64*)(dest)) =                                             \
+          (((*((USB64*)(src))) << 32) | ((*((USB64*)(src))) >> 32))     \
 )
 
 /*
  * SWAP_B16_IN_B64 - swap 16 & 32 bits in 64 bits
  *
- *	dest	- pointer to where the swapped src wil be put
- *	src	- pointer to a 64 bit value to swap
+ *      dest    - pointer to where the swapped src will be put
+ *      src     - pointer to a 64 bit value to swap
  */
-#define SWAP_B16_IN_B64(dest, src) (					\
-	SWAP_B32_IN_B64(dest, src),					\
-	(*((USB64*)(dest)) =						\
-	  ((((*((USB64*)(dest))) & (USB64)0xffff0000ffff0000) >> 16) |	\
-	  (((*((USB64*)(dest))) & (USB64)0x0000ffff0000ffff) << 16)))	\
+#define SWAP_B16_IN_B64(dest, src) (                                    \
+        SWAP_B32_IN_B64(dest, src),                                     \
+        (*((USB64*)(dest)) =                                            \
+          ((((*((USB64*)(dest))) & (USB64)0xffff0000ffff0000) >> 16) |  \
+          (((*((USB64*)(dest))) & (USB64)0x0000ffff0000ffff) << 16)))   \
 )
 
 /*
  * SWAP_B8_IN_B64 - swap 16 & 32 bits in 64 bits
  *
- *	dest	- pointer to where the swapped src wil be put
- *	src	- pointer to a 64 bit value to swap
+ *      dest    - pointer to where the swapped src will be put
+ *      src     - pointer to a 64 bit value to swap
  *
  * This macro will either switch to the opposite byte sex (Big Endian vs.
  * Little Endian) a 64 bit value.
  */
-#define SWAP_B8_IN_B64(dest, src) (					\
-	SWAP_B16_IN_B64(dest, src),					\
-	(*((USB64*)(dest)) =						\
-	  ((((*((USB64*)(dest))) & (USB64)0xff00ff00ff00ff00) >> 8) |	\
-	  (((*((USB64*)(dest))) & (USB64)0x00ff00ff00ff00ff) << 8)))	\
+#define SWAP_B8_IN_B64(dest, src) (                                     \
+        SWAP_B16_IN_B64(dest, src),                                     \
+        (*((USB64*)(dest)) =                                            \
+          ((((*((USB64*)(dest))) & (USB64)0xff00ff00ff00ff00) >> 8) |   \
+          (((*((USB64*)(dest))) & (USB64)0x00ff00ff00ff00ff) << 8)))    \
 )
 
 #else /* HAVE_B64 */
@@ -124,54 +124,54 @@
 /*
  * SWAP_B32_IN_B64 - swap 32 bits in 64 bits (simulated by 2 32 bit values)
  *
- *	dest	- pointer to where the swapped src wil be put
- *	src	- pointer to a 64 bit value to swap
+ *      dest    - pointer to where the swapped src will be put
+ *      src     - pointer to a 64 bit value to swap
  */
-#define SWAP_B32_IN_B64(dest, src) (					\
-	((USB32*)(dest))[1] = ((USB32*)(dest))[0],			\
-	((USB32*)(dest))[0] = ((USB32*)(dest))[1]			\
+#define SWAP_B32_IN_B64(dest, src) (                                    \
+        ((USB32*)(dest))[1] = ((USB32*)(dest))[0],                      \
+        ((USB32*)(dest))[0] = ((USB32*)(dest))[1]                       \
 )
 
 /*
  * SWAP_B16_IN_B64 - swap 16 & 32 bits in 64 bits (simulated by 2 32 bit vals)
  *
- *	dest	- pointer to where the swapped src wil be put
- *	src	- pointer to a 64 bit value to swap
+ *      dest    - pointer to where the swapped src will be put
+ *      src     - pointer to a 64 bit value to swap
  */
-#define SWAP_B16_IN_B64(dest, src) (					\
-	SWAP_B16_IN_B32(((USB32*)dest)+1, ((USB32*)src)),		\
-	SWAP_B16_IN_B32(((USB32*)dest), ((USB32*)src)+1)		\
+#define SWAP_B16_IN_B64(dest, src) (                                    \
+        SWAP_B16_IN_B32(((USB32*)dest)+1, ((USB32*)src)),               \
+        SWAP_B16_IN_B32(((USB32*)dest), ((USB32*)src)+1)                \
 )
 
 /*
  * SWAP_B8_IN_B64 - swap 16 & 32 bits in 64 bits (simulated by 2 32 bit vals)
  *
- *	dest	- pointer to where the swapped src wil be put
- *	src	- pointer to a 64 bit value to swap
+ *      dest    - pointer to where the swapped src will be put
+ *      src     - pointer to a 64 bit value to swap
  *
  * This macro will either switch to the opposite byte sex (Big Endian vs.
  * Little Endian) a 64 bit value.
  */
-#define SWAP_B8_IN_B64(dest, src) (					\
-	SWAP_B8_IN_B32(((USB32*)dest)+1, ((USB32*)src)),		\
-	SWAP_B8_IN_B32(((USB32*)dest), ((USB32*)src)+1)			\
+#define SWAP_B8_IN_B64(dest, src) (                                     \
+        SWAP_B8_IN_B32(((USB32*)dest)+1, ((USB32*)src)),                \
+        SWAP_B8_IN_B32(((USB32*)dest), ((USB32*)src)+1)                 \
 )
 
 #endif /* HAVE_B64 */
 
 #if LONG_BITS == 64
 
-#define SWAP_B32_IN_LONG(dest, src)	SWAP_B32_IN_B64(dest, src)
-#define SWAP_B16_IN_LONG(dest, src)	SWAP_B16_IN_B64(dest, src)
-#define SWAP_B8_IN_LONG(dest, src)	SWAP_B8_IN_B64(dest, src)
+#define SWAP_B32_IN_LONG(dest, src)     SWAP_B32_IN_B64(dest, src)
+#define SWAP_B16_IN_LONG(dest, src)     SWAP_B16_IN_B64(dest, src)
+#define SWAP_B8_IN_LONG(dest, src)      SWAP_B8_IN_B64(dest, src)
 
 #else /* LONG_BITS == 64 */
 
-#define SWAP_B32_IN_LONG(dest, src)	SWAP_B32_IN_B32(dest, src)
-#define SWAP_B16_IN_LONG(dest, src)	SWAP_B16_IN_B32(dest, src)
-#define SWAP_B8_IN_LONG(dest, src)	SWAP_B8_IN_B32(dest, src)
+#define SWAP_B32_IN_LONG(dest, src)     SWAP_B32_IN_B32(dest, src)
+#define SWAP_B16_IN_LONG(dest, src)     SWAP_B16_IN_B32(dest, src)
+#define SWAP_B8_IN_LONG(dest, src)      SWAP_B8_IN_B32(dest, src)
 
 #endif /* LONG_BITS == 64 */
 
 
-#endif /* !__BYTESWAP_H__ */
+#endif /* !INCLUDE_BYTESWAP_H */

cal/Makefile

@@ -1,8 +1,10 @@
-#!/bin/make
+#!/usr/bin/env make
 #
 # cal - makefile for calc standard resource files
 #
-# Copyright (C) 1999  Landon Curt Noll
+# Copyright (C) 1999-2006,2017,2021-2023  Landon Curt Noll
+#
+# Suggestion: Read the ../HOWTO.INSTALL file.
 #
 # 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
@@ -16,61 +18,139 @@
 # 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.
-# 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
-#
-# @(#) $Revision: 29.1 $
-# @(#) $Id: Makefile,v 29.1 1999/12/14 09:15:30 chongo Exp $
-# @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/Makefile,v $
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #
 # Under source code control:	1991/07/21 05:00:54
 # File existed as early as:	1991
 #
-# chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
-# Share and enjoy!  :-) http://reality.sgi.com/chongo/tech/comp/calc/
+# This calculator first developed by David I. Bell with help/mods from others.
 #
-# calculator by David I. Bell with help/mods from others
-# Makefile by Landon Curt Noll
+# chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+# Share and enjoy!  :-)		http://www.isthe.com/chongo/tech/comp/calc/
 
-# required vars
+
+# SUGGESTION: Instead of modifying this file, consider adding
+#	      statements to modify, replace or append Makefile
+#	      variables in the ../Makefile.local file.
+
+
+###########################################
+# Files used or included by this Makefile #
+###########################################
+
+# 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 won't.
 #
-SHELL = /bin/sh
-MAKE_FILE = Makefile
-
-# Normally, the upper level makefile will set these values.  We provide
-# a default here just in case you want to build from this directory.
+# If in doubt, set MAKE_FILE to Makefile
 #
-# where to install things
-TOPDIR= /usr/local/lib
-#TOPDIR= /usr/lib
-#TOPDIR= /usr/libdata
+MAKE_FILE= Makefile
+
+# Calc configuration and compile configuration values
+#
+CONFIG_MKF= ../Makefile.config
+
+# Host target information.
+#
+TARGET_MKF= ../Makefile.target
+
+# Local file that is included just prior to the first rule,
+# that allows one to override any values set in this Makefile.
+#
+LOCAL_MKF= ../Makefile.local
+
+# The set of Makefiles
+#
+MK_SET= ${MAKE_FILE} ${CONFIG_MKF} ${TARGET_MKF} ${LOCAL_MKF}
+
+
+#######################################################
+# Calc configuration and compile configuration values #
+#######################################################
+include ${CONFIG_MKF}
+
+
+###############################
+# host target section include #
+###############################
+include ${TARGET_MKF}
+
+
+##########################################################################
+#=-=-=-=-=- Be careful if you change something below this line -=-=-=-=-=#
+##########################################################################
 
-LIBDIR= ${TOPDIR}/calc
 
 # Makefile debug
 #
-# Q=@	do not echo internal makefile actions (quiet mode)
-# Q=	echo internal makefile actions (debug / verbose mode)
+# Q=@	do not echo internal Makefile actions (quiet mode)
+# Q=	echo internal Makefile actions (debug / verbose mode)
+#
+# H=@:	do not report hsrc file formation progress
+# H=@	do echo hsrc file formation progress
+#
+# S= >/dev/null 2>&1	silence ${CC} output during hsrc file formation
+# S=			full ${CC} output during hsrc file formation
+#
+# E= 2>/dev/null	silence command stderr during hsrc file formation
+# E=			full command stderr during hsrc file formation
+#
+# V=@:	do not echo debug statements (quiet mode)
+# V=@	do echo debug statements (debug / verbose mode)
 #
 #Q=
 Q=@
-
-# standard tools
 #
-CHMOD= chmod
+S= >/dev/null 2>&1
+#S=
+#
+E= 2>/dev/null
+#E=
+#
+#H=@:
+H=@
+#
+V=@:
+#V=@
 
 # 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 \
-	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 xx_print.cal natnumset.cal qtime.cal test8400.cal \
-	test8500.cal
+# This list is produced by the detaillist rule when no WARNINGS are detected.
+#
+# Please use:
+#
+#	make clobber >/dev/null && make calc_files_list
+#
+# to keep this list in nice sorted order.
+#
+CALC_FILES= README alg_config.cal beer.cal bernoulli.cal \
+	bernpoly.cal bigprime.cal bindings brentsolve.cal chi.cal chrem.cal \
+	comma.cal constants.cal deg.cal dms.cal dotest.cal ellip.cal \
+	factorial.cal factorial2.cal fnv_tool.cal gvec.cal hello.cal hms.cal \
+	infinities.cal intfile.cal intnum.cal lambertw.cal linear.cal \
+	lnseries.cal lucas.cal lucas_chk.cal mersenne.cal mfactor.cal mod.cal \
+	natnumset.cal palindrome.cal pell.cal pi.cal pix.cal pollard.cal \
+	poly.cal prompt.cal psqrt.cal qtime.cal quat.cal randbitrun.cal \
+	randmprime.cal randombitrun.cal randomrun.cal randrun.cal regress.cal \
+	repeat.cal screen.cal seedrandom.cal set8700.line smallfactors.cal \
+	solve.cal specialfunctions.cal splitbits.cal statistics.cal \
+	strings.cal sumsq.cal sumtimes.cal surd.cal test2300.obj_incdec.cal \
+	test2600.numfunc.cal test2700.isqrt.cal test3100.matobj.cal \
+	test3300.det.cal test3400.trig.cal test4000.ptest.cal \
+	test4100.redc.cal test4600.fileop.cal test5100.newdecl.cal \
+	test5200.globstat.cal test8000.read.cal test8400.quit.cal \
+	test8500.divmod.cal test8600.maxargs.cal test8700.dotest.cal \
+	test8900.special.cal test9300.frem.cal test9500.trigeq.cal \
+	toomcook.cal unitfrac.cal varargs.cal write2file.cal xx_print.cal \
+	zeta2.cal
+
+# These calc files are now obsolete and are removed by the install rule.
+#
+DEAD_CALC_FILES= lucas_tbl.cal set8700.cal test1700.cal test2300.cal test2600.cal \
+	test2700.cal test3100.cal test3300.cal test3400.cal test3500.cal test4000.cal \
+	test4100.cal test4600.cal test5100.cal test5200.cal test8400.cal test8500.cal \
+	test8600.cal test8900.cal
 
 # These files are found (but not built) in the distribution
 #
@@ -80,13 +160,36 @@ DISTLIST= ${CALC_FILES} ${MAKE_FILE}
 #
 CALCLIBLIST=
 
+# rules that are not also names of files
+#
+PHONY= all distlist buildlist distdir calcliblist calc_files_list echo_inst_files \
+	clean clobber install uninstall
+
+
+############################################################
+# Allow Makefile.local to change any of the above settings #
+############################################################
+include ${LOCAL_MKF}
+
+
+###########################################
+# all - First and default Makefile target #
+###########################################
+
 all: ${CALC_FILES} ${MAKE_FILE} .all
 
+
+###############################
+# additional Makefile targets #
+###############################
+
+.PHONY: ${PHONY}
+
 # used by the upper level Makefile to determine of we have done all
 #
 .all:
-	rm -f .all
-	touch .all
+	${RM} -f .all
+	${TOUCH} .all
 
 ##
 #
@@ -97,53 +200,165 @@ all: ${CALC_FILES} ${MAKE_FILE} .all
 # 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*
+#	an non-empty else clause for every if condition.  *sigh*
 #
 ##
 
 distlist: ${DISTLIST}
-	${Q}for i in ${DISTLIST}; do \
-		echo cal/$$i; \
-	done
-
-distdir:
-	${Q}echo cal
-
-calcliblist:
-	${Q}for i in ${CALCLIBLIST} /dev/null; do \
+	${Q} for i in ${DISTLIST} /dev/null; do \
 	    if [ X"$$i" != X"/dev/null" ]; then \
 		echo cal/$$i; \
 	    fi; \
 	done
 
+buildlist:
+	${Q} for i in ${BUILD_ALL} /dev/null; do \
+	    if [ X"$$i" != X"/dev/null" ]; then \
+		echo cal/$$i; \
+	    fi; \
+	done | fgrep -v '.bak' | LANG=C ${SORT}
+
+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
+
+# These next rule help form the ${CALC_FILES} makefile variables above.
+#
+calc_files_list:
+	${Q} -(find .  -mindepth 1 -maxdepth 1 -type f -name '*.cal' -print | \
+	    while read i; do \
+		echo $$i; \
+	    done; \
+	    echo '--first_line--'; \
+	    echo README; \
+	    echo set8700.line; \
+	    echo bindings) | \
+	    ${SED} -e 's:^\./::' | LANG=C ${SORT} | ${FMT} -70 | \
+	    ${SED} -e '1s/--first_line--/CALC_FILES=/' -e '2,$$s/^/	/' \
+		   -e 's/$$/ \\/' -e '$$s/ \\$$//'
+
+##
+#
+# 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:
-	rm -f .all
-
-install: all
-	-${Q}if [ ! -d ${TOPDIR} ]; then \
-		echo mkdir ${TOPDIR}; \
-		mkdir ${TOPDIR}; \
-	else \
-	    true; \
+clobber: clean
+	${RM} -f .all
+	-${Q} if [ -e .DS_Store ]; then \
+	    echo ${RM} -rf .DS_Store; \
+	    ${RM} -rf .DS_Store; \
 	fi
-	-${Q}if [ ! -d ${LIBDIR} ]; then \
-		echo mkdir ${LIBDIR}; \
-		mkdir ${LIBDIR}; \
-	else \
-	    true; \
-	fi
-	${Q}for i in ${CALC_FILES}; do \
-		echo rm -f ${LIBDIR}/$$i; \
-		rm -f ${LIBDIR}/$$i; \
-		echo cp $$i ${LIBDIR}; \
-		cp $$i ${LIBDIR}; \
-		echo ${CHMOD} 0444 ${LIBDIR}/$$i; \
-		${CHMOD} 0444 ${LIBDIR}/$$i; \
+	-${Q} for i in ${DEAD_CALC_FILES} test082.cal outfile /dev/null; do \
+	    if [ "$$i" = "/dev/null" ]; then \
+		continue; \
+	    fi; \
+	    if [ -e "./$$i" ]; then \
+		echo "${RM} -f ./$$i"; \
+		${RM} -f ./$$i; \
+	    fi; \
+	done
+
+# 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} -p ${T}${CALC_SHAREDIR}; \
+	    ${MKDIR} -p ${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
+	${Q} for i in ${DEAD_CALC_FILES} /dev/null; do \
+	    if [ "$$i" = "/dev/null" ]; then \
+		continue; \
+	    fi; \
+	    if [ -e "${T}${CALC_SHAREDIR}/$$i" ]; then \
+		echo "${RM} -f ${T}${CALC_SHAREDIR}/$$i"; \
+		${RM} -f ${T}${CALC_SHAREDIR}/$$i; \
+	    fi; \
+	    if [ -e "./$$i" ]; then \
+		echo "${RM} -f ./$$i"; \
+		${RM} -f ./$$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 ${DEAD_CALC_FILES} /dev/null; do \
+	    if [ "$$i" = "/dev/null" ]; then \
+		continue; \
+	    fi; \
+	    if [ -e "${T}${CALC_SHAREDIR}/$$i" ]; then \
+		echo "${RM} -f ${T}${CALC_SHAREDIR}/$$i"; \
+		${RM} -f ${T}${CALC_SHAREDIR}/$$i; \
+	    fi; \
+	    if [ -e "./$$i" ]; then \
+		echo "${RM} -f ./$$i"; \
+		${RM} -f ./$$i; \
+	    fi; \
+	done
+	-${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 "un-installed ${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
-	${Q}echo remove files that are obsolete
-	-rm -f nextprime.cal nextprim.cal
-	-rm -f test1000.cal test2000.cal ${LIBDIR}/test2000.cal
-	-rm -f ${LIBDIR}/nextprime.cal ${LIBDIR}/nextprim.cal
-	-rm -f ${LIBDIR}/test1000.cal ${LIBDIR}/cryrand.cal

cal/beer.cal

@@ -9,23 +9,19 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: beer.cal,v 29.1 1999/12/14 09:15:30 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
  *
- * Under source code control:	1996/11/13 13:21:05
- * File existed as early as:	1996
- *
- * chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -34,17 +30,17 @@
 
 
 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!";
+        /* 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,",;
+        /* 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";
+        /* 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

@@ -1,7 +1,7 @@
 /*
- * bernoulli - clculate the Nth Bernoulli number B(n)
+ * bernoulli - calculate the Nth Bernoulli number B(n)
  *
- * Copyright (C) 1999  David I. Bell
+ * Copyright (C) 2000,2021  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
@@ -9,80 +9,85 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: bernoulli.cal,v 29.1 1999/12/14 09:15:30 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
  *
- * Under source code control:	1991/09/30 11:18:41
- * File existed as early as:	1991
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
  * Calculate the Nth Bernoulli number B(n).
- * This uses the following symbolic formula to calculate B(n):
  *
- *	(b+1)^(n+1) - b^(n+1) = 0
+ * NOTE: This is now a builtin function.
+ *
+ * The non-builtin 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
+ *
+ *      (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.
+ * calculated interactively, 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;
+/*
+        local   nn, np1, i, sum, mulval, divval, combval;
 
-	if (!isint(n) || (n < 0))
-		quit "Non-negative integer required for Bernoulli";
+        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 == 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];
+        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];
+        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/bernpoly.cal

@@ -0,0 +1,55 @@
+/*
+ * bernpoly - Bernoulli polynomials B_n(z) for arbitrary n,z..
+ *
+ * Copyright (C) 2013,2021 Christoph Zurnieden
+ *
+ * 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.
+ *
+ * Under source code control:   2013/08/11 01:31:28
+ * File existed as early as:    2013
+ */
+
+
+static resource_debug_level;
+resource_debug_level = config("resource_debug", 0);
+
+
+read -once zeta2
+
+
+/* Idea by Don Zagier */
+define bernpoly(n,z){
+  local h s c k;
+  if(isint(n) && n>=0){
+    h=0;s=0;c=-1;
+    for(k=1;k<=n+1;k++){
+      c*=1-(n+2)/k;
+      s+=z^n;
+      z++;
+      h+=c*s/k;
+    }
+    return h;
+  }
+  else return -n*hurwitzzeta(1-n,z);
+}
+
+
+/*
+ * restore internal function from resource debugging
+ */
+config("resource_debug", resource_debug_level),;
+if (config("resource_debug") & 3) {
+    print "bernpoly(n,z)";
+}

cal/bigprime.cal

@@ -9,41 +9,37 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: bigprime.cal,v 29.1 1999/12/14 09:15:30 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
  *
- * Under source code control:	1991/05/22 21:56:32
- * File existed as early as:	1991
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 
 define bigprime(a, m, p)
 {
-	local n1, n;
+        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;
-	}
+        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

@@ -8,68 +8,64 @@
 #
 # 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
+# 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.
-# 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 #
-# @(#) $Revision: 29.1 $
-# @(#) $Id: bindings,v 29.1 1999/12/14 09:15:30 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
 #
-# Under source code control:	1993/05/02 20:09:19
-# File existed as early as:	1993
-#
-# Share and enjoy!  :-) http://reality.sgi.com/chongo/tech/comp/calc/
+# 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.
+#       In that case, the standard readline mechanisms (see readline(3))
+#       are used in place of those found below.
 
 
-map	base-map
+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
+^@      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
+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/brentsolve.cal

@@ -0,0 +1,254 @@
+/*
+ * brentsolve - Root finding with the Brent-Dekker trick
+ *
+ * Copyright (C) 2013,2021 Christoph Zurnieden
+ *
+ * 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.
+ *
+ * Under source code control:   2013/08/11 01:31:28
+ * File existed as early as:    2013
+ */
+
+
+static resource_debug_level;
+resource_debug_level = config("resource_debug", 0);
+
+
+/*
+  A short explanation is at http://en.wikipedia.org/wiki/Brent%27s_method
+  I tried to follow the description at wikipedia as much as possible to make
+  the slight changes I did more visible.
+  You may give http://people.sc.fsu.edu/~jburkardt/cpp_src/brent/brent.html a
+  short glimpse (Brent's originl Fortran77 versions and some translations of
+  it).
+*/
+
+static true = 1;
+static false = 0;
+define brentsolve(low, high,eps){
+  local a b c d fa fb fc fa2 fb2 fc2 s fs  tmp tmp2  mflag i places;
+  a = low;
+  b = high;
+  c = 0;
+
+  if(isnull(eps))
+    eps = epsilon(epsilon()*1e-3);
+  places = highbit(1 + int( 1/epsilon() ) ) + 1;
+
+  d = 1/eps;
+
+  fa = f(a);
+  fb = f(b);
+
+  fc = 0;
+  s = 0;
+  fs = 0;
+
+  if(fa * fb >= 0){
+    if(fa < fb){
+      epsilon(eps);
+      return a;
+    }
+    else{
+      epsilon(eps);
+      return b;
+    }
+  }
+
+  if(abs(fa) < abs(fb)){
+    tmp = a; a = b; b = tmp;
+    tmp = fa; fa = fb; fb = tmp;
+  }
+
+  c = a;
+  fc = fa;
+  mflag = 1;
+  i = 0;
+
+  while(!(fb==0) && (abs(a-b) > eps)){
+    if((fa != fc) && (fb != fc)){
+      /* Inverse quadratic interpolation*/
+      fc2 = fc^2;
+      fa2 = fa^2;
+      s = bround(((fb^2*((fc*a)-(c*fa)))+(fb*((c*fa2)-(fc2*a)))+(b*((fc2*fa)
+                    -(fc*fa2))))/((fc - fb)*(fa - fb)*(fc - fa)),places++);
+    }
+    else{
+      /* Secant Rule*/
+      s =bround( b - fb * (b - a) / (fb - fa),places++);
+    }
+    tmp2 = (3 * a + b) / 4;
+    if( (!( ((s > tmp2) && (s < b))||((s < tmp2) && (s > b))))
+        || (mflag && (abs(s - b) >= (abs(b - c) / 2)))
+        || (!mflag && (abs(s - b) >= (abs(c - d) / 2)))) {
+      s = (a + b) / 2;
+      mflag = true;
+    }
+    else{
+      if( (mflag && (abs(b - c) < eps))
+          || (!mflag && (abs(c - d) < eps))) {
+        s = (a + b) / 2;
+        mflag = true;
+      }
+      else
+        mflag = false;
+    }
+    fs = f(s);
+    c = b;
+    fc = fb;
+    if (fa * fs < 0){
+      b = s;
+      fb = fs;
+    }
+    else {
+      a = s;
+      fa = fs;
+    }
+
+    if (abs(fa) < abs(fb)){
+      tmp = a; a = b; b = tmp;
+      tmp = fa; fa = fb; fb = tmp;
+    }
+    i++;
+    if (i > 1000){
+      epsilon(eps);
+      return newerror("brentsolve: does not converge");
+    }
+  }
+  epsilon(eps);
+  return b;
+}
+
+/*
+  A variation of the solver to accept functions named differently from "f". The
+  code should explain it.
+*/
+define brentsolve2(low, high,which,eps){
+  local a b c d fa fb fc fa2 fb2 fc2 s fs  tmp tmp2  mflag i places;
+  a = low;
+  b = high;
+  c = 0;
+
+  switch(param(0)){
+    case 0:
+    case 1: return newerror("brentsolve2: not enough arguments");
+    case 2: eps = epsilon(epsilon()*1e-2);
+            which = 0;break;
+    case 3: eps = epsilon(epsilon()*1e-2);break;
+    default: break;
+  };
+  places = highbit(1 + int(1/epsilon())) + 1;
+
+  d = 1/eps;
+
+  switch(which){
+    case 1:  fa = __CZ__invbeta(a);
+             fb = __CZ__invbeta(b); break;
+    case 2:  fa = __CZ__invincgamma(a);
+             fb = __CZ__invincgamma(b); break;
+
+    default: fa = f(a);fb = f(b);   break;
+  };
+
+  fc = 0;
+  s = 0;
+  fs = 0;
+
+  if(fa * fb >= 0){
+    if(fa < fb)
+      return a;
+    else
+      return b;
+  }
+
+  if(abs(fa) < abs(fb)){
+    tmp = a; a = b; b = tmp;
+    tmp = fa; fa = fb; fb = tmp;
+  }
+
+  c = a;
+  fc = fa;
+  mflag = 1;
+  i = 0;
+
+  while(!(fb==0) && (abs(a-b) > eps)){
+
+    if((fa != fc) && (fb != fc)){
+      /* Inverse quadratic interpolation*/
+      fc2 = fc^2;
+      fa2 = fa^2;
+      s = bround(((fb^2*((fc*a)-(c*fa)))+(fb*((c*fa2)-(fc2*a)))+(b*((fc2*fa)
+                    -(fc*fa2))))/((fc - fb)*(fa - fb)*(fc - fa)),places);
+      places++;
+    }
+    else{
+      /* Secant Rule*/
+      s =bround( b - fb * (b - a) / (fb - fa),places);
+      places++;
+    }
+    tmp2 = (3 * a + b) / 4;
+    if( (!( ((s > tmp2) && (s < b))||((s < tmp2) && (s > b))))
+        || (mflag && (abs(s - b) >= (abs(b - c) / 2)))
+        || (!mflag && (abs(s - b) >= (abs(c - d) / 2)))) {
+      s = (a + b) / 2;
+      mflag = true;
+    }
+    else{
+      if( (mflag && (abs(b - c) < eps))
+          || (!mflag && (abs(c - d) < eps))) {
+        s = (a + b) / 2;
+        mflag = true;
+      }
+      else
+        mflag = false;
+    }
+    switch(which){
+      case 1:  fs = __CZ__invbeta(s); break;
+      case 2:  fs = __CZ__invincgamma(s); break;
+
+      default: fs = f(s);             break;
+    };
+    c = b;
+    fc = fb;
+    if (fa * fs < 0){
+      b = s;
+      fb = fs;
+    }
+    else {
+      a = s;
+      fa = fs;
+    }
+
+    if (abs(fa) < abs(fb)){
+      tmp = a; a = b; b = tmp;
+      tmp = fa; fa = fb; fb = tmp;
+    }
+    i++;
+    if (i > 1000){
+      return newerror("brentsolve2: does not converge");
+    }
+  }
+  return b;
+}
+
+
+/*
+ * restore internal function from resource debugging
+ */
+config("resource_debug", resource_debug_level),;
+if (config("resource_debug") & 3) {
+    print "brentsolve(low, high,eps)";
+    print "brentsolve2(low, high,which,eps)";
+}

cal/chi.cal

@@ -0,0 +1,247 @@
+/*
+ * chi - chi^2 probabilities with degrees of freedom for null hypothesis
+ *
+ * Copyright (C) 2001,2021  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.
+ *
+ * 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]) asymptotic 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";
+    }
+
+    /*
+     * approximate 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 sufficiently small error term as the degrees 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;            /* denominator (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,7 +1,7 @@
 /*
- * chrem - chinese remainder theorem/problem solver
+ * chrem - Chinese remainder theorem/problem solver
  *
- * Copyright (C) 1999  Ernest Bowen and Landon Curt Noll
+ * Copyright (C) 1999,2021  Ernest Bowen and Landon Curt Noll
  *
  * Primary author:  Ernest Bowen
  *
@@ -11,45 +11,41 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: chrem.cal,v 29.1 1999/12/14 09:15:31 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
  *
- * Under source code control:	1992/09/26 01:00:47
- * File existed as early as:	1992
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
- * When possible, chrem finds solutions for x of a set of congruences
+ * When possible, chrem finds solutions for x of a set of congruence
  * of the form:
  *
- *			x = r1 (mod m1)
- *			x = r2 (mod m2)
- *			   ...
+ *                      x = r1 (mod m1)
+ *                      x = r2 (mod m2)
+ *                         ...
  *
  * 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, ...
+ * m1, m2, ... are relatively prime in pairs, the above congruence
+ * 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.
  *
@@ -57,19 +53,19 @@
  *
  * usage:
  *
- *	chrem(r1,m1 [,r2,m2, ...])
+ *      chrem(r1,m1 [,r2,m2, ...])
  *
- *	    r1, r2, ...		remainder integers or null values
- *	    m1, m2, ...		moduli integers
+ *          r1, r2, ...         remainder integers or null values
+ *          m1, m2, ...         moduli integers
  *
- *	chrem(r_list, [m_list])
+ *      chrem(r_list, [m_list])
  *
- *	    r_list	list (r1,r2, ...)
- *	    m_list	list (m1,m2, ...)
+ *          r_list      list (r1,r2, ...)
+ *          m_list      list (m1,m2, ...)
  *
- *	    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.
+ *          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.
  *
  * If a remainder is null(), then the corresponding congruence is
  * ignored.  This is useful when working with a fixed list of moduli.
@@ -79,17 +75,17 @@
  *
  * 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:
  *
- *	  (r, m)	('r' and 'm' are defined above, see [[NOTE 1]])
+ *        (r, m)        ('r' and 'm' are defined above, see [[NOTE 1]])
  *
  * NOTE: In all cases, null() is returned if there is no solution.
  *
@@ -99,20 +95,20 @@
  *
  *   Sun-Tsu, 1st century A.D.
  *
- *	To find a number for which the reminders after division by 3, 5, 7
- *	are 2, 3, 2, respectively:
+ *      To find a number for which the reminders after division by 3, 5, 7
+ *      are 2, 3, 2, respectively:
  *
- *	    chrem(2,3,3,5,2,7) ---> 23
+ *          chrem(2,3,3,5,2,7) ---> 23
  *
  *   Fibonacci, 13th century A.D.
  *
- *	To find a number divisible by 7 which leaves remainder 1 when
- *	divided by 2, 3, 4, 5, or 6:
+ *      To find a number divisible by 7 which leaves remainder 1 when
+ *      divided by 2, 3, 4, 5, or 6:
  *
  *
- *	    chrem(list(0,1,1,1,1,1),list(7,2,3,4,5,6)) ---> (301,420)
+ *          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.
+ *      i.e., any value that is 301 mod 420.
  */
 
 
@@ -120,10 +116,10 @@ static defaultmlist = list(2,3,5,7,11,13,17,19); /* The first eight primes */
 
 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 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 m,z,r,y,d,t,x,u,i;
 
     /*
@@ -131,25 +127,25 @@ define chrem()
      */
     argc = param(0);
     if (argc == 0) {
-	quit "usage: chrem(r1,m1 [,r2,m2 ...]) or chrem(r_list, m_list)";
+        quit "usage: chrem(r1,m1 [,r2,m2 ...]) or chrem(r_list, m_list)";
     }
     list_args = islist(param(1));
     if (list_args) {
-	rlist = param(1);
-	mlist = (argc == 1) ? defaultmlist : param(2);
-	if (size(rlist) > size(mlist)) {
-	    quit "too many residues";
-	}
+        rlist = param(1);
+        mlist = (argc == 1) ? defaultmlist : param(2);
+        if (size(rlist) > size(mlist)) {
+            quit "too many residues";
+        }
     } else {
-	if (argc % 2 == 1) {
-	    quit "odd number integers given";
-	}
-	rlist = list();
-	mlist = list();
-	for (i=1; i <= argc; i+=2) {
-	    push(rlist, param(i));
-	    push(mlist, param(i+1));
-	}
+        if (argc % 2 == 1) {
+            quit "odd number integers given";
+        }
+        rlist = list();
+        mlist = list();
+        for (i=1; i <= argc; i+=2) {
+            push(rlist, param(i));
+            push(mlist, param(i+1));
+        }
     }
 
     /*
@@ -158,46 +154,46 @@ define chrem()
     m = 1;
     z = 0;
     while (size(rlist)) {
-	r=pop(rlist);
-	y=abs(pop(mlist));
-	if (r==null())
-	    continue;
-	if (m) {
-	    if (y) {
-		d = t = z - r;
-		m = lcm(x=m, y);
-		while (d % y) {
-		    u = x;
-		    x %= y;
-		    swap(x,y);
-		    if (y==0)
-			return;
-		    z += (t *= -u/y);
-		}
-	    } else {
-		if ((r % m) != (z % m))
-		    return;
-		else {
-		    m = 0;
-		    z = r;
-		}
-	    }
-	} else if (((y) && (r % y != z % y)) || (r != z))
-	    return;
+        r=pop(rlist);
+        y=abs(pop(mlist));
+        if (r==null())
+            continue;
+        if (m) {
+            if (y) {
+                d = t = z - r;
+                m = lcm(x=m, y);
+                while (d % y) {
+                    u = x;
+                    x %= y;
+                    swap(x,y);
+                    if (y==0)
+                        return;
+                    z += (t *= -u/y);
+                }
+            } else {
+                if ((r % m) != (z % m))
+                    return;
+                else {
+                    m = 0;
+                    z = r;
+                }
+            }
+        } else if (((y) && (r % y != z % y)) || (r != z))
+            return;
     }
     if (m) {
-	z %= m;
-	if (z < 0)
-	    z += m;
+        z %= m;
+        if (z < 0)
+            z += m;
     }
 
     /*
      * return information as required
      */
     if (list_args) {
-	return list(z,m);
+        return list(z,m);
     } else {
-	return z;
+        return z;
     }
 }
 

cal/comma.cal

@@ -0,0 +1,437 @@
+/*
+ * comma - convert numbers into strings with 3-digit group and integer-fraction separators
+ *
+ * Convert numbers into strings with 3-digit group and integer-fraction separators.
+ *
+ * If the value is an integer, the integer-fraction separator is not used.
+ *
+ * str_comma(x, [group, [decimal]])
+ *
+ *      Convert x into a string.
+ *
+ *      If group is given and is a string, group will be used as
+ *      the 3-digit group separator, otherwise the default 3-digit
+ *      group separator will be used.
+ *
+ *      If decimal is given and is a string, group will be used as
+ *      the integer-fraction separator, otherwise the default
+ *      integer-fraction separator will be used.
+ *
+ *      The decimal and group arguments are optional.
+ *
+ * set_default_group_separator(group)
+ *
+ *      Change the default 3-digit group separator if group is a string,
+ *      otherwise the default 3-digit group separator will not be
+ *      changed.  Return the old 3-digit group separator.
+ *
+ * set_default_decimal_separator(decimal)
+ *
+ *      Change the default 3-digit group separator if decimal is a
+ *      string, otherwise the default integer-fraction separator
+ *      will not be changed.  Return the old integer-fraction separator.
+ *
+ * print_comma(x, [group, [decimal]])
+ *
+ *      Print the value produced by str_comma(x, [group, [decimal]])
+ *      followed by a newline.
+ *
+ *      If the str_comma() does not return a string, nothing is printed.
+ *
+ *      The decimal and group arguments are optional.
+ *
+ *      The value produced by str_comma() is returned.
+ *
+ * fprint_comma(fd, x, [group, [decimal]])
+ *
+ *      Print the value produced by str_comma(x, [group, [decimal]]),
+ *      without a trailing newline, on file fd.
+ *
+ *      If the str_comma() does not return a string, nothing is printed.
+ *
+ *      If fd is not an open file, nothing is printed.
+ *
+ *      The decimal and group arguments are optional.
+ *
+ *      The value produced by str_comma() is returned.
+ *
+ * Copyright (C) 2022  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.
+ *
+ * Under source code control:   2022/06/20 15:51:49
+ * File existed as early as:    2022
+ *
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+static default_group_separator = ",";   /* default 3-digit group separator */
+static default_decimal_separator = "."; /* default integer-fraction separator */
+
+
+/*
+ * str_comma - convert number into base 10 string with 3-digit groups and integer-fraction separator
+ *
+ *
+ * This function converts a real number into a base 10 string, where
+ * groups of 3 digits are separated by a 3-digit group separator and
+ * a integer-fraction separator is printed between integer and decimal fraction.
+ *
+ * For example:
+ *
+ *      string = str_comma(x);
+ *      string = str_comma(x), " ", ".");
+ *      string = str_comma(x), ".", ",");
+ *
+ * Internally the function calls:
+ *
+ *     strprintf("%f", x);
+ *
+ * and thus the number of decimal fraction digits is subject to
+ * the display() or config("display") value.  See:
+ *
+ *     man display
+ *
+ * for details.
+ *
+ * given:
+ *
+ *      x               number to convert
+ *
+ * optional args:
+ *
+ *      group           use this 3-digit group separator
+ *      decimal         use this integer-fraction separator
+ *
+ * returns:
+ *
+ *      string containing the base 10 digits with group and decimal separators, OR
+ *      null() if x is not a number, OR
+ *      null() if group is neither null() (not given) nor a string, OR
+ *      null() if group is null() (not given) AND default_group_separator is not a string, OR
+ *      null() if decimal is neither null() (not given) nor a string, OR
+ *      null() if decimal is null() (not given) AND default_decimal_separator is not a string.
+ */
+define str_comma(x, group, decimal)
+{
+    local group_separator;      /* 3-digit group separator */
+    local decimal_separator;    /* separator between decimal integer and decimal fraction */
+    local sign_str;             /* leading - if x < 0 or empty if x >= 0 */
+    local integer;              /* integer part of absolute value of x */
+    local int_str;              /* integer as a string */
+    local int_len;              /* number of digits in int_str */
+    local first_group_len;      /* length of 1st group before the 1st 3-digit group separator */
+    local fraction;             /* factional part of absolute value of x */
+    local frac_str;             /* fraction as a string */
+    local frac_len;             /* number of digits in frac_str including leading 0. */
+    local ret;                  /* string to return */
+    local config_leadzero;      /* config("leadzero") to restore */
+    local config_tilde;         /* config("tilde") to restore */
+    local i;
+
+    /*
+     * parse args - return null if args are bogus
+     *
+     * Return null() if args or conditions are bogus.
+     */
+    if (!isreal(x)) {
+        return null();
+    }
+    group_separator = isnull(group) ? default_group_separator : group;
+    decimal_separator = isnull(decimal) ? default_decimal_separator : decimal;
+    if (!isstr(group_separator)) {
+        return null();
+    }
+    if (!isstr(decimal_separator)) {
+        return null();
+    }
+
+    /*
+     * split number
+     */
+    if (x < 0) {
+        sign_str = "-";
+        integer = int(-x);
+        fraction = frac(-x);
+    } else {
+        sign_str = "";
+        integer = int(x);
+        fraction = frac(x);
+    }
+    ret = sign_str;
+
+    /*
+     * convert digits
+     *
+     * Avoid printing ~ and leading zeros for factional part.
+     */
+    int_str = strprintf("%d", integer);
+    config_leadzero = config("leadzero", 0);
+    config_tilde = config("tilde", 0);
+    frac_str = strprintf("%d", fraction);
+    config("leadzero", config_leadzero),;
+    config("tilde", config_tilde),;
+
+    /*
+     * determine number of digits in the integer part
+     */
+    int_len = strlen(int_str);
+    frac_len = strlen(frac_str);
+
+    /*
+     * form integer part with group separators as needed
+     */
+
+    /*
+     * case: integer is 3 or fewer digits
+     */
+    if (integer < 1000) {
+        ret += int_str;
+
+    /*
+     * case: integer is 4 or more digits
+     */
+    } else {
+
+        /*
+         * form a decimal string using group separators
+         */
+
+        /*
+         * form the initial leading digits before 1st group separator
+         */
+        first_group_len = int_len % 3;
+        if (first_group_len == 0) {
+            first_group_len = 3;
+        }
+        ret += substr(int_str, 1, first_group_len);
+
+        /*
+         * until end of digits, print group separator followed by 3 more digits
+         */
+        for (i = first_group_len+1; i < int_len; i += 3) {
+            ret += group_separator + substr(int_str, i, 3);
+        }
+    }
+
+    /*
+     * form fractional part using decimal separator as needed
+     */
+
+    /*
+     * case: x is an integer
+     */
+    if (fraction == 0) {
+
+        /* no fraction, nothing more to do */
+
+    /*
+     * case: x is not an integer
+     */
+    } else {
+
+        /*
+         * add integer-fraction separator
+         */
+        ret += decimal_separator;
+
+        /*
+         * add remaining digits
+         *
+         * Skip over the leading 0. in frac_str
+         */
+        ret += substr(frac_str, 2, frac_len-1);
+    }
+
+    /*
+     * All Done!!! -- Jessica Noll, Age 2
+     */
+    return ret;
+}
+
+
+/*
+ * set_default_group_separator - change the default 3-digit group separator
+ *
+ * If group is not a string, then the default 3-digit group separator
+ * is not changed.  Thus, this will only return the default 3-digit group separator:
+ *
+ *      set_default_group_separator(null());
+ *
+ * given:
+ *
+ *      group           3-digit group separator
+ *
+ * returns:
+ *
+ *      previous 3-digit group separator value
+ */
+define set_default_group_separator(group)
+{
+    local old_default_group_separator;          /* previous default 3-digit group separator to return */
+
+    /*
+     * save current 3-digit group separator
+     */
+    old_default_group_separator = default_group_separator;
+
+    /*
+     * change 3-digit group separator if group is a string
+     */
+    if (isstr(group)) {
+        default_group_separator = group;
+    }
+    return old_default_group_separator;
+}
+
+
+/*
+ * set_default_decimal_separator - change the default integer-fraction separator
+ *
+ * If decimal is not a string, then the default integer-fraction separator
+ * is not changed.  Thus, this will only return the integer-fraction separator:
+ *
+ *      set_default_decimal_separator(null());
+ *
+ * given:
+ *
+ *      decimal         separator between decimal integer and decimal fraction (def: ".")
+ *
+ * returns:
+ *
+ *      previous integer-fraction separator value
+ */
+define set_default_decimal_separator(decimal)
+{
+    local old_default_decimal_separator;        /* previous default integer-fraction separator */
+
+    /*
+     * save current integer-fraction separator
+     */
+    old_default_decimal_separator = default_decimal_separator;
+
+    /*
+     * change 3-digit decimal integer-fraction if decimal is a string
+     */
+    if (isstr(decimal)) {
+        default_decimal_separator = decimal;
+    }
+    return old_default_decimal_separator;
+}
+
+
+/*
+ * print_comma - print base 10 string with 3-digit group separators & integer-fraction separator + newline
+ *
+ * This function prints the result of str_comma(x, group, decimal) followed by a newline.
+ * For example:
+ *
+ *      print_comma(x);
+ *      print_comma(x), " ", ".");
+ *      print_comma(x), ".", ",");
+ *
+ * If str_comma() does not return a string, this function prints nothing.
+ *
+ * NOTE: To print without a newline, use fprint_comma(fd, x, group, decimal).
+ *
+ * given:
+ *      x               number to convert
+ *
+ * optional args:
+ *
+ *      group           use this 3-digit group separator
+ *      decimal         use this integer-fraction separator
+ *
+ * returns:
+ *
+ *      string containing the base 10 digits with group and decimal separators, OR
+ *      null() if x is not a number, OR
+ *      null() if group is neither null() (not given) nor a string, OR
+ *      null() if group is null() (not given) AND default_group_separator is not a string, OR
+ *      null() if decimal is neither null() (not given) nor a string, OR
+ *      null() if decimal is null() (not given) AND default_decimal_separator is not a string.
+ */
+define print_comma(x, group, decimal)
+{
+    local ret;          /* base 10 string with 3-digit group and integer-fraction separators */
+
+    /*
+     * convert to string
+     */
+    ret = str_comma(x, group, decimal);
+
+    /*
+     * print converted string
+     */
+    if (isstr(ret)) {
+        printf("%s\n", ret);
+    }
+    return ret;
+}
+
+
+/*
+ * fprint_comma - print base 10 string with 3-digit group separators & integer-fraction separator w/o newline
+ *
+ * This function prints the result of str_comma(x, group, decimal) on an open file, without a trailing newline.
+ * For example:
+ *
+ *      fprint_comma(files(1), x);
+ *      fprint_comma(fd, x), " ", ".");
+ *      fprint_comma(files(2), x), ".", ",");
+ *
+ * If str_comma() does not return a string, this function prints nothing.
+ *
+ * This function flushes output to the open file before returning.
+ *
+ * NOTE: To print with a newline, use print_comma(x, group, decimal).
+ *
+ * given:
+ *      fd              open file
+ *      x               number to convert
+ *
+ * optional args:
+ *
+ *      group           use this 3-digit group separator
+ *      decimal         use this integer-fraction separator
+ *
+ * returns:
+ *
+ *      string containing the base 10 digits with group and integer-fraction separators, OR
+ *      null() if x is not a number, OR
+ *      null() if group is neither null() (not given) nor a string, OR
+ *      null() if group is null() (not given) AND default_group_separator is not a string, OR
+ *      null() if decimal is neither null() (not given) nor a string, OR
+ *      null() if decimal is null() (not given) AND default_decimal_separator is not a string.
+ */
+define fprint_comma(fd, x, group, decimal)
+{
+    local ret;          /* base 10 string with 3-digit group and integer-fraction separators */
+
+    /*
+     * convert to string
+     */
+    ret = str_comma(x, group, decimal);
+
+    /*
+     * print converted string
+     */
+    if (isstr(ret) && isfile(fd)) {
+        fprintf(fd, "%s", ret);
+        fflush(fd);
+    }
+    return ret;
+}

cal/constants.cal

@@ -0,0 +1,100 @@
+/*
+ * constants - implementation of different constants to arbitrary precision
+ *
+ * Copyright (C) 2013 Christoph Zurnieden
+ *
+ * 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.
+ *
+ * Under source code control:   2013/08/11 01:31:28
+ * File existed as early as:    2013
+ */
+
+
+static resource_debug_level;
+resource_debug_level = config("resource_debug", 0);
+
+
+static __CZ__euler_mascheroni = 0;
+static __CZ__euler_mascheroni_prec = 0;
+
+
+define e(){
+  local k temp1 temp2 ret eps factor upperlimit prec;
+
+  prec = digits(1/epsilon());
+  if(__CZ__euler_mascheroni != 0 &&  __CZ__euler_mascheroni_prec >= prec)
+    return __CZ__euler_mascheroni;
+  if(prec<=20) return 2.718281828459045235360287471;
+  if(prec<=1800){
+    __CZ__euler_mascheroni = exp(1);
+    __CZ__euler_mascheroni_prec = prec;
+  }
+
+  eps=epsilon(1e-20);
+  factor = 1;
+  k = 0;
+  upperlimit = prec * ln(10);
+  while(k<upperlimit){
+    k += ln(factor);
+    factor++;
+  }
+  epsilon(eps);
+  temp1 = 0;
+  ret   = 1;
+  for(k=3;k<=factor;k++){
+    temp2 = temp1;
+    temp1 = ret;
+    ret =  (k-1) *(temp1 + temp2);
+  }
+
+  ret = inverse( ret * inverse(factorial(factor) ) ) ;
+  __CZ__euler_mascheroni = ret;
+  __CZ__euler_mascheroni_prec = prec;
+  return ret;
+}
+
+
+/* Lupas' series */
+static __CZ__catalan = 0;
+static __CZ__catalan_prec = 0;
+define G(){
+  local eps a s t n;
+  eps = epsilon(epsilon()*1e-10);
+  if(__CZ__catalan != 0 &&  __CZ__catalan >= log(1/eps))
+    return __CZ__catalan;
+  a = 1;
+  s = 0;
+  t = 1;
+  n = 1;
+  while(abs(t)> eps){
+    a *= 32 * n^3 * (2*n-1);
+    a /=((3-16*n+16*n^2)^2);
+    t = a * (-1)^(n-1) * (40*n^2-24*n+3) / (n^3 * (2*n-1));
+    s += t;
+    n += 1;
+  }
+  s = s/64;
+  __CZ__catalan = s;
+  __CZ__catalan_prec = log(1/eps);
+  epsilon(eps);
+  return s;
+}
+
+
+config("resource_debug", resource_debug_level),;
+if (config("resource_debug") & 3) {
+    print "e()";
+    print "G()";
+}

cal/deg.cal

@@ -9,130 +9,126 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: deg.cal,v 29.1 1999/12/14 09:15:31 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
  *
- * Under source code control:	1990/02/15 01:50:33
- * File existed as early as:	before 1990
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 
-obj dms {deg, min, sec};
+obj deg {deg, min, sec};
 
-define dms(deg, min, sec)
+define deg(deg, min, sec)
 {
-	local ans;
+        local ans;
 
-	if (isnull(sec))
-		sec = 0;
-	if (isnull(min))
-		min = 0;
-	obj dms ans;
-	ans.deg = deg;
-	ans.min = min;
-	ans.sec = sec;
-	fixdms(&ans);
-	return 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 dms_add(a, b)
+define deg_add(a, b)
 {
-	local obj dms	ans;
+        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;
-	fixdms(&ans);
-	return 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 dms_neg(a)
+define deg_neg(a)
 {
-	local obj dms	ans;
+        local obj deg   ans;
 
-	ans.deg = -ans.deg;
-	ans.min = -ans.min;
-	ans.sec = -ans.sec;
-	return ans;
+        ans.deg = -a.deg;
+        ans.min = -a.min;
+        ans.sec = -a.sec;
+        return ans;
 }
 
 
-define dms_sub(a, b)
+define deg_sub(a, b)
 {
-	return a - b;
+        return a - b;
 }
 
 
-define dms_mul(a, b)
+define deg_mul(a, b)
 {
-	local obj dms	ans;
+        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;
-	}
-	fixdms(&ans);
-	return 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 dms_print(a)
+define deg_print(a)
 {
-	print a.deg : 'd' : a.min : 'm' : a.sec : 's' :;
+        print a.deg : 'd' : a.min : 'm' : a.sec : 's' :;
 }
 
 
-define dms_abs(a)
+define deg_abs(a)
 {
-	return a.deg + a.min / 60 + a.sec / 3600;
+        return a.deg + a.min / 60 + a.sec / 3600;
 }
 
 
-define fixdms(a)
+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;
+        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 dms {deg, min, sec} defined";
+    print "obj deg {deg, min, sec} defined";
 }

cal/dms.cal

@@ -0,0 +1,364 @@
+/*
+ * dms - calculate in degrees, minutes, and seconds (based on deg)
+ *
+ * Copyright (C) 1999,2010,2021  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.
+ *
+ * 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 */
+
+    /* initialize 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 */
+
+    /* initialize 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";
+    }
+
+    /* use builtin d2dms function */
+    d2dms(a.deg + a.min/60 + a.sec/3600, a.deg, a.min, a.sec),;
+
+    /* return normalized result */
+    return a;
+}
+
+if (config("resource_debug") & 3) {
+    print "obj dms {deg, min, sec} defined";
+}

cal/dotest.cal

@@ -0,0 +1,207 @@
+/*
+ * 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 file is not covered under version 2.1 of the GNU LGPL.
+ * This file is covered under "The unlicense":
+ *
+ *      https://unlicense.org
+ *
+ * In particular:
+ *
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * For more information, please refer to <http://unlicense.org/>
+ *
+ * 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);
+    }
+
+    /*
+     * prepare 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,7 +1,7 @@
 /*
  * ellip - attempt to factor numbers using elliptic functions
  *
- * Copyright (C) 1999  David I. Bell
+ * Copyright (C) 1999,2023  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
@@ -9,35 +9,32 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: ellip.cal,v 29.1 1999/12/14 09:15:31 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
  *
- * Under source code control:	1990/02/15 01:50:33
- * File existed as early as:	before 1990
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * 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 N).
+ * Attempt to factor numbers using elliptic functions:
  *
- * Many points (x,y) (mod N) are found that solve the above equation,
+ *      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
- * varies almost randomly within a certain interval for each choice of 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
+ * order contains a common factor with ellip_N.  The order of the group of
+ * points varies almost randomly within a certain interval for each choice of
+ * a and b, and thus each choice provides an independent opportunity to
+ * 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
@@ -45,18 +42,18 @@
  * 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
- * only an approximation, read "A Course in Number Theory and Cryptography"
- * by Neal Koblitz for a good explanation.
+ * of the failing value and ellip_N provides a factor of ellip_N.
+ * This description is only an approximation, read "A Course in Number
+ * Theory and Cryptography" by Neal Koblitz for a good explanation.
  *
  * 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).
- *	B is the limit of the primes that make up the high power that the
- *	point is raised to for each factoring attempt (default 100).
- *	force is a flag to attempt to factor numbers even if they are
- *	thought to already be prime (default FALSE).
+ *      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).
+ *      B is the limit of the primes that make up the high power that the
+ *      point is raised to for each factoring attempt (default 100).
+ *      force is a flag to attempt to factor numbers even if they are
+ *      thought to already be prime (default false).
  *
  * Making B larger makes the power the point being raised to contain more
  * prime factors, thus increasing the chance that the order of the point
@@ -80,114 +77,114 @@
  * 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 N.
+ * variable f.  The number being factored is also saved in the global
+ * variable ellip_N.
  */
 
 
 obj point {x, y};
-global	N;		/* number to factor */
-global	a;		/* first coefficient */
-global	b;		/* second coefficient */
-global	f;		/* found factor */
+global  ellip_N;                /* number to factor */
+global  ellip_a;                /* first coefficient */
+global  ellip_b;                /* second coefficient */
+global  ellip_f;                /* found factor */
 
 
 define efactor(iN, ia, B, force)
 {
-	local	C, x, p;
+        local   C, x, p;
 
-	if (!force && ptest(iN, 50))
-		return 1;
-	if (isnull(B))
-		B = 100;
-	if (isnull(ia))
-		ia = 1;
-	obj point x;
-	a = ia;
-	b = -ia;
-	N = iN;
-	C = isqrt(N);
-	C = 2 * C + 2 * isqrt(C) + 1;
-	f = 0;
-	while (f == 0) {
-		print "A =", 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) {
-			if (!ptest(p, 1))
-				continue;
-			print p, x;
-			x = x ^ (p ^ ((highbit(C) // highbit(p)) + 1));
-		}
-		a++;
-		b--;
-	}
-	return f;
+        if (!force && ptest(iN, 50))
+                return 1;
+        if (isnull(B))
+                B = 100;
+        if (isnull(ia))
+                ia = 1;
+        obj point x;
+        ellip_a = ia;
+        ellip_b = -ia;
+        ellip_N = iN;
+        C = isqrt(ellip_N);
+        C = 2 * C + 2 * isqrt(C) + 1;
+        ellip_f = 0;
+        while (ellip_f == 0) {
+                print "A =", ellip_a;
+                x.x = 1;
+                x.y = 1;
+                print 2, x;
+                x = x ^ (2 ^ (highbit(C) + 1));
+                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));
+                }
+                ellip_a++;
+                ellip_b--;
+        }
+        return ellip_f;
 }
 
 
 define point_print(p)
 {
-	print "(" : p.x : "," : p.y : ")" :;
+        print "(" : p.x : "," : p.y : ")" :;
 }
 
 
 define point_mul(p1, p2)
 {
-	local	r, m;
+        local   r, m;
 
-	if (p2 == 1)
-		return p1;
-	if (p1 == p2)
-		return point_square(&p1);
-	obj point r;
-	m = (minv(p2.x - p1.x, N) * (p2.y - p1.y)) % N;
-	if (m == 0) {
-		if (f == 0)
-			f = gcd(p2.x - p1.x, N);
-		r.x = 1;
-		r.y = 1;
-		return r;
-	}
-	r.x = (m^2 - p1.x - p2.x) % N;
-	r.y = ((m * (p1.x - r.x)) - p1.y) % N;
-	return r;
+        if (p2 == 1)
+                return p1;
+        if (p1 == p2)
+                return point_square(`p1);
+        obj point r;
+        m = (minv(p2.x - p1.x, ellip_N) * (p2.y - p1.y)) % ellip_N;
+        if (m == 0) {
+                if (ellip_f == 0)
+                        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) % ellip_N;
+        r.y = ((m * (p1.x - r.x)) - p1.y) % ellip_N;
+        return r;
 }
 
 
 define point_square(p)
 {
-	local	r, m;
+        local   r, m;
 
-	obj point r;
-	m = ((3 * p.x^2 + a) * minv(p.y << 1, N)) % N;
-	if (m == 0) {
-		if (f == 0)
-			f = gcd(p.y << 1, N);
-		r.x = 1;
-		r.y = 1;
-		return r;
-	}
-	r.x = (m^2 - p.x - p.x) % N;
-	r.y = ((m * (p.x - r.x)) - p.y) % N;
-	return r;
+        obj point r;
+        m = ((3 * p.x^2 + ellip_a) * minv(p.y << 1, ellip_N)) % ellip_N;
+        if (m == 0) {
+                if (ellip_f == 0)
+                        ellip_f = gcd(p.y << 1, ellip_N);
+                r.x = 1;
+                r.y = 1;
+                return r;
+        }
+        r.x = (m^2 - p.x - p.x) % ellip_N;
+        r.y = ((m * (p.x - r.x)) - p.y) % ellip_N;
+        return r;
 }
 
 
 define point_pow(p, pow)
 {
-	local bit, r, t;
+        local bit, r, t;
 
-	r = 1;
-	if (isodd(pow))
-		r = p;
-	t = p;
-	for (bit = 2; ((bit <= pow) && (f == 0)); bit <<= 1) {
-		t = point_square(&t);
-		if (bit & pow)
-			r = point_mul(&t, &r);
-	}
-	return r;
+        r = 1;
+        if (isodd(pow))
+                r = p;
+        t = p;
+        for (bit = 2; ((bit <= pow) && (ellip_f == 0)); bit <<= 1) {
+                t = point_square(`t);
+                if (bit & pow)
+                        r = point_mul(`t, `r);
+        }
+        return r;
 }

cal/factorial.cal

@@ -0,0 +1,200 @@
+/*
+ * factorial - implementation of different algorithms for the factorial
+ *
+ * Copyright (C) 2013 Christoph Zurnieden
+ *
+ * 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.
+ *
+ * Under source code control:   2013/08/11 01:31:28
+ * File existed as early as:    2013
+ */
+
+
+/*
+ * hide internal function from resource debugging
+ */
+static resource_debug_level;
+resource_debug_level = config("resource_debug", 0);
+
+
+/*
+  get dependencies
+*/
+read -once toomcook;
+
+
+/* A simple list to keep things...uhm...simple?*/
+static __CZ__primelist = list();
+
+/* Helper for primorial: fill list with primes in range a,b */
+define __CZ__fill_prime_list(a,b)
+{
+  local k;
+  k=a;
+  if(isprime(k))k--;
+  while(1){
+    k = nextprime(k);
+    if(k > b) break;
+    append(__CZ__primelist,k );
+  }
+}
+
+/* Helper for factorial: how often prime p divides the factorial of n */
+define __CZ__prime_divisors(n,p)
+{
+    local q,m;
+    q = n;
+    m = 0;
+    if (p > n) return 0;
+    if (p > n/2) return 1;
+    while (q >= p) {
+        q  = q//p;
+        m += q;
+    }
+    return m;
+}
+
+/*
+  Wrapper. Please set cut-offs to own taste and hardware.
+*/
+define factorial(n){
+  local prime result shift prime_list k k1 k2 expo_list pix cut primorial;
+
+  result = 1;
+  prime  = 2;
+
+  if(!isint(n))  {
+    return newerror("factorial(n): n is not an integer"); ## or gamma(n)?
+  }
+  if(n < 0)      return newerror("factorial(n): n < 0");
+  if(n < 9000 && !isdefined("test8900"))   {
+    ## builtin is implemented with splitting but only with
+    ## Toom-Cook 2 (by Karatsuba (the father))
+    return n!;
+  }
+
+  shift = __CZ__prime_divisors(n,prime);
+  prime = 3;
+  cut = n//2;
+  pix   = pix(cut);
+  prime_list = mat[pix];
+  expo_list  = mat[pix];
+
+  k = 0;
+/*
+  Peter Borwein's algorithm
+
+  @Article{journals/jal/Borwein85,
+  author = {Borwein, Peter B.},
+  title  = {On the Complexity of Calculating Factorials.},
+  journal = {J. Algorithms},
+  year   = {1985},
+  number = {3},
+  url    = {http://dblp.uni-trier.de/db/journals/jal/jal6.html#Borwein85}
+*/
+
+  do {
+    prime_list[k]  = prime;
+    expo_list[k++] = __CZ__prime_divisors(n,prime);
+    prime          = nextprime(prime);
+  }while(prime <= cut);
+
+  /* size of the largest exponent in bits  */
+  k1 = highbit(expo_list[0]);
+  k2 = size(prime_list)-1;
+
+  for(;k1>=0;k1--){
+    /*
+       the cut-off for T-C-4 ist still to low, using T-C-3 here
+       TODO: check cutoffs
+     */
+    result = toomcook3square(result);
+    /*
+      almost all time is spend in this loop, so cutting of the
+      upper half of the primes makes sense
+    */
+    for(k=0; k<=k2; k++) {
+      if((expo_list[k] & (1 << k1)) != 0) {
+        result *= prime_list[k];
+      }
+    }
+
+  }
+  primorial = primorial( cut, n);
+  result *= primorial;
+  result <<= shift;
+  return result;
+}
+
+/*
+  Helper for primorial: do the product with binary splitting
+  TODO: do it without the intermediate list
+*/
+define __CZ__primorial__lowlevel( a, b ,p)
+{
+  local  c;
+  if( b == a) return p ;
+  if( b-a > 1){
+    c= (b + a) >> 1;
+    return  __CZ__primorial__lowlevel( a   , c , __CZ__primelist[a] )
+         *  __CZ__primorial__lowlevel( c+1 , b , __CZ__primelist[b] ) ;
+  }
+  return  __CZ__primelist[a] * __CZ__primelist[b];
+}
+
+/*
+   Primorial, Product of consecutive primes in range a,b
+
+  Originally meant to do primorials with a start different from 2, but
+  found out that this is faster at about a=1,b>=10^5 than the builtin
+  function pfact().  With the moderately small list a=1,b=10^6 (78498
+  primes) it is 3 times faster.  A quick look-up showed what was already
+  guessed: pfact() does it linearly.  (BTW: what is the time complexity
+  of the primorial with the naive algorithm?)
+*/
+define primorial(a,b)
+{
+  local C1 C2;
+  if(!isint(a)) return newerror("primorial(a,b): a is not an integer");
+  else if(!isint(b)) return newerror("primorial(a,b): b is not an integer");
+  else if(a < 0) return newerror("primorial(a,b): a < 0");
+  else if( b < 2 ) return newerror("primorial(a,b): b < 2");
+  else if( b < a) return newerror("primorial(a,b): b < a");
+  else{
+    /* last prime < 2^32 is also  max. prime for nextprime()*/
+    if(b >= 4294967291) return newerror("primorial(a,b): max. prime exceeded");
+    if(b ==  2) return 2;
+    /*
+      Can be extended by way of pfact(b)/pfact(floor(a-1/2)) for small a
+     */
+    if(a<=2 && b < 10^5) return pfact(b);
+    /* TODO: use pix() and a simple array (mat[])instead*/
+     __CZ__primelist = list();
+     __CZ__fill_prime_list(a,b);
+    C1 = size(__CZ__primelist)-1;
+    return __CZ__primorial__lowlevel( 0, C1,1)
+  }
+}
+
+
+/*
+ * restore internal function from resource debugging
+ * report important interface functions
+ */
+config("resource_debug", resource_debug_level),;
+if (config("resource_debug") & 3) {
+    print "factorial(n)";
+    print "primorial(a, b)";
+}

cal/factorial2.cal

@@ -0,0 +1,719 @@
+/*
+ * factorial2 - implementation of different factorial related functions
+ *
+ * Copyright (C) 2013,2021 Christoph Zurnieden
+ *
+ * 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.
+ *
+ * Under source code control:   2013/08/11 01:31:28
+ * File existed as early as:    2013
+ */
+
+
+/*
+ * hide internal function from resource debugging
+ */
+static resource_debug_level;
+resource_debug_level = config("resource_debug", 0);
+
+
+/*
+  get dependencies
+*/
+read -once factorial toomcook specialfunctions;
+
+
+/*
+  Factorize a factorial and put the result in a 2-column matrix with pi(n) rows
+  mat[ primes , exponent ]
+  Result can be restricted to start at a prime different from 2 with the second
+  argument "start". That arguments gets taken at face value if it prime and
+  smaller than n, otherwise the next larger prime is taken if that prime is
+  smaller than n.
+*/
+
+define __CZ__factor_factorial(n,start){
+  local prime prime_list k pix stop;
+
+
+  if(!isint(n)) return
+    newerror("__CZ__factor_factorial(n,start): n is not integer");
+  if(n <  0)    return newerror("__CZ__factor_factorial(n,start): n < 0");
+  if(n == 1)    return newerror("__CZ__factor_factorial(n,start): n == 1");
+
+  if(start){
+    if(!isint(start) && start < 0 && start > n)
+      return newerror("__CZ__factor_factorial(n,start): value of "
+                      "parameter 'start' out of range");
+    if(start == n && isprime(n)){
+      prime_list = mat[1 , 2];
+      prime_list[0,0] = n;
+      prime_list[0,1] = 1;
+    }
+    else if(!isprime(start) && nextprime(start) >n)
+      return newerror("__CZ__factor_factorial(n,start): value of parameter "
+                      "'start' out of range");
+    else{
+      if(!isprime(start))  prime = nextprime(start);
+      else prime = start;
+    }
+  }
+  else
+    prime = 2;
+
+  pix   = pix(n);
+  if(start){
+    pix -= pix(prime) -1;
+  }
+  prime_list = mat[pix , 2];
+
+  k = 0;
+
+  do {
+    prime_list[k  ,0] = prime;
+    prime_list[k++,1] = __CZ__prime_divisors(n,prime);
+    prime          = nextprime(prime);
+  }while(prime <= n);
+
+  return prime_list;
+}
+
+/*
+
+  subtracts exponents of n_1! from exponents of n_2! with n_1<=n_2
+
+  Does not check for size or consecutiveness of the primes or a carry
+*/
+
+define __CZ__subtract_factored_factorials(matrix_2n,matrix_n){
+  local k ret len1,len2,tmp count p e;
+  len1 = size(matrix_n)/2;
+  len2 = size(matrix_2n)/2;
+  if(len2<len1){
+
+    swap(len1,len2);
+    tmp = matrix_n;
+    matrix_n = matrix_2n;
+    matrix_2n = tmp;
+  }
+  tmp = mat[len1,2];
+  k   = 0;
+
+  for(;k<len1;k++){
+     p = matrix_2n[k,0];
+     e = matrix_2n[k,1] - matrix_n[k,1];
+     if(e!=0){
+       tmp[count  ,0] = p;
+       tmp[count++,1] = e;
+     }
+  }
+  ret = mat[count + (len2-len1),2];
+  for(k=0;k<count;k++){
+     ret[k,0] = tmp[k,0];
+     ret[k,1] = tmp[k,1];
+  }
+
+  free(tmp);
+  for(k=len1;k<len2;k++){
+     ret[count,0] = matrix_2n[k,0];
+     ret[count++,1] = matrix_2n[k,1];
+  }
+  return ret;
+}
+
+/*
+
+  adds exponents of n_1! to exponents of n_2! with n_1<=n_2
+
+  Does not check for size or consecutiveness of the primes or a carry
+*/
+
+define __CZ__add_factored_factorials(matrix_2n,matrix_n){
+  local k ret len1,len2,tmp;
+  len1 = size(matrix_n)/2;
+  len2 = size(matrix_2n)/2;
+  if(len2<len1){
+    swap(len1,len2);
+    tmp = matrix_n;
+    matrix_n = matrix_2n;
+    matrix_2n = tmp;
+  }
+  ret = mat[len2,2];
+  k   = 0;
+  for(;k<len1;k++){
+     ret[k,0] = matrix_2n[k,0];
+     ret[k,1] = matrix_2n[k,1] + matrix_n[k,1];
+  }
+  for(;k<len2;k++){
+     ret[k,0] = matrix_2n[k,0];
+     ret[k,1] = matrix_2n[k,1];
+  }
+  return ret;
+}
+
+/*
+   Does not check if all exponents are positive
+
+
+                   timings
+                   this           comb      comb-this     rel. k/n
+;  benchmark_binomial(10,13)
+n=2^13 k=2^10    0.064004        0.016001       +       0.76923076923076923077
+n=2^13 k=2^11    0.064004        0.048003       +       0.84615384615384615385
+n=2^13 k=2^12    0.068004        0.124008       -       0.92307692307692307692
+;  benchmark_binomial(10,15)
+n=2^15 k=2^10    0.216014        0.024001       +       0.66666666666666666667
+n=2^15 k=2^11    0.220014        0.064004       +       0.73333333333333333333
+n=2^15 k=2^12    0.228014        0.212014       +       0.8
+n=2^15 k=2^13    0.216013        0.664042       -       0.86666666666666666667
+n=2^15 k=2^14    0.240015        1.868117       -       0.93333333333333333333
+;  benchmark_binomial(11,15)
+n=2^15 k=2^11    0.216014        0.068004       +       0.73333333333333333333
+n=2^15 k=2^12    0.236015        0.212013       +       0.8
+n=2^15 k=2^13    0.216013        0.656041       -       0.86666666666666666667
+n=2^15 k=2^14    0.244016        1.872117       -       0.93333333333333333333
+;  benchmark_binomial(11,18)
+n=2^18 k=2^11    1.652103        0.100006       +       0.61111111111111111111
+n=2^18 k=2^12    1.608101        0.336021       +       0.66666666666666666667
+n=2^18 k=2^13    1.700106        1.140071       +       0.72222222222222222222
+n=2^18 k=2^14    1.756109        3.924245       -       0.77777777777777777778
+n=2^18 k=2^15    2.036127        13.156822      -       0.83333333333333333333
+n=2^18 k=2^16    2.172135        41.974624      -       0.88888888888888888889
+n=2^18 k=2^17    2.528158        121.523594     -       0.94444444444444444444
+;  benchmark_binomial(15,25)
+n=2^25 k=2^15    303.790985      38.266392      +       0.6
+;  benchmark_binomial(17,25)
+n=2^25 k=2^17    319.127944      529.025062     -       0.68
+*/
+
+define benchmark_binomial(s,limit){
+  local ret k A B T1 T2 start end N K;
+    N = 2^(limit);
+  for(k=s;k<limit;k++){
+    K = 2^k;
+   start=usertime();A=binomial(N,K);end=usertime();
+   T1 = end-start;
+   start=usertime();B=comb(N,K);end=usertime();
+   T2 = end-start;
+   print "n=2^"limit,"k=2^"k,"  ",T1,"  ",T2,T1<T2?"-":"+","    "k/limit;
+   if(A!=B){
+     print "false";
+    break;
+   }
+  }
+}
+
+define __CZ__multiply_factored_factorial(matrix,stop){
+  local prime result shift prime_list k k1 k2 expo_list pix count start;
+  local hb flag;
+
+  result = 1;
+  shift  = 0;
+
+
+  if(!ismat(matrix))
+   return newerror("__CZ__multiply_factored_factorial(matrix): "
+                   "argument matrix not a matrix ");
+  if(!matrix[0,0])
+    return
+      newerror("__CZ__multiply_factored_factorial(matrix): "
+               "matrix[0,0] is null/0");
+
+  if(!isnull(stop))
+    pix = stop;
+  else
+    pix   = size(matrix)/2-1;
+
+  if(matrix[0,0] == 2 && matrix[0,1] > 0){
+    shift = matrix[0,1];
+    if(pix-1 == 0)
+      return 2^matrix[0,1];
+  }
+
+  /*
+    This is a more general way to do the multiplication, so any optimization
+    must have been done by the caller.
+  */
+  k = 0;
+  /*
+     The size of the largest exponent in bits is calculated dynamically.
+     Can be done more elegantly and saves one run over the whole array if done
+     inside the main loop.
+   */
+  hb =0;
+  for(k=0;k<pix;k++){
+    k1=highbit(matrix[k,1]);
+    if(hb < k1)hb=k1;
+  }
+
+  k2 = pix;
+  start = 0;
+  if(shift) start++;
+
+  for(k1=hb;k1>=0;k1--){
+    /*
+       the cut-off for T-C-4 ist still too low, using T-C-3 here
+       TODO: check cutoffs
+     */
+    result = toomcook3square(result);
+
+    for(k=start; k<=k2; k++) {
+      if((matrix[k,1] & (1 << k1)) != 0) {
+        result *= matrix[k,0];
+      }
+    }
+  }
+
+  result <<= shift;
+  return result;
+}
+
+/*
+    Compute binomial coefficients n!/(k!(n-k)!)
+
+    One of the rare cases where a formula once meant to ease manual computation
+    is actually the (asymptotically) fastest way to do it (in July 2013) for
+    the extreme case binomial(2N,N) but for a high price, the memory
+    needed is pi(N)--theoretically.
+*/
+define binomial(n,k){
+  local ret factored_n factored_k factored_nk denom num quot K prime_list prime;
+  local pix diff;
+
+  if(!isint(n) || !isint(k))
+    return newerror("binomial(n,k): input is not integer");
+  if(n<0 || k<0)
+    return newerror("binomial(n,k): input is not >= 0"); ;
+  if(n<k )   return 0;
+  if(n==k)   return 1;
+  if(k==0)   return 1;
+  if(k==1)   return n;
+  if(n-k==1) return n;
+  /*
+      cut-off depends on real size of n,k and size of n/k
+      The current cut-off is to small for large n, e.g.:
+      for 2n=2^23, k=n-n/2 the quotient is q=2n/k=0.25. Empirical tests showed
+      that 2n=2^23 and k=2^16  with q=0.0078125 are still faster than the
+      builtin function.
+
+      The symmetry (n,k) = (n,n-k) is of not much advantage here. One way
+      might be to get closer to k=n/2 if k<n-k but only if the difference
+      is small and n very large.
+   */
+  if(n<2e4 && !isdefined("test8900"))  return comb(n,k);
+  if(n<2e4 && k< n-n/2 && !isdefined("test8900")) return comb(n,k);
+  /*
+    This should be done in parallel to save some memory, e.g. no temporary
+    arrays are needed, all can be done inline.
+    The theoretical memory needed is pi(k).
+    Which is still a lot.
+  */
+
+  prime = 2;
+  pix   = pix(n);
+  prime_list = mat[pix , 2];
+  K = 0;
+  do {
+    prime_list[K  ,0] = prime;
+    diff = __CZ__prime_divisors(n,prime)-
+           ( __CZ__prime_divisors(n-k,prime)+__CZ__prime_divisors(k,prime));
+    if(diff != 0)
+      prime_list[K++,1] = diff;
+    prime          = nextprime(prime);
+  }while(prime <= k);
+
+  do {
+    prime_list[K  ,0] = prime;
+    diff = __CZ__prime_divisors(n,prime)-__CZ__prime_divisors(n-k,prime);
+    if(diff != 0)
+      prime_list[K++,1] = diff;
+    prime          = nextprime(prime);
+  }while(prime <= n-k);
+
+  do {
+    prime_list[K  ,0] = prime;
+    prime_list[K++,1] = __CZ__prime_divisors(n,prime);
+    prime          = nextprime(prime);
+  }while(prime <= n);
+  ##print K,pix(k),pix(n-k),pix(n);
+  ##factored_k  = __CZ__factor_factorial(k,1);
+  ##factored_nk = __CZ__factor_factorial(n-k,1);
+
+  ##denom = __CZ__add_factored_factorials(factored_k,factored_nk);
+    ##free(factored_k,factored_nk);
+  ##num  = __CZ__factor_factorial(n,1);
+  ##quot  = __CZ__subtract_factored_factorials( num , denom );
+    ##free(num,denom);
+
+  ret = __CZ__multiply_factored_factorial(`prime_list,K-1);
+
+  return ret;
+}
+
+/*
+    Compute large catalan numbers  C(n) = binomial(2n,n)/(n+1) with
+    cut-off: (n>5e4)
+    Needs a lot of memory.
+*/
+define bigcatalan(n){
+  if(!isint(n) )return newerror("bigcatalan(n): n is not integer");
+  if( n<0) return newerror("bigcatalan(n): n < 0");
+  if( n<5e4 && !isdefined("test8900") ) return catalan(n);
+  return binomial(2*n,n)/(n+1);
+}
+
+/*
+  df(-111) = -1/3472059605858239446587523014902616804783337112829102414124928
+                7753332469144201839599609375
+
+ df(-3+1i) = 0.12532538977287649201-0.0502372106177184607i
+ df(2n + 1) = (2*n)!/(n!*2^n)
+*/
+define __CZ__double_factorial(n){
+  local n1 n2 diff prime pix K prime_list k;
+  prime = 3;
+  pix   = pix(2*n)+1;
+  prime_list = mat[pix , 2];
+  K = 0;
+  do {
+    prime_list[K  ,0] = prime;
+    diff = __CZ__prime_divisors(2*n,prime)-( __CZ__prime_divisors(n,prime));
+    if(diff != 0)
+      prime_list[K++,1] = diff;
+    prime          = nextprime(prime);
+  }while(prime <= n);
+  do {
+    prime_list[K  ,0] = prime;
+    prime_list[K++,1] = __CZ__prime_divisors(2*n,prime);
+    prime          = nextprime(prime);
+  }while(prime <= 2*n);
+  return __CZ__multiply_factored_factorial(prime_list,K);
+/*
+        n1=__CZ__factor_factorial(2*n,1);
+        n1[0,1] = n1[0,1]-n;
+        n2=__CZ__factor_factorial(n,1);
+        diff=__CZ__subtract_factored_factorials( n1 , n2 );
+        return __CZ__multiply_factored_factorial(diff);
+*/
+}
+
+##1, 1, 3, 15, 105, 945, 10395, 135135, 2027025, 34459425, 654729075,
+##13749310575, 316234143225, 7905853580625, 213458046676875,
+##6190283353629375, 191898783962510625, 6332659870762850625,
+##221643095476699771875, 8200794532637891559375
+
+## 1, 2, 8, 48, 384, 3840, 46080, 645120, 10321920, 185794560,
+##3715891200, 81749606400, 1961990553600, 51011754393600,
+##1428329123020800, 42849873690624000, 1371195958099968000,
+##46620662575398912000, 1678343852714360832000, 63777066403145711616000
+define doublefactorial(n){
+    local n1 n2 diff eps ret;
+    if(!isint(n) ){
+       /*
+           Probably one of the not-so-good ideas. See result of
+            http://www.wolframalpha.com/input/?i=doublefactorial%28a%2Bbi%29
+        */
+       eps=epsilon(epsilon()*1e-2);
+       ret =  2^(n/2-1/4 * cos(pi()* n)+1/4) * pi()^(1/4 *
+              cos(pi()* n)-1/4)* gamma(n/2+1);
+       epsilon(eps);
+       return ret;
+    }
+    if(n==2) return 2;
+    if(n==3) return 3;
+    switch(n){
+      case -1:
+      case 0 : return 1;break;
+      case 2 : return 2;break;
+      case 3 : return 3;break;
+      case 4 : return 8;break;
+      default: break;
+    }
+    if(isodd(n)){
+      /*
+        TODO: find reasonable cutoff
+        df(2n + 1) = (2*n)!/(n!*2^n)
+      */
+      if(n>0){
+         n = (n+1)//2;
+         return __CZ__double_factorial(n);
+      }
+      else{
+        if(n == -3 ) return -1;
+        n = ((-n)-1)/2;
+        return ((-1)^-n)/__CZ__double_factorial(n);
+       }
+    }
+    else{
+      /*
+         I'm undecided here. The formula for complex n is valid for the negative
+         integers, too.
+      */
+      n = n>>1;
+      if(n>0){
+        if(!isdefined("test8900"))
+          return factorial(n)<<n;
+        else
+          return n!<<n;
+      }
+      else
+        return newerror("doublefactorial(n): even(n) < 0");
+   }
+}
+
+/*
+    Algorithm 3.17,
+    Donald Kreher and Douglas Simpson,
+    Combinatorial Algorithms,
+    CRC Press, 1998, page 89.
+*/
+static __CZ__stirling1;
+static __CZ__stirling1_n = -1;
+static __CZ__stirling1_m = -1;
+
+define stirling1(n,m){
+  local i j k;
+  if(n<0)return newerror("stirling1(n,m): n <= 0");
+  if(m<0)return newerror("stirling1(n,m): m < 0");
+  if(n<m) return 0;
+  if(n==m) return 1;
+  if(m==0 || n==0) return 0;
+  /* We always use the list */
+  /*
+  if(m=1){
+    if(iseven(n)) return -factorial(n-1);
+    else return factorial(n-1);
+  }
+  if(m == n-1){
+    if(iseven(n)) return -binomial(n,2);
+    else return -binomial(n,2);
+  }
+  */
+  if(__CZ__stirling1_n >= n && __CZ__stirling1_m  >= m){
+    return __CZ__stirling1[n,m];
+  }
+  else{
+    __CZ__stirling1      = mat[n+1,m+1];
+    __CZ__stirling1[0,0] = 1;
+    for(i=1;i<=n;i++)
+      __CZ__stirling1[i,0] = 0;
+    for(i=1;i<=n;i++){
+      for(j=1;j<=m;j++){
+        if(j<=i){
+          __CZ__stirling1[i, j] =   __CZ__stirling1[i - 1, j - 1] - (i - 1)\
+                                  * __CZ__stirling1[i - 1, j];
+        }
+        else{
+         __CZ__stirling1[i, j] = 0;
+        }
+      }
+    }
+    __CZ__stirling1_n = n;
+    __CZ__stirling1_m = m;
+    return __CZ__stirling1[n,m];
+  }
+}
+
+define stirling2(n,m){
+  local k sum;
+  if(n<0)return newerror("stirling2(n,m): n < 0");
+  if(m<0)return newerror("stirling2(n,m): m < 0");
+  if(n<m) return 0;
+  if(n==0 && n!=m) return 0;
+  if(n==m) return 1;
+  if(m==0 )return 0;
+  if(m==1) return 1;
+  if(m==2) return 2^(n-1)-1;
+  /*
+    There are different methods to speed up alternating sums.
+    This one doesn't.
+   */
+  if(isdefined("test8900")){
+    for(k=0;k<=m;k++){
+      sum += (-1)^(m-k)*comb(m,k)*k^n;
+    }
+  return sum/(m!);
+  }
+  else{
+    for(k=0;k<=m;k++){
+      sum += (-1)^(m-k)*binomial(m,k)*k^n;
+    }
+  return sum/factorial(m);
+  }
+}
+
+static __CZ__stirling2;
+static __CZ__stirling2_n = -1;
+static __CZ__stirling2_m = -1;
+define stirling2caching(n,m){
+  local nm i j ;
+  if(n<0)return newerror("stirling2iter(n,m): n < 0");
+  if(m<0)return newerror("stirling2iter(n,m): m < 0");
+  /* no shortcuts here */
+
+  if(n<m) return 0;
+  if(n==0 && n!=m) return 0;
+  if(n==m) return 1;
+  if(m==0 )return 0;
+  if(m==1) return 1;
+  if(m==2) return 2^(n-1)-1;
+
+  nm = n-m;
+  if(__CZ__stirling2_n >= n && __CZ__stirling2_m >= m){
+    return __CZ__stirling2[n,m];
+  }
+  else{
+    __CZ__stirling2 = mat[n+1,m+1];
+    __CZ__stirling2[0,0] = 1;
+    for(i=1;i<=n;i++){
+      __CZ__stirling2[i,0] = 0;
+      for(j=1;j<=m;j++){
+        if(j<=i){
+          __CZ__stirling2[i, j] =   __CZ__stirling2[i -1, j -1] + (j )\
+                                  * __CZ__stirling2[i - 1, j];
+        }
+        else{
+         __CZ__stirling2[i, j] = 0;
+        }
+      }
+    }
+  }
+  __CZ__stirling2_n = (n);
+  __CZ__stirling2_m = (m);
+  return __CZ__stirling2[n,m];
+}
+
+define bell(n){
+  local sum s2list k A;
+
+  if(!isint(n)) return newerror("bell(n): n is not integer");
+  if(n < 0) return newerror("bell(n): n is not positive");
+  /* place some more shortcuts here?*/
+  if(n<=15){
+    mat A[16] = {
+                  1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147, 115975, 678570,
+                  4213597, 27644437, 190899322, 1382958545
+                };
+    return A[n];
+  }
+  /* Start by generating the list of stirling numbers of the second kind */
+  s2list = stirling2caching(n,n//2);
+  if(iserror(s2list))
+    return newerror("bell(n): could not build stirling num. list");
+  sum = 0;
+  for(k=1;k<=n;k++){
+      sum += stirling2caching(n,k);
+  }
+  return sum;
+}
+
+define subfactorialrecursive(n){
+  if(n==0) return 1;
+  if(n==1) return 0;
+  if(n==2) return 1;
+  return n * subfactorialrecursive(n-1) + (-1)^n;
+}
+
+/* This is, quite amusingly, faster than the very same algorithm in
+   PARI/GP + GMP*/
+define subfactorialiterative(n){
+  local k temp1 temp2 ret;
+  if(n==0) return 1;
+  if(n==1) return 0;
+  if(n==2) return 1;
+  temp1 = 0;
+  ret   = 1;
+  for(k=3;k<=n;k++){
+    temp2 = temp1;
+    temp1 = ret;
+    ret =  (k-1) *(temp1 + temp2);
+  }
+  return ret;
+}
+
+define subfactorial(n){
+  local epsilon eps ret lnfact;
+  if(!isint(n))return  newerror("subfactorial(n): n is not integer.");
+  if(n < 0)return  newerror("subfactorial(n): n < 0");
+  return subfactorialiterative(n);
+}
+
+define risingfactorial(x,n){
+  local num denom quot ret;
+  if(n == 1) return x;
+  if(x==0) return newerror("risingfactorial(x,n): x == 0");
+  if(!isint(x) || !isint(n)){
+    return gamma(x+n)/gamma(x);
+  }
+  if(x<1)return newerror("risingfactorial(x,n): integer x and x < 1");
+  if(x+n < 1)return newerror("risingfactorial(x,n): integer x+n and x+n < 1");
+  if(x<9000&&n<9000){
+    return (x+n-1)!/(x-1)!;
+  }
+  else{
+    num   = __CZ__factor_factorial(x+n-1,1);
+    denom = __CZ__factor_factorial(x-1,1);
+    quot  = __CZ__subtract_factored_factorials( num , denom );
+      free(num,denom);
+    ret = __CZ__multiply_factored_factorial(quot);
+    return ret;
+  }
+}
+
+define fallingfactorial(x,n){
+  local num denom quot ret;
+  if(n == 0) return 1;
+
+  if(!isint(x) || !isint(n)){
+    if(x == n) return gamma(x+1);
+    return gamma(x+1)/gamma(x-n+1);
+  }
+  else{
+    if(x<0 || x-n < 0)
+     return newerror("fallingfactorial(x,n): integer x<0 or x-n < 0");
+    if(x == n) return factorial(x);
+    if(x<9000&&n<9000){
+      return (x)!/(x-n)!;
+    }
+    else{
+      num   = __CZ__factor_factorial(x,1);
+      denom = __CZ__factor_factorial(x-n,1);
+      quot  = __CZ__subtract_factored_factorials( num , denom );
+        free(num,denom);
+      ret = __CZ__multiply_factored_factorial(quot);
+      return ret;
+    }
+  }
+}
+
+
+/*
+ * restore internal function from resource debugging
+ * report important interface functions
+ */
+config("resource_debug", resource_debug_level),;
+if (config("resource_debug") & 3) {
+    print "binomial(n,k)";
+    print "bigcatalan(n)";
+    print "doublefactorial(n)";
+    print "subfactorial(n)";
+    print "stirling1(n,m)";
+    print "stirling2(n,m)";
+    print "stirling2caching(n,m)";
+    print "bell(n)";
+    print "subfactorial(n)";
+    print "risingfactorial(x,n)";
+    print "fallingfactorial(x,n)";
+}

cal/fnv_tool.cal

@@ -0,0 +1,473 @@
+/*
+ * fnv_util - utility tools for FNV hash and "FNV-style" hash operations
+ *
+ * This file provides the following functions:
+ *
+ *      find_fnv_prime(bits)
+ *      deprecated_fnv0(bits, fnv_prime, string)
+ *      fnv_offset_basis(bits, fnv_prime)
+ *      fnv1a_style_hash(bits, fnv_prime, prev_hash, string)
+ *
+ * See the individual function for details on args and return value.
+ *
+ * If no args are given to find_fnv_prime() and stdin is associated
+ * with a tty (i.e., an interactive terminal), then bits will be
+ * prompted for and commentary will be printed to stdout as well.
+ *
+ * If fnv_prime == null(), then an attempt to compute the FNV prime
+ * for a hash if size bits is attempted..
+ *
+ * If prev_hash == null(), then the FNV offset basis for
+ * for a hash if size bits is computed.
+ *
+ * For more information on the FNV hash see:
+ *
+ *      https://en.wikipedia.org/wiki/Fowler-Noll-Vo_hash_function
+ *      http://www.isthe.com/chongo/tech/comp/fnv/index.html
+ *
+ * IMPORTANT NOTE:
+ *
+ * These functions, if given non-standard values, will produce bogus results.
+ * In some cases, such as specifying the number of bits in the hash,
+ * using a non-power of 2 bit will produce a result that may work,
+ * but the hash will be only an "FNV-style" hash and not a true FNV hash.
+ *
+ * We say "FNV-style" because the result hash is not a "true FNV-like" hash.
+ *
+ * Let integer n > 0 be the number if bits in the FNV hash.  Then:
+ *
+ *      t = floor((5+n)/12)
+ *
+ * The FNV prime, for the given n bits is the smallest prime of the form:
+ *
+ *      p = 256^t + 2^8 + b
+ *
+ * such that:
+ *
+ *      0 < b < 2^8
+ *      The number of one-bits in b must be 4 or 5
+ *      p mod (2^40 - 2^24 - 1) > (2^24 + 2^8 + 2^7)
+ *
+ * If you force n to not be a power of 2, for example:
+ *
+ *      n = 44
+ *
+ * you will find that the FNV prime for 44 bits is:
+ *
+ *      p44 = 4294967597
+ *          = 0x10000012d
+ *          = 0b100000000000000000000000100101101
+ *          = 2^32 + 301 = 2^32 + 2^8 + 2^5 + 2^3 + 2^2 + 2^0
+ *
+ * However a hash size of 44 bits is not a true FNV hash, it is only a "FNV-style" hash.
+ *
+ * NOTE: We disallow n <= 31 because there are no FNV primes that small.
+ *
+ * NOTE: For n that is a power of 2 and n > 1024, you will find that
+ *       that FNV primes become so rare that that one may not find a suitable
+ *       FNV prime.  For n = powers of 2 >= 2048 and <= 1048576,
+ *       there is NO FNV primes.
+ *
+ *       As for as hashing goes, large values of n, even if an
+ *       FNV hash may be found, are unlikely to be truly useful.  :-)
+ */
+/*
+ * Copyright (c) 2023 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 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 (Landon Curt Noll, http://www.isthe.com/chongo/index.html) /\oo/\
+ *
+ * Share and enjoy! :-)
+ */
+
+
+/*
+ * find_fnv_prime - try to find a FNV prime given the number of bits
+ *
+ * If bits == null(), this function will attempt to prompt stdin
+ * for a value and provide commends on the value of bits.
+ *
+ * given:
+ *      bits    number of bits in the hash, null() ==> prompt for value
+ *
+ * returns:
+ *      0 ==> no FNV prime found
+ *      >0 ==> FNV prime
+ */
+define find_fnv_prime(bits)
+{
+    local b;            /* lower octet of the potential FNV prime: [1,255] */
+    local p;            /* value to test as an FNV prime */
+    local t;            /* power of 256 part of the FNV prime */
+    local one_bits;     /* number of 1 bits in b */
+    local p_minus_b;    /* potential FNV prime less b */
+    local interactive;  /* true ==> interactive mode and print commentary */
+
+    /*
+     * case: no arg, prompt for bits and print commentary
+     */
+    interactive = 0;    /* assume non-interactive mode */
+    if (isnull(bits)) {
+
+        /*
+         * must be attached to an interactive terminal
+         */
+        if (!isatty(files(0))) {
+            print "# FATAL: stdin is not a tty: not attached to an interactive terminal";
+            return 0;
+        }
+        interactive = 1;        /* set interactive mode */
+
+        /*
+         * prompt for the number of bits
+         */
+        do {
+            local strscanf_ret;         /* return from strscanf_ret */
+            local input;                /* value read after prompt */
+
+            /*
+             * prompt and obtain the input
+             */
+            input = prompt("Enter hash size in bits: ");
+            strscanf_ret = strscanf(input, "%i", bits);
+            print "input =", input;
+            print "bits =", bits;
+            if (!isint(bits) || bits <= 0) {
+                print;
+                print "# NOTE: must enter a integer > 0, try again";
+                print;
+            }
+        } while (!isint(bits) || bits <= 0);
+    }
+
+    /*
+     * firewall - bits must be non-negative integer
+     */
+    if (!isint(bits) || bits < 0) {
+        if (interactive) {
+            print "# FATAL: bits must be non-negative integer";
+        }
+        return 0;
+    }
+
+    /*
+     * provide commentary on the choice of bits if we are interactive
+     */
+    if (interactive) {
+        if (popcnt(bits) == 1) {
+            if (bits > 1024) {
+                print "# WARNING: FNV primes for bit size powers of 2  > 1024 are extremely rare.";
+                print "# WARNING: There are no FNV primes for bit size powers of 2 >= 2048 and <= 1048576.";
+            }
+            print "n =", bits;
+        } else {
+            if (bits < 32) {
+                print "# WARNING: bits < 32 is not recommended because there isn't enough bits to be worth hashing";
+            }
+            print "# WARNING: because bits is not a power of 2, we can only form an \"FNV-style hash\": not a true FNV hash.";
+            print "# WARNING: A \"FNV-style hash\" may not have the desired hash properties of a true FNV hash.";
+            print "n =", bits;
+        }
+    }
+
+    /*
+     * search setup
+     */
+    t = floor((5+bits)/12);
+    p_minus_b = 256^t + 2^8;
+
+    /*
+     * search for a b that forms a suitable FNV prime
+     */
+    for (b=1; b < 256; ++b) {
+
+        /*
+         * reject b unless the of one-bits in bottom octet of p is 4 or 5
+         */
+        one_bits = popcnt(b);
+        if (one_bits != 4 && one_bits != 5) {
+            continue;
+        }
+
+        /*
+         * reject p if p mod (2^40 - 2^24 - 1) <= (2^24 + 2^8 + 2^7)
+         */
+        p = p_minus_b + b;
+        if ((p % (2^40 - 2^24 - 1)) <= (2^24 + 2^8 + 2^7)) {
+            continue;
+        }
+
+        /*
+         * accept potential p value that is prime
+         */
+        if (ptest(p) == 1) {
+            return p;
+        }
+    }
+
+    /*
+     * case: did not find an FNV prime
+     */
+    if (b >= 256) {
+
+        /*
+         * examine results if interactive
+         */
+        if (interactive) {
+            print "# FATAL: There is no a suitable FNV prime for bits =", bits;
+            quit "find_fnv_prime: FATAL: FNV prime search failed";
+        }
+
+        /*
+         * return 0 to indicate no FNV prime found
+         */
+        return 0;
+    }
+
+    /*
+     * provide FNV commentary if interactive
+     */
+    if (interactive) {
+        print "t =", t;
+        print "b =", b;
+        print "# NOTE: p = 256^":t, "+ 2^8 +", b;
+        print;
+        print "p =", p;
+    }
+
+    /*
+     * return FNV prime
+     */
+    return p;
+}
+
+
+/*
+ * deprecated_fnv0 - FNV-0 hash that should only be used to generate an FNV offset basis
+ *
+ * If fnv_prime == null(), this function will try to compute the FNV prime
+ * for a hash of size bits.
+ *
+ * given:
+ *      bits            number of bits in FNV hash
+ *      fnv_prime       FNV prime, null() ==> generate suitable FNV prime if possible
+ *      string          string to hash
+ *
+ * returns:
+ *      FNV-0 hash, for size bytes, of string
+ *
+ * NOTE: This function does NOT attempt to determine that fnv_prime is prime.
+ */
+define deprecated_fnv0(bits, fnv_prime, string)
+{
+    local hash;         /* FNV hash value */
+    local len;          /* length of string */
+    local base;         /* base of FNV hash: 2^bits */
+    local i;
+
+    /*
+     * firewall
+     */
+    if (!isint(bits) || bits <= 0) {
+        quit "deprecated_fnv0: FATAL: bits arg must be an integer > 0";
+    }
+    if (!isstr(string)) {
+        quit "deprecated_fnv0: FATAL: string arg must be a string";
+    }
+
+    /*
+     * fnv_prime == null() means to try and generate the FNV prime
+     */
+    if (isnull(fnv_prime)) {
+        /* try to generate an FNV prime */
+        fnv_prime = find_fnv_prime(bits);
+        if (fnv_prime == 0) {
+            quit "deprecated_fnv0: FATAL: no FNV prime exists for the given hash size in bits";
+        }
+    }
+    if (!isint(fnv_prime) || fnv_prime <= 0) {
+        quit "deprecated_fnv0: FATAL: fnv_prime arg must be an integer > 0 and should be prime";
+    }
+
+    /*
+     * FNV-0 hash each character
+     */
+    len = strlen(string);
+    base = 2^bits;
+    hash = 0;
+    for (i=0; i < len; ++i) {
+        hash = xor((hash * fnv_prime) % base, ord(string[i]));
+    }
+    return hash;
+}
+
+
+/*
+ * fnv_offset_basis - generate and FNV offset basis
+ *
+ * given:
+ *      bits            number of bits in FNV hash
+ *      fnv_prime       FNV prime, null() ==> generate suitable FNV prime if possible
+ *
+ * returns:
+ *      FNV offset basis for a hash size of bits and an FNV prime of fnv_prime
+ *
+ * NOTE: This function does NOT attempt to determine that fnv_prime is prime.
+ */
+define
+fnv_offset_basis(bits, fnv_prime)
+{
+    local fnv0_hash = 0;        /* FNV-0 hash value */
+
+    /* string to generate a FNV offset basis - do not change this value */
+    static chongo_was_here = "chongo <Landon Curt Noll> /\\../\\";
+
+    /*
+     * firewall
+     */
+    if (!isint(bits) || bits <= 0) {
+        quit "fnv_offset_basis: FATAL: bits arg must be an integer > 0";
+    }
+
+    /*
+     * fnv_prime == null() means to try and generate the FNV prime
+     */
+    if (isnull(fnv_prime)) {
+        /* try to generate an FNV prime */
+        fnv_prime = find_fnv_prime(bits);
+        if (fnv_prime == 0) {
+            quit "fnv_offset_basis: FATAL: no FNV prime exists for the given hash size in bits";
+        }
+    }
+    if (!isint(fnv_prime) || fnv_prime <= 0) {
+        quit "fnv_offset_basis: FATAL: fnv_prime arg must be an integer > 0 and should be prime";
+    }
+
+    /*
+     * return the FNV-0 hash of fnv_offset_basis as the FNV offset basis
+     */
+    fnv0_hash = deprecated_fnv0(bits, fnv_prime, chongo_was_here);
+    return fnv0_hash;
+}
+
+
+/*
+ * fnv_style_hash - compute an "FNV-1a-style" hash
+ *
+ * These functions, if given non-standard values, will produce bogus results.
+ * To produce a true FNV-1a hash:
+ *
+ *      bits must be a power of 2
+ *      32 <= bits
+ *      fnv_prime == find_fnv_prime(bits) OR fnv_prime == null()
+ *      prev_hash == previous FNV hash OR prev_hash == null()
+ *
+ * If fnv_prime == null(), this function will try to compute the FNV prime
+ * for a hash of size bits.
+ *
+ * If prev_hash == null(), this function will try to compute the FNV offset basis
+ * for a hash of size bits.
+ *
+ * One may chain "FNV-style" hashes by replacing the offset_basis with
+ * the hash state of the previous hash.  For the first hash:
+ *
+ *      fnv_prime = find_fnv_prime(bits)
+ *      hash_val = fnv_style_hash(bits, fnv_prime, null(), string_a);
+ *
+ * then:
+ *
+ *      hash_val = fnv_style_hash(bits, fnv_prime, hash_val, string_b);
+ *
+ * This will produce the same as the string_a concatenated with string_b:
+ *
+ *      hash_val = fnv_style_hash(bits, null(), null(), string_a + string_b);
+ *
+ * NOTE: Because string_a and string_b are strings, the expression:
+ *
+ *          string_a + string_b
+ *
+ *      is string_a concatenated with string_b.
+ *
+ * given:
+ *      bits            number of bits in FNV hash
+ *      fnv_prime       FNV prime, null() ==> generate suitable FNV prime if possible
+ *      prev_hash       previous hash value, null() ==> generate FNV offset basis
+ *      string          string to hash
+ *
+ * returns:
+ *      "FNV-style" hash of bits
+ *
+ * NOTE: This function does NOT attempt to determine that fnv_prime is prime.
+ */
+define
+fnv1a_style_hash(bits, fnv_prime, prev_hash, string)
+{
+    local hash = 0;     /* FNV hash value */
+    local len;          /* length of string */
+    local base;         /* base of FNV hash: 2^bits */
+    local i;
+
+    /*
+     * firewall
+     */
+    if (!isint(bits) || bits <= 0) {
+        quit "fnv1a_style_hash: FATAL: bits arg must be an integer > 0";
+    }
+    if (!isstr(string)) {
+        quit "fnv1a_style_hash: FATAL: string arg must be a string";
+    }
+
+    /*
+     * fnv_prime == null() means to try and generate the FNV prime
+     */
+    if (isnull(fnv_prime)) {
+        /* try to generate an FNV prime */
+        fnv_prime = find_fnv_prime(bits);
+        if (fnv_prime == 0) {
+            quit "fnv1a_style_hash: FATAL: no FNV prime exists for the given hash size in bits";
+        }
+    }
+    if (!isint(fnv_prime) || fnv_prime <= 0) {
+        quit "fnv1a_style_hash: FATAL: fnv_prime arg must be an integer > 0 and should be prime";
+    }
+
+    /*
+     * prev_hash == null() means to generate the FNV offset basis
+     */
+    if (isnull(prev_hash)) {
+
+        /* generate the FNV offset basis for a hash of size bits */
+        prev_hash = fnv_offset_basis(bits, fnv_prime);
+    }
+    if (!isint(prev_hash) || prev_hash < 0) {
+        quit "fnv1a_style_hash: FATAL: prev_hash arg must be an integer => 0";
+    }
+
+    /*
+     * FNV-1a hash each character
+     */
+    len = strlen(string);
+    base = 2^bits;
+    hash = prev_hash;
+    for (i=0; i < len; ++i) {
+        hash = xor((hash * fnv_prime) % base, ord(string[i]));
+    }
+    return hash;
+}

cal/gvec.cal

@@ -0,0 +1,103 @@
+/*
+ * gvec - vectorize any single-input function or trailing operator
+ *
+ * This version accepts arbitrary number of arguments, but of course
+ * they must all be same length vectors.
+ *
+ * The gvec function is for use in either a two-arg function or a two-arg
+ * operation "function" must be first; calc doesn't care how many more
+ * arguments there actually are.
+ *
+ * Under source code control:   2011/03/31 17:54:55
+ * File existed as early as:    2010
+ *
+ * By Carl Witthoft carl at witthoft dot com
+ */
+
+define gvec(function, vector)
+{
+    local xlen,y,foo;
+    local precx = 1e-50;        /* default for now */
+    local argc = param(0)-1;
+    local old_tilde;            /* previous config("tilde") */
+
+    /*
+     * parse args
+     */
+    local plist = mat[argc];
+    if (config("resource_debug") & 8) {
+        print "plist=", plist;
+        print "argc=", argc;
+    }
+    for(local i = 0; i< argc; i++) {
+        local ii = i + 2;
+        if (config("resource_debug") & 8) {
+            print "ii=", ii;
+            print "param(" : ii : "}=", param(ii);
+            print "size(param(" : ii : ")=", size(param(ii));
+        }
+        plist[i] = size(param(ii));
+    }
+    local slist=sort(plist);
+    if (config("resource_debug") & 8) {
+        print "plist=", plist;
+    }
+    local argm = argc-1;
+    if (config("resource_debug") & 8) {
+        print "argm=", argm;
+    }
+    if (slist[0] != slist[argm]) {
+        quit "lengths don't match";
+    }
+    xlen = size(vector);
+    y = mat[xlen];
+
+    /*
+     * We can't do str(vector[j]) outside loop, eval() petulantly refuses to
+     * look at local variables.
+     *
+     * Also we need to config("tilde",0) to turn off lead tilde
+     * (so str(vector[j]) looks like a number.
+     */
+    old_tilde = config("tilde",0);
+
+    /*
+     * Ok, now check to see if "function" is a function.  If not, it's an
+     * operation and it's up to user to make it valid
+     */
+    if (isdefined(function)) {
+
+        /* yep, it's a function, either builtin or user-defined */
+        for (local j=0; j<xlen; j++) {
+
+            /* build the function call */
+            foo = strcat(function, "(");
+            for (local jj = 0; jj<argc; jj++) {
+                foo = strcat(foo , str(param(jj+2)[j]), ",");
+            }
+            foo = strcat(foo, str(precx), ")");
+            if (config("resource_debug") & 8) {
+                print "foo=", foo;
+            }
+            y[j] = eval(foo);
+        }
+
+    /*
+     * it is an operator --  multi-argument operator makes no sense
+     */
+    } else {
+        if (argc > 1) {
+            quit "Error: operator can accept only one argument";
+        }
+        for (j=0; j<xlen; j++) {
+            foo = strcat(str(vector[j]), function);
+            y[j] = eval(foo);
+        }
+    }
+
+    /* restore tilde mode if needed */
+    config("tilde", old_tilde);
+
+    /* return result */
+    return y;
+}

cal/hello.cal

@@ -9,23 +9,19 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: hello.cal,v 29.1 1999/12/14 09:15:31 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
  *
- * Under source code control:	1996/11/13 13:25:43
- * File existed as early as:	1996
- *
- * chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*

cal/hms.cal

@@ -0,0 +1,364 @@
+/*
+ * hms - calculate in hours, minutes, and seconds
+ *
+ * Copyright (C) 2010,2021  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.
+ *
+ * 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 */
+
+    /* initialize 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 */
+
+    /* initialize 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";
+    }
+
+    /* use builtin h2hms function */
+    h2hms(a.hour + a.min/60 + a.sec/3600, a.hour, a.min, a.sec),;
+
+    /* return normalized result */
+    return a;
+}
+
+if (config("resource_debug") & 3) {
+    print "obj hms {hour, min, sec} defined";
+}

cal/infinities.cal

@@ -0,0 +1,88 @@
+/*
+ * infinities - handle infinities symbolically, a little helper file
+ *
+ * Copyright (C) 2013 Christoph Zurnieden
+ *
+ * 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.
+ */
+
+
+static resource_debug_level;
+resource_debug_level = config("resource_debug", 0);
+
+
+define isinfinite(x)
+{
+    if (isstr(x)) {
+        if (strncmp(x, "cinf", 4) == 0
+            || strncmp(x, "pinf", 4) == 0 || strncmp(x, "ninf", 4) == 0)
+            return 1;
+    }
+    return 0;
+}
+
+define iscinf(x)
+{
+    if (isstr(x)) {
+        if (strncmp(x, "cinf", 4) == 0)
+            return 1;
+    }
+    return 0;
+}
+
+define ispinf(x)
+{
+    if (isstr(x)) {
+        if (strncmp(x, "pinf", 4) == 0)
+            return 1;
+    }
+    return 0;
+}
+
+define isninf(x)
+{
+    if (isstr(x)) {
+        if (strncmp(x, "ninf", 4) == 0)
+            return 1;
+    }
+    return 0;
+}
+
+define cinf()
+{
+    return "cinf";
+}
+
+define ninf()
+{
+    return "ninf";
+}
+
+define pinf()
+{
+    return "pinf";
+}
+
+
+config("resource_debug", resource_debug_level),;
+if (config("resource_debug") & 3) {
+    print "isinfinite(x)";
+    print "iscinf(x)";
+    print "ispinf(x)";
+    print "isninf(x)";
+    print "cinf()";
+    print "ninf()";
+    print "pinf()";
+}

cal/intfile.cal

@@ -0,0 +1,218 @@
+/*
+ * intfile - integer to file and file to integer conversion
+ *
+ * Copyright (C) 2001,2021  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.
+ *
+ * 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/intnum.cal

@@ -0,0 +1,728 @@
+/*
+ * intnum - implementation of tanhsinh- and Gauss-Legendre quadrature
+ *
+ * Copyright (C) 2013,2021 Christoph Zurnieden
+ *
+ * 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.
+ */
+
+
+static resource_debug_level;
+resource_debug_level = config("resource_debug", 0);
+
+
+read -once infinities;
+
+static __CZ__tanhsinh_x;
+static __CZ__tanhsinh_w;
+static __CZ__tanhsinh_order;
+static __CZ__tanhsinh_prec;
+
+define quadtsdeletenodes()
+{
+    free(__CZ__tanhsinh_x);
+    free(__CZ__tanhsinh_w);
+    free(__CZ__tanhsinh_order);
+    free(__CZ__tanhsinh_prec);
+}
+
+define quadtscomputenodes(order, expo, eps)
+{
+    local t cht sht chp sum k PI places;
+    local h t0 x w;
+    if (__CZ__tanhsinh_order == order && __CZ__tanhsinh_prec == eps)
+        return 1;
+    __CZ__tanhsinh_order = order;
+    __CZ__tanhsinh_prec = eps;
+    __CZ__tanhsinh_x = list();
+    __CZ__tanhsinh_w = list();
+    /* The tanhsinh algorithm needs a slightly higher precision than G-L */
+    eps = epsilon(eps * 1e-2);
+    places = highbit(1 + int (1 / epsilon())) +1;
+    PI = pi();
+    sum = 0;
+    t0 = 2 ^ (-expo);
+    h = 2 * t0;
+    /*
+     * The author wanted to use the mpmath trick here which was
+     * advertised---and reasonably so!---to be faster. Didn't work out
+     * so well with calc.
+     * PI4 = PI/4;
+     * expt0 = bround(exp(t0),places);
+     * a = bround( PI4 * expt0,places);
+     * b = bround(PI4 / expt0,places);
+     * udelta = bround(exp(h),places);
+     * urdelta = bround(1/udelta,places);
+     */
+    /* make use of x(-t) = -x(t), w(-t) = w(t)  */
+    for (k = 0; k < 20 * order + 1; k++) {
+        /*
+         * x = tanh(pi/2 * sinh(t))
+         * w = pi/2 * cosh(t) / cosh(pi/2 * sinh(t))^2
+         */
+        t = bround(t0 + k * h, places);
+
+        cht = bround(cosh(t), places);
+        sht = bround(sinh(t), places);
+        chp = bround(cosh(0.5 * PI * sht), places);
+        x = bround(tanh(0.5 * PI * sht), places);
+        w = bround((PI * h * cht) / (2 * chp ^ 2), places);
+        /*
+         * c = bround(exp(a-b),places);
+         * d = bround(1/c,places);
+         * co =bround( (c+d)/2,places);
+         * si =bround( (c-d)/2,places);
+         * x = bround(si / co,places);
+         * w = bround((a+b) / co^2,places);
+         */
+        if (abs(x - 1) <= eps)
+            break;
+
+        append(__CZ__tanhsinh_x, x);
+        append(__CZ__tanhsinh_w, w);
+        /*
+         * a *= udelta;
+         * b *= urdelta;
+         */
+    }
+
+    /* Normalize the weights to make them add up to 2 (two) */
+    /*
+     * for(k=0;k < size(__CZ__tanhsinh_w);k++)
+     * sum = bround(sum + __CZ__tanhsinh_w[k],places);
+     * sum *= 2;
+     * for(k=0;k < size(__CZ__tanhsinh_w);k++)
+     * __CZ__tanhsinh_w[k] = bround(2.0 * __CZ__tanhsinh_w[k] / sum,places);
+     */
+
+    epsilon(eps);
+    return 1;
+}
+
+define quadtscore(a, b, n)
+{
+    local k c d order eps places sum ret x x1 x2 xm w w1 w2 m sizel;
+
+    eps = epsilon(epsilon() * 1e-2);
+    places = highbit(1 + int (1 / epsilon())) +1;
+    m = int (4 + max(0, ln(places / 30.0) / ln(2))) + 2;
+    if (!isnull(n)) {
+        order = n;
+        m = ilog(order / 3, 2) + 1;
+    } else
+        order = 3 * 2 ^ (m - 1);
+
+    quadtscomputenodes(order, m, epsilon());
+    sizel = size(__CZ__tanhsinh_w);
+
+    if (isinfinite(a) || isinfinite(b)) {
+        /*
+         *           x
+         * t =  ------------
+         *                2
+         *      sqrt(1 - y )
+         */
+        if (isninf(a) && ispinf(b)) {
+            for (k = 0; k < sizel; k++) {
+                x1 = __CZ__tanhsinh_x[k];
+                x2 = -__CZ__tanhsinh_x[k];
+                w1 = __CZ__tanhsinh_w[k];
+
+                x = bround(x1 * (1 - x1 ^ 2) ^ (-1 / 2), places);
+                xm = bround(x2 * (1 - x2 ^ 2) ^ (-1 / 2), places);
+                w = bround(w1 * (((1 - x1 ^ 2) ^ (-1 / 2)) / (1 - x1 ^ 2)),
+                           places);
+                w2 = bround(w1 * (((1 - x2 ^ 2) ^ (-1 / 2)) / (1 - x2 ^ 2)),
+                            places);
+                sum += bround(w * f(x), places);
+                sum += bround(w2 * f(xm), places);
+            }
+        }
+        /*
+         *        1
+         * t =  - - + b + 1
+         *        x
+         */
+        else if (isninf(a) && !iscinf(b)) {
+            for (k = 0; k < sizel; k++) {
+                x1 = __CZ__tanhsinh_x[k];
+                x2 = -__CZ__tanhsinh_x[k];
+                w1 = __CZ__tanhsinh_w[k];
+
+                x = bround((b + 1) - (2 / (x1 + 1)), places);
+                xm = bround((b + 1) - (2 / (x2 + 1)), places);
+                w = bround(w1 * (1 / 2 * (2 / (x1 + 1)) ^ 2), places);
+                w2 = bround(w1 * (1 / 2 * (2 / (x2 + 1)) ^ 2), places);
+                sum += bround(w * f(x), places);
+                sum += bround(w2 * f(xm), places);
+            }
+        }
+        /*
+         *      1
+         * t =  - + a - 1
+         *      x
+         */
+        else if (!iscinf(a) && ispinf(b)) {
+            for (k = 0; k < sizel; k++) {
+                x1 = __CZ__tanhsinh_x[k];
+                x2 = -__CZ__tanhsinh_x[k];
+                w1 = __CZ__tanhsinh_w[k];
+                x = bround((a - 1) + (2 / (x1 + 1)), places);
+                xm = bround((a - 1) + (2 / (x2 + 1)), places);
+                w = bround(w1 * (((1 / 2) * (2 / (x1 + 1)) ^ 2)), places);
+                w2 = bround(w1 * (((1 / 2) * (2 / (x2 + 1)) ^ 2)), places);
+                sum += bround(w * f(x), places);
+                sum += bround(w2 * f(xm), places);
+            }
+        } else if (isninf(a) || isninf(b)) {
+            /*TODO: swap(a,b) and negate(w)? Lookup! */
+            return newerror("quadtscore: reverse limits?");
+        } else {
+            return
+                newerror("quadtscore: complex infinity not yet implemented");
+        }
+        ret = sum;
+    } else {
+        /* Avoid rounding errors */
+        if (a == -1 && b == 1) {
+            c = 1;
+            d = 0;
+        } else {
+            c = (b - a) / 2;
+            d = (b + a) / 2;
+        }
+        sum = 0;
+        for (k = 0; k < sizel; k++) {
+            sum +=
+                bround(__CZ__tanhsinh_w[k] * f(c * __CZ__tanhsinh_x[k] + d),
+                       places);
+            sum +=
+                bround(__CZ__tanhsinh_w[k] * f(c * -__CZ__tanhsinh_x[k] + d),
+                       places);
+        }
+        ret = c * sum;
+    }
+    epsilon(eps);
+    return ret;
+}
+
+static __CZ__quadts_error;
+
+define quadts(a, b, points)
+{
+    local k sp results epsbits nsect interval length segment slope C ;
+    local x1 x2 y1 y2  sum D1 D2 D3 D4;
+    if (param(0) < 2)
+        return newerror("quadts: not enough arguments");
+    epsbits = highbit(1 + int (1 / epsilon())) +1;
+    if (param(0) < 3 || isnull(points)) {
+        /* return as given */
+        return quadtscore(a, b);
+    } else {
+        if ((isinfinite(a) || isinfinite(b))
+            && (!ismat(points) && !islist(points)))
+            return
+                newerror(strcat
+                         ("quadts: segments of infinite length ",
+                          "are not yet supported"));
+        if (ismat(points) || islist(points)) {
+            sp = size(points);
+            if (sp == 0)
+                return
+                    newerror(strcat
+                             ("quadts: variable 'points` must be a list or ",
+                              "1d-matrix of a length > 0"));
+            /* check if all points are numbers */
+            for (k = 0; k < sp; k++) {
+                if (!isnum(points[k]))
+                    return
+                        newerror(strcat
+                                 ("quadts: elements of 'points` must be",
+                                  " numbers only"));
+            }
+            /* We have n-1 intervals and a and b, hence n-1 + 2 results */
+            results = mat[sp + 1];
+            if (a != points[0]) {
+                results[0] = quadtscore(a, points[0]);
+            } else {
+                results[0] = 0;
+            }
+            if (sp == 1) {
+                if (b != points[0]) {
+                    results[1] = quadtscore(points[0], b);
+                } else {
+                    results[1] = 0;
+                }
+            } else {
+                for (k = 1; k < sp; k++) {
+                    results[k] = quadtscore(points[k - 1], points[k]);
+                }
+                if (b != points[k - 1]) {
+                    results[k] = quadtscore(points[k - 1], b);
+                } else {
+                    results[k] = 0;
+                }
+            }
+        } else {
+            if (!isint(points) || points <= 0)
+                return newerror(strcat("quadts: variable 'points` must be a ",
+                                       "list or a positive integer"));
+            /* Taking "points" as the number of equally spaced intervals */
+            results = mat[points + 1];
+            /* It is easy if a,b lie on the real line */
+            if (isreal(a) && isreal(b)) {
+                length = abs(a - b);
+                segment = length / points;
+
+                for (k = 1; k <= points; k++) {
+                    results[k - 1] =
+                        quadtscore(a + (k - 1) * segment, a + k * segment);
+                }
+            } else {
+                /* We have at least one complex limit but treat "points" still
+                 * as the number of equally spaced intervals on a straight line
+                 * connecting a and b. Computing the segments here is a bit
+                 * more complicated but not much, it should have been taught in
+                 * high school.
+                 * Other contours by way of a list of points */
+                slope = (im(b) - im(a)) / (re(b) - re(a));
+                C = (im(a) + slope) * re(a);
+                length = abs(re(a) - re(b));
+                segment = length / points;
+
+                /* y = mx+C where m is the slope, x is the real part and y the
+                 * imaginary part  */
+                if(re(a)>re(b))swap(a,b);
+                for (k = re(a); k <= (re(b)); k+=segment) {
+                    x1 = slope*(k) +  C;
+                    results[k] = quadtscore(k + x1 * 1i);
+                }
+            }                   /* else of isreal */
+        }                       /* else of ismat|islist */
+    }                           /* else of isnull(points) */
+    /* With a bit of undeserved luck we have a result by now. */
+    sp = size(results);
+    for (k = 0; k < sp; k++) {
+        sum += results[k];
+    }
+    return sum;
+}
+
+static __CZ__gl_x;
+static __CZ__gl_w;
+static __CZ__gl_order;
+static __CZ__gl_prec;
+
+define quadglcomputenodes(N)
+{
+    local places k l x w t1 t2 t3 t4 t5 r tmp;
+
+    if (__CZ__gl_order == N && __CZ__gl_prec == epsilon())
+        return;
+
+    __CZ__gl_x = mat[N];
+    __CZ__gl_w = mat[N];
+    __CZ__gl_order = N;
+    __CZ__gl_prec = epsilon();
+
+    places = highbit(1 + int (1 / epsilon())) +1;
+
+    /*
+     * Compute roots and weights (doing it inline seems to be fastest)
+     * Trick shamelessly stolen from D. Bailey et .al (program "arprec")
+     */
+    for (k = 1; k <= N//2; k++) {
+        r = bround(cos(pi() * (k - .25) / (N + .5)), places);
+        while (1) {
+            t1 = 1, t2 = 0;
+            for (l = 1; l <= N; l++) {
+                t3 = t2;
+                t2 = t1;
+                t1 = bround(((2 * l - 1) * r * t2 - (l - 1) * t3) / l, places);
+            }
+            t4 = bround(N * (r * t1 - t2) / ((r ^ 2) - 1), places);
+            t5 = r;
+            tmp = t1 / t4;
+            r = r - tmp;
+            if (abs(tmp) <= epsilon())
+                break;
+        }
+        x = r;
+        w = bround(2 / ((1 - r ^ 2) * t4 ^ 2), places);
+
+        __CZ__gl_x[k - 1] = x;
+        __CZ__gl_w[k - 1] = w;
+        __CZ__gl_x[N - k] = -__CZ__gl_x[k - 1];
+        __CZ__gl_w[N - k] = __CZ__gl_w[k - 1];
+    }
+    return;
+}
+
+define quadgldeletenodes()
+{
+    free(__CZ__gl_x);
+    free(__CZ__gl_w);
+    free(__CZ__gl_order);
+    free(__CZ__gl_prec);
+}
+
+define quadglcore(a, b, n)
+{
+    local k c d digs order eps places sum ret err x x1 w w1 m;
+    local phalf x2 px1 spx1 u b1 a1 half;
+
+    eps = epsilon(epsilon() * 1e-2);
+    places = highbit(1 + int (1 / epsilon())) +1;
+    if (!isnull(n))
+        order = n;
+    else {
+        m = int (4 + max(0, ln(places / 30.0) / ln(2))) + 2;
+        order = 3 * 2 ^ (m - 1);
+    }
+
+
+    quadglcomputenodes(order, 1);
+
+    if (isinfinite(a) || isinfinite(b)) {
+        if (isninf(a) && ispinf(b)) {
+            for (k = 0; k < order; k++) {
+                x1 = __CZ__gl_x[k];
+                w1 = __CZ__gl_w[k];
+
+                x = bround(x1 * (1 - x1 ^ 2) ^ (-1 / 2), places);
+                w = bround(w1 * (((1 - x1 ^ 2) ^ (-1 / 2)) / (1 - x1 ^ 2)),
+                           places);
+                sum += bround(w * f(x), places);
+            }
+        } else if (isninf(a) && !iscinf(b)) {
+            for (k = 0; k < order; k++) {
+                x1 = __CZ__gl_x[k];
+                w1 = __CZ__gl_w[k];
+
+                x = bround((b + 1) - (2 / (x1 + 1)), places);
+                w = bround(w1 * (1 / 2 * (2 / (x1 + 1)) ^ 2), places);
+                sum += bround(w * f(x), places);
+            }
+        } else if (!iscinf(a) && ispinf(b)) {
+            for (k = 0; k < order; k++) {
+                x1 = __CZ__gl_x[k];
+                w1 = __CZ__gl_w[k];
+                x = bround((a - 1) + (2 / (x1 + 1)), places);
+                w = bround(w1 * (((1 / 2) * (2 / (x1 + 1)) ^ 2)), places);
+                sum += bround(w * f(x), places);
+            }
+        } else if (isninf(a) || isninf(b)) {
+            /*TODO: swap(a,b) and negate(w)? Lookup! */
+            return newerror("quadglcore: reverse limits?");
+        } else
+            return
+                newerror("quadglcore: complex infinity not yet implemented");
+        ret = sum;
+    } else {
+        /* Avoid rounding errors */
+        if (a == -1 && b == 1) {
+            c = 1;
+            d = 0;
+        } else {
+            c = (b - a) / 2;
+            d = (b + a) / 2;
+        }
+        sum = 0;
+        for (k = 0; k < order; k++) {
+            sum += bround(__CZ__gl_w[k] * f(c * __CZ__gl_x[k] + d), places);
+        }
+        ret = c * sum;
+    }
+    epsilon(eps);
+    return ret;
+}
+
+define quadgl(a, b, points)
+{
+    local k sp results epsbits nsect interval length segment slope C x1 y1 x2
+        y2;
+    local sum D1 D2 D3 D4;
+    if (param(0) < 2)
+        return newerror("quadgl: not enough arguments");
+    epsbits = highbit(1 + int (1 / epsilon())) +1;
+    if (isnull(points)) {
+        /* return as given */
+        return quadglcore(a, b);
+    } else {
+        /* But if we could half the time needed to execute a single operation
+         * we could do all of it in just twice that time. */
+        if (isinfinite(a) || isinfinite(b)
+            && (!ismat(points) && !islist(points)))
+            return
+                newerror(strcat
+                         ("quadgl: multiple segments of infinite length ",
+                          "are not yet supported"));
+        if (ismat(points) || islist(points)) {
+            sp = size(points);
+            if (sp == 0)
+                return
+                    newerror(strcat
+                             ("quadgl: variable 'points` must be a list or ",
+                              "1d-matrix of a length > 0"));
+            /* check if all points are numbers */
+            for (k = 0; k < sp; k++) {
+                if (!isnum(points[k]))
+                    return
+                        newerror(strcat
+                                 ("quadgl: elements of 'points` must be ",
+                                  "numbers only"));
+            }
+            /* We have n-1 intervals and a and b, hence n-1 + 2 results */
+            results = mat[sp + 1];
+            if (a != points[0]) {
+                results[0] = quadglcore(a, points[0]);
+            } else {
+                results[0] = 0;
+            }
+            if (sp == 1) {
+                if (b != points[0]) {
+                    results[1] = quadglcore(points[0], b);
+                } else {
+                    results[1] = 0;
+                }
+            } else {
+                for (k = 1; k < sp; k++) {
+                    results[k] = quadglcore(points[k - 1], points[k]);
+                }
+                if (b != points[k - 1]) {
+                    results[k] = quadglcore(points[k - 1], b);
+                } else {
+                    results[k] = 0;
+                }
+            }
+        } else {
+            if (!isint(points) || points <= 0)
+                return newerror(strcat("quadgl: variable 'points` must be a ",
+                                       "list or a positive integer"));
+            /* Taking "points" as the number of equally spaced intervals */
+            results = mat[points + 1];
+            /* It is easy if a,b lie on the real line */
+            if (isreal(a) && isreal(b)) {
+                length = abs(a - b);
+                segment = length / points;
+
+                for (k = 1; k <= points; k++) {
+                    results[k - 1] =
+                        quadglcore(a + (k - 1) * segment, a + k * segment);
+                }
+            } else {
+                /* Other contours by way of a list of points */
+                slope = (im(b) - im(a)) / (re(b) - re(a));
+                C = (im(a) + slope) * re(a);
+                length = abs(re(a) - re(b));
+                segment = length / points;
+
+                /* y = mx+C where m is the slope, x is the real part and y the
+                 * imaginary part  */
+                if(re(a)>re(b))swap(a,b);
+                for (k = re(a); k <= (re(b)); k+=segment) {
+                    x1 = slope*(k) +  C;
+                    results[k] = quadglcore(k + x1 * 1i);
+                }
+            }                   /* else of isreal */
+        }                       /* else of ismat|islist */
+    }                           /* else of isnull(points) */
+    /* With a bit of undeserved luck we have a result by now. */
+    sp = size(results);
+    for (k = 0; k < sp; k++) {
+        sum += results[k];
+    }
+    return sum;
+}
+
+define quad(a, b, points = -1, method = "tanhsinh")
+{
+    if (isnull(a) || isnull(b) || param(0) < 2)
+        return newerror("quad: both limits must be given");
+    if (isstr(a)) {
+        if (strncmp(a, "cinf", 1) == 0)
+            return
+                newerror(strcat
+                         ("quad: complex infinity not yet supported, use",
+                          " 'pinf' or 'ninf' respectively"));
+    }
+    if (isstr(b)) {
+        if (strncmp(b, "cinf", 1) == 0)
+            return
+                newerror(strcat
+                         ("quad: complex infinity not yet supported, use",
+                          " 'pinf' or 'ninf' respectively"));
+    }
+
+    if (param(0) == 3) {
+        if (isstr(points))
+            method = points;
+    }
+
+    if (strncmp(method, "tanhsinh", 1) == 0) {
+        if (!isstr(points)) {
+            if (points == -1) {
+                return quadts(a, b);
+            } else {
+                return quadts(a, b, points);
+            }
+        } else {
+            return quadts(a, b);
+        }
+    }
+
+    if (strncmp(method, "gausslegendre", 1) == 0) {
+        if (!isstr(points)) {
+            if (points == -1) {
+                return quadgl(a, b);
+            } else {
+                return quadgl(a, b, points);
+            }
+        } else {
+            return quadgl(a, b);
+        }
+    }
+}
+
+define makerange(start, end, steps)
+{
+    local ret k l step C length slope x1 x2 y1 y2;
+    local segment;
+    steps = int (steps);
+    if (steps < 1) {
+        return newerror("makerange: number of steps must be > 0");
+    }
+    if (!isnum(start) || !isnum(end)) {
+        return newerror("makerange: only numbers are supported yet");
+    }
+    if (isreal(start) && isreal(end)) {
+        step = (end - start) / (steps);
+        print step;
+        ret = mat[steps + 1];
+        for (k = 0; k <= steps; k++) {
+            ret[k] = k * step + start;
+        }
+    } else {
+        ret = mat[steps + 1];
+        if (re(start) > re(end)) {
+            swap(start, end);
+        }
+
+        slope = (im(end) - im(start)) / (re(end) - re(start));
+        C = im(start) - slope * re(start);
+        length = abs(re(start) - re(end));
+        segment = length / (steps);
+
+        for (k = re(start), l = 0; k <= (re(end)); k += segment, l++) {
+            x1 = slope * (k) + C;
+            ret[l] = k + x1 * 1i;
+        }
+
+    }
+    return ret;
+}
+
+define makecircle(radius, center, points)
+{
+    local ret k a b twopi centerx centery;
+    if (!isint(points) || points < 2) {
+        return
+            newerror("makecircle: number of points is not a positive integer");
+    }
+    if (!isnum(center)) {
+        return newerror("makecircle: center does not lie on the complex plane");
+    }
+    if (!isreal(radius) || radius <= 0) {
+        return newerror("makecircle: radius is not a real > 0");
+    }
+    ret = mat[points];
+    twopi = 2 * pi();
+    centerx = re(center);
+    centery = im(center);
+    for (k = 0; k < points; k++) {
+        a = centerx + radius * cos(twopi * k / points);
+        b = centery + radius * sin(twopi * k / points);
+        ret[k] = a + b * 1i;
+    }
+    return ret;
+}
+
+define makeellipse(angle, a, b, center, points)
+{
+    local ret k x y twopi centerx centery;
+    if (!isint(points) || points < 2) {
+        return
+            newerror("makeellipse: number of points is not a positive integer");
+    }
+    if (!isnum(center)) {
+        return
+            newerror("makeellipse: center does not lie on the complex plane");
+    }
+    if (!isreal(a) || a <= 0) {
+        return newerror("makecircle: a is not a real > 0");
+    }
+    if (!isreal(b) || b <= 0) {
+        return newerror("makecircle: b is not a real > 0");
+    }
+    if (!isreal(angle)) {
+        return newerror("makecircle: angle is not a real");
+    }
+    ret = mat[points];
+    twopi = 2 * pi();
+    centerx = re(center);
+    centery = im(center);
+    for (k = 0; k < points; k++) {
+        x = centerx + a * cos(twopi * k / points) * cos(angle)
+            - b * sin(twopi * k / points) * sin(angle);
+        y = centerx + a * cos(twopi * k / points) * sin(angle)
+            + b * sin(twopi * k / points) * cos(angle);
+        ret[k] = x + y * 1i;
+    }
+    return ret;
+}
+
+define makepoints()
+{
+    local ret k;
+    ret = mat[param(0)];
+    for (k = 0; k < param(0); k++) {
+        if (!isnum(param(k + 1))) {
+            return
+                newerror(strcat
+                         ("makepoints: parameter number \"", str(k + 1),
+                          "\" is not a number"));
+        }
+        ret[k] = param(k + 1);
+    }
+    return ret;
+}
+
+
+config("resource_debug", resource_debug_level),;
+if (config("resource_debug") & 3) {
+    print "quadtsdeletenodes()";
+    print "quadtscomputenodes(order, expo, eps)";
+    print "quadtscore(a,b,n)";
+    print "quadts(a,b,points)";
+    print "quadglcomputenodes(N)";
+    print "quadgldeletenodes()";
+    print "quadglcore(a,b,n)";
+    print "quadgl(a,b,points)";
+    print "quad(a,b,points=-1,method=\"tanhsinh\")";
+    print "makerange(start, end, steps)";
+    print "makecircle(radius, center, points)";
+    print "makeellipse(angle, a, b, center, points)";
+    print "makepoints(a1,[...])";
+}

cal/lambertw.cal

@@ -0,0 +1,284 @@
+/*
+ * lambertw - Lambert's W-function
+ *
+ * Copyright (C) 2013,2021 Christoph Zurnieden
+ *
+ * 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.
+ *
+ * Under source code control:   2013/08/11 01:31:28
+ * File existed as early as:    2013
+ */
+
+
+static resource_debug_level;
+resource_debug_level = config("resource_debug", 0);
+
+
+/*
+
+     R. M. Corless and G. H. Gonnet and D. E. G. Hare and D. J. Jeffrey and
+     D. E. Knuth, "On the Lambert W Function", Advances n Computational
+     Mathematics, 329--359, (1996)
+     http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.112.6117
+
+     D. J. Jeffrey, D. E. G. Hare, R. M. Corless, "Unwinding the branches of the
+     Lambert W function", The Mathematical Scientist, 21, pp 1-7, (1996)
+     http://www.apmaths.uwo.ca/~djeffrey/Offprints/wbranch.pdf
+
+     Darko Verebic, "Having Fun with Lambert W(x) Function"
+     arXiv:1003.1628v1, March 2010, http://arxiv.org/abs/1003.1628
+
+     Winitzki, S. "Uniform Approximations for Transcendental Functions",
+     In Part 1 of Computational Science and its Applications - ICCSA 2003,
+     Lecture Notes in Computer Science, Vol. 2667, Springer-Verlag,
+     Berlin, 2003, 780-789. DOI 10.1007/3-540-44839-X_82
+     A copy may be found by Google.
+
+
+*/
+static true = 1;
+static false = 0;
+
+/* Branch 0, Winitzki (2003) , the well known Taylor series*/
+define __CZ__lambertw_0(z,eps){
+  local a=2.344e0, b=0.8842e0, c=0.9294e0, d=0.5106e0, e=-1.213e0;
+  local y=sqrt(2*exp(1)*z+2);
+  return (2*ln(1+b*y)-ln(1+c*ln(1+d*y))+e)/(1+1/(2*ln(1+b*y)+2*a));
+}
+/* branch -1 */
+define __CZ__lambertw_m1(z,eps){
+  local wn k;
+  /* Cut-off found in Maxima */
+  if(z < 0.3) return __CZ__lambertw_app(z,eps);
+  wn = z;
+  /*  Verebic (2010) eqs. 16-18*/
+  for(k=0;k<10;k++){
+    wn = ln(-z)-ln(-wn);
+  }
+  return wn;
+}
+
+/*
+  generic approximation
+
+  series for 1+W((z-2)/(2 e))
+
+  Corless et al (1996) (4.22)
+  Verebic (2010) eqs. 35-37; more coefficients given at the end of sect. 3.1
+  or online
+     http://www.wolframalpha.com/input/?
+       i=taylor+%28+1%2Bproductlog%28+%28z-2%29%2F%282*e%29+%29+%29
+  or by using the function lambertw_series_print() after running
+  lambertw_series(z,eps,branch,terms) at least once with the wanted number of
+  terms and z = 1 (which might throw an error because the series will not
+  converge in anybodies lifetime for something that far from the branch point).
+
+
+*/
+define __CZ__lambertw_app(z,eps){
+  local  b0=-1, b1=1, b2=-1/3, b3=11/72;
+  local  y=sqrt(2*exp(1)*z+2);
+  return b0 + ( y * (b1 + (y * (b2 + (b3 * y)))));
+}
+
+static __CZ__Ws_a;
+static __CZ__Ws_c;
+static __CZ__Ws_len=0;
+
+define lambertw_series_print(){
+  local k;
+  for(k=0;k<__CZ__Ws_len;k++){
+    print num(__CZ__Ws_c[k]):"/":den(__CZ__Ws_c[k]):"*p^":k;
+  }
+}
+
+/*
+   The series is fast but only if _very_ close to the branch point
+   The exact branch must be given explicitly, e.g.:
+
+; lambertw(-exp(-1)+.001)-lambertw_series(-exp(-1)+.001,epsilon()*1e-10,0)
+        -0.14758879113205794065490184399030194122136720202792-
+                  0.00000000000000000000000000000000000000000000000000i
+; lambertw(-exp(-1)+.001)-lambertw_series(-exp(-1)+.001,epsilon()*1e-10,1)
+        0.00000000000000000000000000000000000000000000000000-
+                  0.00000000000000000000000000000000000000000000000000i
+ */
+define lambertw_series(z,eps,branch,terms){
+  local k l limit tmp sum A C P PP epslocal;
+  if(!isnull(terms))
+    limit = terms;
+  else
+    limit = 100;
+
+  if(isnull(eps))
+    eps = epsilon(epsilon()*1e-10);
+  epslocal = epsilon(eps);
+
+  P = sqrt(2*(exp(1)*z+1));
+  if(branch != 0) P = -P;
+  tmp=0;sum=0;PP=P;
+
+    __CZ__Ws_a   = mat[limit+1];
+    __CZ__Ws_c   = mat[limit+1];
+    __CZ__Ws_len = limit;
+   /*
+      c0 = -1; c1 = 1
+      a0 =  2; a1 =-1
+    */
+    __CZ__Ws_c[0] = -1; __CZ__Ws_c[1] =  1;
+    __CZ__Ws_a[0] =  2; __CZ__Ws_a[1] = -1;
+    sum += __CZ__Ws_c[0];
+    sum += __CZ__Ws_c[1] * P;
+    PP *= P;
+    for(k=2;k<limit;k++){
+      for(l=2;l<k;l++){
+         __CZ__Ws_a[k] += __CZ__Ws_c[l]*__CZ__Ws_c[k+1-l];
+      }
+
+      __CZ__Ws_c[k] = (k-1) * (  __CZ__Ws_c[k-2]/2
+                            +__CZ__Ws_a[k-2]/4)/
+                      (k+1)-__CZ__Ws_a[k]/2-__CZ__Ws_c[k-1]/(k+1);
+      tmp = __CZ__Ws_c[k] * PP;
+      sum += tmp;
+      if(abs(tmp) <= eps){
+        epsilon(epslocal);
+        return sum;
+      }
+      PP *= P;
+    }
+    epsilon(epslocal);
+    return
+      newerror(strcat("lambertw_series: does not converge in ",
+                        str(limit)," terms" ));
+}
+
+/* */
+define lambertw(z,branch){
+  local eps epslarge ret branchpoint bparea w we ew w1e wn k places m1e;
+  local closeness;
+
+  eps = epsilon();
+  if(branch == 0){
+    if(!im(z)){
+      if(abs(z) <= eps) return 0;
+      if(abs(z-exp(1)) <= eps) return 1;
+      if(abs(z - (-ln(2)/2)) <= eps ) return -ln(2);
+      if(abs(z - (-pi()/2)) <= eps ) return 1i*pi()/2;
+    }
+  }
+
+  branchpoint = -exp(-1);
+  bparea = .2;
+  if(branch == 0){
+    if(!im(z) && abs(z-branchpoint) == 0) return -1;
+    ret = __CZ__lambertw_0(z,eps);
+   /* Yeah, C&P, I know, sorry */
+   ##ret = ln(z) + 2*pi()*1i*branch - ln(ln(z)+2*pi()*1i*branch);
+  }
+  else if(branch == 1){
+    if(im(z)<0 && abs(z-branchpoint) <= bparea)
+      ret = __CZ__lambertw_app(z,eps);
+   /* Does calc have a goto? Oh, it does!  */
+    ret =ln(z) + 2*pi()*1i*branch - ln(ln(z)+2*pi()*1i*branch);
+  }
+  else if(branch == -1){##print "-1";
+    if(!im(z) && abs(z-branchpoint) == 0) return -1;
+    if(!im(z) && z>branchpoint && z < 0){##print "0";
+      ret = __CZ__lambertw_m1(z,eps);}
+    if(im(z)>=0 && abs(z-branchpoint) <= bparea){##print "1";
+      ret = __CZ__lambertw_app(z,eps);}
+    ret =ln(z) + 2*pi()*1i*branch - ln(ln(z)+2*pi()*1i*branch);
+  }
+  else
+    ret = ln(z) + 2*pi()*1i*branch - ln(ln(z)+2*pi()*1i*branch);
+
+  /*
+     Such a high precision is only needed _very_ close to the branchpoint
+     and might even be insufficient if z has not been computed with
+     sufficient precision itself (M below was calculated by Mathematica and also
+     with the series above with epsilon(1e-200)):
+    ; epsilon(1e-50)
+        0.00000000000000000001
+    ; display(50)
+        20
+    ; M=-0.9999999999999999999999997668356018402875796636464119050387
+    ; lambertw(-exp(-1)+1e-50,0)-M
+        -0.00000000000000000000000002678416515423276355643684
+    ; epsilon(1e-60)
+        0.0000000000000000000000000000000000000000000000000
+    ; A=-exp(-1)+1e-50
+    ; epsilon(1e-50)
+        0.00000000000000000000000000000000000000000000000000
+    ; lambertw(A,0)-M
+        -0.00000000000000000000000000000000000231185460220585
+    ; lambertw_series(A,epsilon(),0)-M
+        -0.00000000000000000000000000000000000132145133161626
+    ; epsilon(1e-100)
+        0.00000000000000000000000000000000000000000000000001
+    ; A=-exp(-1)+1e-50
+    ; epsilon(1e-65)
+        0.00000000000000000000000000000000000000000000000000
+    ; lambertw_series(A,epsilon(),0)-M
+        0.00000000000000000000000000000000000000000000000000
+    ; lambertw_series(-exp(-1)+1e-50,epsilon(),0)-M
+        -0.00000000000000000000000000000000000000002959444084
+    ; epsilon(1e-74)
+        0.00000000000000000000000000000000000000000000000000
+    ; lambertw_series(-exp(-1)+1e-50,epsilon(),0)-M
+        -0.00000000000000000000000000000000000000000000000006
+   */
+  closeness = abs(z-branchpoint);
+  if( closeness< 1){
+    if(closeness != 0)
+      eps = epsilon(epsilon()*( closeness));
+    else
+      eps = epsilon(epsilon()^2);
+  }
+  else
+    eps = epsilon(epsilon()*1e-2);
+
+
+  epslarge =epsilon();
+
+  places = highbit(1 + int(1/epslarge)) + 1;
+  w = ret;
+  for(k=0;k<100;k++){
+    ew = exp(w);
+    we = w*ew;
+    if(abs(we-z)<= 4*epslarge*abs(z))break;
+    w1e = (1+w)*ew;
+    wn = bround(w- ((we - z) / ( w1e - ( (w+2)*(we-z) )/(2*w+2)  ) ),places++) ;
+    if( abs(wn - w) <= epslarge*abs(wn)) break;
+    else  w = wn;
+  }
+
+  if(k==100){
+    epsilon(eps);
+    return newerror("lambertw: Halley iteration does not converge");
+  }
+  /* The Maxima coders added a check if the iteration converged to the correct
+     branch. This coder deems it superfluous. */
+
+  epsilon(eps);
+  return wn;
+}
+
+
+config("resource_debug", resource_debug_level),;
+if (config("resource_debug") & 3) {
+    print "lambertw(z,branch)";
+    print "lambertw_series(z,eps,branch,terms)";
+    print "lambertw_series_print()";
+}

cal/linear.cal

@@ -0,0 +1,52 @@
+/*
+ * linear - perform a simple two point 2D linear interpolation
+ *
+ * Copyright (C) 2005-2007,2021  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.
+ *
+ * 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 known 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/lnseries.cal

@@ -0,0 +1,108 @@
+/*
+ * lnseries - special functions (e.g.: gamma, zeta, psi)
+ *
+ * Copyright (C) 2013 Christoph Zurnieden
+ *
+ * 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.
+ *
+ * Under source code control:   2013/08/11 01:31:28
+ * File existed as early as:    2013
+ */
+
+
+/*
+ * hide internal function from resource debugging
+ */
+static resource_debug_level;
+resource_debug_level = config("resource_debug", 0);
+
+
+static __CZ__int_logs;
+static __CZ__int_logs_limit;
+static __CZ__int_logs_prec;
+
+
+define deletelnseries(){
+  free(__CZ__int_logs,__CZ__int_logs_limit,__CZ__int_logs_prec);
+}
+
+define lnfromseries(n){
+  if(    isnull(__CZ__int_logs)
+      || __CZ__int_logs_limit < n
+      || __CZ__int_logs_prec < log(1/epsilon())){
+
+    lnseries(n+1);
+  }
+  return __CZ__int_logs[n,0];
+}
+
+define lnseries(limit){
+  local k j eps ;
+  if(    isnull(__CZ__int_logs)
+      || __CZ__int_logs_limit < limit
+      || __CZ__int_logs_prec < log(1/epsilon())){
+    __CZ__int_logs = mat[limit+1,2];
+    __CZ__int_logs_limit = limit;
+    __CZ__int_logs_prec = log(1/epsilon());
+
+    /* probably still too much */
+    eps = epsilon(epsilon()*10^(-(5+log(limit))));
+    k =2;
+    while(1){
+      /* the prime itself, compute logarithm */
+      __CZ__int_logs[k,0] = ln(k);
+      __CZ__int_logs[k,1] = k;
+
+      for(j = 2*k;j<=limit;j+=k){
+       /* multiples of prime k, add logarithm of k computed earlier */
+       __CZ__int_logs[j,0] += __CZ__int_logs[k,0];
+       /* First hit, set counter to number */
+       if(__CZ__int_logs[j,1] ==0)
+         __CZ__int_logs[j,1]=j;
+       /* reduce counter by prime added */
+       __CZ__int_logs[j,1] //= __CZ__int_logs[k,1];
+      }
+
+      k++;
+      if(k>=limit) break;
+      /* Erastothenes-sieve: look for next prime. */
+      while(__CZ__int_logs[k,0]!=0){
+        k++;
+        if(k>=limit) break;
+      }
+    }
+    /* Second run to include the last factor */
+    for(k=1;k<=limit;k++){
+      if(__CZ__int_logs[k,1] != k){
+        __CZ__int_logs[k,0] +=__CZ__int_logs[ __CZ__int_logs[k,1],0];
+        __CZ__int_logs[k,1] = 0;
+      }
+    }
+
+    epsilon(eps);
+  }
+  return 1;
+}
+
+
+/*
+ * restore internal function from resource debugging
+ */
+config("resource_debug", resource_debug_level),;
+if (config("resource_debug") & 3) {
+    print "lnseries(limit)";
+    print "lnfromseries(n)";
+    print "deletelnseries()";
+}

cal/lucas_chk.cal

@@ -1,7 +1,7 @@
 /*
  * lucas_chk - test all primes of the form h*2^n-1, 1<=h<200 and n <= high_n
  *
- * Copyright (C) 1999  Landon Curt Noll
+ * Copyright (C) 1999,2021  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
@@ -9,23 +9,19 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: lucas_chk.cal,v 29.1 1999/12/14 09:15:31 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
  *
- * Under source code control:	1991/01/11 05:41:43
- * File existed as early as:	1991
- *
- * chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -35,260 +31,260 @@
  *
  * These values were taken from:
  *
- *	"Prime numbers and Computer Methods for Factorization", by Hans Riesel,
- *	Birkhauser, 1985, pp 384-387.
+ *      "Prime numbers and Computer Methods for Factorization", by Hans Riesel,
+ *      Birkhauser, 1985, pp 384-387.
  *
  * This routine assumes that the file "lucas.cal" has been loaded.
  *
  * NOTE: There are several errors in Riesel's table that have been corrected
- *	 in this file:
+ *       in this file:
  *
- *		193*2^87-1 is prime
- *		193*2^97-1 is NOT prime
- *		199*2^211-1 is prime
- *		199*2^221-1 is NOT prime
+ *              193*2^87-1 is prime
+ *              193*2^97-1 is NOT prime
+ *              199*2^211-1 is prime
+ *              199*2^221-1 is NOT prime
  */
 
 
-static prime_cnt = 1145;	/* number of primes in the list */
+static prime_cnt = 1145;        /* number of primes in the list */
 
 /* h = prime parameters */
 static mat h_p[prime_cnt] = {
-	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,			/* element 0 */
-	1, 1, 1, 1, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 5,
-	5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-	5, 5, 5, 5, 5, 5, 7, 7, 7, 7,
-	7, 7, 7, 7, 9, 9, 9, 9, 9, 9,
-	9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
-	9, 9, 9, 11, 11, 11, 11, 11, 11, 11,
-	11, 11, 11, 13, 13, 13, 13, 13, 13, 15,
-	15, 15, 15, 15, 15, 15, 15, 15, 15, 15,		/* 100 */
-	15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-	15, 15, 17, 17, 17, 17, 17, 17, 17, 17,
-	17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
-	17, 17, 19, 19, 19, 19, 19, 19, 19, 19,
-	19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-	19, 19, 21, 21, 21, 21, 21, 21, 21, 21,
-	21, 21, 21, 21, 21, 21, 21, 21, 23, 23,
-	23, 23, 23, 23, 23, 23, 23, 25, 25, 25,
-	25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-	25, 25, 25, 27, 27, 27, 27, 27, 27, 27,		/* 200 */
-	27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-	27, 27, 27, 27, 27, 27, 27, 29, 29, 29,
-	29, 29, 31, 31, 31, 31, 31, 31, 31, 31,
-	31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
-	33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
-	33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
-	33, 33, 33, 33, 35, 35, 35, 35, 35, 35,
-	35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
-	35, 37, 39, 39, 39, 39, 39, 39, 39, 39,
-	39, 41, 41, 41, 41, 41, 41, 41, 41, 41,		/* 300 */
-	41, 41, 41, 41, 43, 43, 43, 43, 43, 45,
-	45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
-	45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
-	45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
-	45, 45, 45, 45, 45, 47, 47, 47, 47, 49,
-	49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
-	49, 49, 49, 49, 49, 49, 51, 51, 51, 51,
-	51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
-	51, 53, 53, 53, 53, 53, 53, 53, 53, 53,
-	53, 55, 55, 55, 55, 55, 55, 55, 55, 55,		/* 400 */
-	55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
-	57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
-	57, 57, 57, 57, 57, 57, 57, 57, 59, 59,
-	59, 59, 59, 59, 61, 61, 61, 61, 61, 61,
-	61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-	61, 63, 63, 63, 63, 63, 63, 63, 63, 63,
-	63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
-	63, 63, 63, 63, 65, 65, 65, 65, 65, 65,
-	65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
-	65, 65, 67, 67, 67, 67, 67, 67, 67, 67,		/* 500 */
-	69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
-	69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
-	69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
-	69, 69, 71, 71, 71, 73, 73, 73, 73, 73,
-	73, 75, 75, 75, 75, 75, 75, 75, 75, 75,
-	75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
-	75, 75, 75, 75, 75, 75, 75, 77, 77, 77,
-	77, 77, 77, 77, 77, 77, 77, 77, 77, 79,
-	79, 79, 79, 79, 79, 79, 79, 79, 79, 79,
-	81, 81, 81, 81, 81, 81, 81, 81, 81, 81,		/* 600 */
-	81, 81, 81, 83, 83, 83, 83, 83, 83, 83,
-	83, 83, 83, 83, 83, 83, 83, 83, 83, 83,
-	83, 83, 83, 83, 83, 85, 85, 85, 85, 85,
-	85, 85, 85, 85, 87, 87, 87, 87, 87, 87,
-	87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
-	87, 87, 87, 87, 87, 87, 89, 89, 89, 89,
-	89, 89, 89, 89, 89, 91, 91, 91, 91, 91,
-	91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
-	91, 91, 91, 91, 91, 91, 91, 93, 93, 93,
-	93, 93, 93, 93, 93, 93, 93, 93, 93, 93,		/* 700 */
-	93, 93, 93, 93, 93, 95, 95, 95, 95, 95,
-	95, 95, 95, 95, 95, 97, 97, 97, 97, 97,
-	99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
-	99, 99, 99, 99, 99, 99, 101, 101, 101, 101,
-	103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
-	103, 103, 103, 105, 105, 105, 105, 105, 105, 105,
-	105, 105, 105, 105, 105, 105, 105, 105, 105, 105,
-	105, 105, 107, 107, 107, 107, 107, 107, 107, 107,
-	107, 107, 107, 107, 107, 107, 109, 109, 109, 109,
-	109, 113, 113, 113, 113, 113, 113, 113, 113, 113,	/* 800 */
-	113, 115, 115, 115, 115, 115, 115, 115, 115, 115,
-	115, 115, 115, 115, 115, 115, 115, 119, 119, 119,
-	119, 119, 119, 119, 119, 121, 121, 121, 121, 121,
-	121, 121, 121, 121, 121, 121, 121, 125, 125, 125,
-	125, 125, 125, 127, 127, 131, 131, 131, 131, 131,
-	131, 131, 131, 131, 131, 133, 133, 133, 133, 133,
-	133, 133, 133, 133, 133, 133, 133, 133, 137, 137,
-	137, 137, 139, 139, 139, 139, 139, 139, 139, 139,
-	139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
-	139, 139, 139, 139, 139, 139, 139, 139, 139, 143,	/* 900 */
-	143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
-	143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
-	143, 143, 143, 145, 145, 145, 145, 145, 145, 145,
-	145, 145, 145, 145, 149, 149, 149, 149, 149, 149,
-	149, 151, 151, 151, 155, 155, 155, 155, 155, 155,
-	155, 155, 155, 155, 155, 155, 157, 157, 157, 157,
-	157, 157, 157, 157, 157, 161, 161, 161, 161, 161,
-	161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
-	163, 163, 163, 163, 167, 167, 167, 167, 167, 167,
-	167, 167, 167, 167, 167, 167, 169, 169, 169, 169,	/* 1000 */
-	169, 169, 169, 169, 169, 169, 169, 169, 173, 173,
-	173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
-	173, 173, 173, 173, 175, 175, 175, 175, 175, 175,
-	175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
-	179, 179, 179, 181, 181, 181, 181, 181, 181, 181,
-	181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
-	181, 181, 181, 181, 181, 181, 181, 181, 185, 185,
-	185, 185, 185, 185, 185, 185, 185, 185, 187, 187,
-	187, 187, 187, 191, 193, 193, 193, 193, 193, 193,
-	193, 197, 197, 197, 197, 197, 197, 197, 197, 197,	/* 1100 */
-	197, 197, 197, 197, 197, 197, 197, 197, 197, 199,
-	199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
-	199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
-	199, 199, 199, 199, 199
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1,                   /* element 0 */
+        1, 1, 1, 1, 3, 3, 3, 3, 3, 3,
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 5,
+        5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+        5, 5, 5, 5, 5, 5, 7, 7, 7, 7,
+        7, 7, 7, 7, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 11, 11, 11, 11, 11, 11, 11,
+        11, 11, 11, 13, 13, 13, 13, 13, 13, 15,
+        15, 15, 15, 15, 15, 15, 15, 15, 15, 15,         /* 100 */
+        15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+        15, 15, 17, 17, 17, 17, 17, 17, 17, 17,
+        17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+        17, 17, 19, 19, 19, 19, 19, 19, 19, 19,
+        19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+        19, 19, 21, 21, 21, 21, 21, 21, 21, 21,
+        21, 21, 21, 21, 21, 21, 21, 21, 23, 23,
+        23, 23, 23, 23, 23, 23, 23, 25, 25, 25,
+        25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+        25, 25, 25, 27, 27, 27, 27, 27, 27, 27,         /* 200 */
+        27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+        27, 27, 27, 27, 27, 27, 27, 29, 29, 29,
+        29, 29, 31, 31, 31, 31, 31, 31, 31, 31,
+        31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
+        33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+        33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+        33, 33, 33, 33, 35, 35, 35, 35, 35, 35,
+        35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
+        35, 37, 39, 39, 39, 39, 39, 39, 39, 39,
+        39, 41, 41, 41, 41, 41, 41, 41, 41, 41,         /* 300 */
+        41, 41, 41, 41, 43, 43, 43, 43, 43, 45,
+        45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
+        45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
+        45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
+        45, 45, 45, 45, 45, 47, 47, 47, 47, 49,
+        49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
+        49, 49, 49, 49, 49, 49, 51, 51, 51, 51,
+        51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
+        51, 53, 53, 53, 53, 53, 53, 53, 53, 53,
+        53, 55, 55, 55, 55, 55, 55, 55, 55, 55,         /* 400 */
+        55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+        57, 57, 57, 57, 57, 57, 57, 57, 57, 57,
+        57, 57, 57, 57, 57, 57, 57, 57, 59, 59,
+        59, 59, 59, 59, 61, 61, 61, 61, 61, 61,
+        61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
+        61, 63, 63, 63, 63, 63, 63, 63, 63, 63,
+        63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
+        63, 63, 63, 63, 65, 65, 65, 65, 65, 65,
+        65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+        65, 65, 67, 67, 67, 67, 67, 67, 67, 67,         /* 500 */
+        69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+        69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+        69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+        69, 69, 71, 71, 71, 73, 73, 73, 73, 73,
+        73, 75, 75, 75, 75, 75, 75, 75, 75, 75,
+        75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
+        75, 75, 75, 75, 75, 75, 75, 77, 77, 77,
+        77, 77, 77, 77, 77, 77, 77, 77, 77, 79,
+        79, 79, 79, 79, 79, 79, 79, 79, 79, 79,
+        81, 81, 81, 81, 81, 81, 81, 81, 81, 81,         /* 600 */
+        81, 81, 81, 83, 83, 83, 83, 83, 83, 83,
+        83, 83, 83, 83, 83, 83, 83, 83, 83, 83,
+        83, 83, 83, 83, 83, 85, 85, 85, 85, 85,
+        85, 85, 85, 85, 87, 87, 87, 87, 87, 87,
+        87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
+        87, 87, 87, 87, 87, 87, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 91, 91, 91, 91, 91,
+        91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
+        91, 91, 91, 91, 91, 91, 91, 93, 93, 93,
+        93, 93, 93, 93, 93, 93, 93, 93, 93, 93,         /* 700 */
+        93, 93, 93, 93, 93, 95, 95, 95, 95, 95,
+        95, 95, 95, 95, 95, 97, 97, 97, 97, 97,
+        99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+        99, 99, 99, 99, 99, 99, 101, 101, 101, 101,
+        103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
+        103, 103, 103, 105, 105, 105, 105, 105, 105, 105,
+        105, 105, 105, 105, 105, 105, 105, 105, 105, 105,
+        105, 105, 107, 107, 107, 107, 107, 107, 107, 107,
+        107, 107, 107, 107, 107, 107, 109, 109, 109, 109,
+        109, 113, 113, 113, 113, 113, 113, 113, 113, 113,       /* 800 */
+        113, 115, 115, 115, 115, 115, 115, 115, 115, 115,
+        115, 115, 115, 115, 115, 115, 115, 119, 119, 119,
+        119, 119, 119, 119, 119, 121, 121, 121, 121, 121,
+        121, 121, 121, 121, 121, 121, 121, 125, 125, 125,
+        125, 125, 125, 127, 127, 131, 131, 131, 131, 131,
+        131, 131, 131, 131, 131, 133, 133, 133, 133, 133,
+        133, 133, 133, 133, 133, 133, 133, 133, 137, 137,
+        137, 137, 139, 139, 139, 139, 139, 139, 139, 139,
+        139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
+        139, 139, 139, 139, 139, 139, 139, 139, 139, 143,       /* 900 */
+        143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
+        143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
+        143, 143, 143, 145, 145, 145, 145, 145, 145, 145,
+        145, 145, 145, 145, 149, 149, 149, 149, 149, 149,
+        149, 151, 151, 151, 155, 155, 155, 155, 155, 155,
+        155, 155, 155, 155, 155, 155, 157, 157, 157, 157,
+        157, 157, 157, 157, 157, 161, 161, 161, 161, 161,
+        161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+        163, 163, 163, 163, 167, 167, 167, 167, 167, 167,
+        167, 167, 167, 167, 167, 167, 169, 169, 169, 169,       /* 1000 */
+        169, 169, 169, 169, 169, 169, 169, 169, 173, 173,
+        173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+        173, 173, 173, 173, 175, 175, 175, 175, 175, 175,
+        175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
+        179, 179, 179, 181, 181, 181, 181, 181, 181, 181,
+        181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
+        181, 181, 181, 181, 181, 181, 181, 181, 185, 185,
+        185, 185, 185, 185, 185, 185, 185, 185, 187, 187,
+        187, 187, 187, 191, 193, 193, 193, 193, 193, 193,
+        193, 197, 197, 197, 197, 197, 197, 197, 197, 197,       /* 1100 */
+        197, 197, 197, 197, 197, 197, 197, 197, 197, 199,
+        199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
+        199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
+        199, 199, 199, 199, 199
 };
 
 
 /* n (exponent) prime parameters */
 static mat n_p[prime_cnt] = {
-	2, 3, 5, 7, 13, 17, 19, 31, 61, 89,		/* element 0 */
-	107, 127, 521, 607, 1, 2, 3, 4, 6, 7,
-	11, 18, 34, 38, 43, 55, 64, 76, 94, 103,
-	143, 206, 216, 306, 324, 391, 458, 470, 827, 2,
-	4, 8, 10, 12, 14, 18, 32, 48, 54, 72,
-	148, 184, 248, 270, 274, 420, 1, 5, 9, 17,
-	21, 29, 45, 177, 1, 3, 7, 13, 15, 21,
-	43, 63, 99, 109, 159, 211, 309, 343, 415, 469,
-	781, 871, 939, 2, 26, 50, 54, 126, 134, 246,
-	354, 362, 950, 3, 7, 23, 287, 291, 795, 1,
-	2, 4, 5, 10, 14, 17, 31, 41, 73, 80,		/* 100 */
-	82, 116, 125, 145, 157, 172, 202, 224, 266, 289,
-	293, 463, 2, 4, 6, 16, 20, 36, 54, 60,
-	96, 124, 150, 252, 356, 460, 612, 654, 664, 698,
-	702, 972, 1, 3, 5, 21, 41, 49, 89, 133,
-	141, 165, 189, 293, 305, 395, 651, 665, 771, 801,
-	923, 953, 1, 2, 3, 7, 10, 13, 18, 27,
-	37, 51, 74, 157, 271, 458, 530, 891, 4, 6,
-	12, 46, 72, 244, 264, 544, 888, 3, 9, 11,
-	17, 23, 35, 39, 75, 105, 107, 155, 215, 335,
-	635, 651, 687, 1, 2, 4, 5, 8, 10, 14,		/* 200 */
-	28, 37, 38, 70, 121, 122, 160, 170, 253, 329,
-	362, 454, 485, 500, 574, 892, 962, 4, 16, 76,
-	148, 184, 1, 5, 7, 11, 13, 23, 33, 35,
-	37, 47, 115, 205, 235, 271, 409, 739, 837, 887,
-	2, 3, 6, 8, 10, 22, 35, 42, 43, 46,
-	56, 91, 102, 106, 142, 190, 208, 266, 330, 360,
-	382, 462, 503, 815, 2, 6, 10, 20, 44, 114,
-	146, 156, 174, 260, 306, 380, 654, 686, 702, 814,
-	906, 1, 3, 24, 105, 153, 188, 605, 795, 813,
-	839, 2, 10, 14, 18, 50, 114, 122, 294, 362,	/* 300 */
-	554, 582, 638, 758, 7, 31, 67, 251, 767, 1,
-	2, 3, 4, 5, 6, 8, 9, 14, 15, 16,
-	22, 28, 29, 36, 37, 54, 59, 85, 93, 117,
-	119, 161, 189, 193, 256, 308, 322, 327, 411, 466,
-	577, 591, 902, 928, 946, 4, 14, 70, 78, 1,
-	5, 7, 9, 13, 15, 29, 33, 39, 55, 81,
-	95, 205, 279, 581, 807, 813, 1, 9, 10, 19,
-	22, 57, 69, 97, 141, 169, 171, 195, 238, 735,
-	885, 2, 6, 8, 42, 50, 62, 362, 488, 642,
-	846, 1, 3, 5, 7, 15, 33, 41, 57, 69,		/* 400 */
-	75, 77, 131, 133, 153, 247, 305, 351, 409, 471,
-	1, 2, 4, 5, 8, 10, 20, 22, 25, 26,
-	32, 44, 62, 77, 158, 317, 500, 713, 12, 16,
-	72, 160, 256, 916, 3, 5, 9, 13, 17, 19,
-	25, 39, 63, 67, 75, 119, 147, 225, 419, 715,
-	895, 2, 3, 8, 11, 14, 16, 28, 32, 39,
-	66, 68, 91, 98, 116, 126, 164, 191, 298, 323,
-	443, 714, 758, 759, 4, 6, 12, 22, 28, 52,
-	78, 94, 124, 162, 174, 192, 204, 304, 376, 808,
-	930, 972, 5, 9, 21, 45, 65, 77, 273, 677,	/* 500 */
-	1, 4, 5, 7, 9, 11, 13, 17, 19, 23,
-	29, 37, 49, 61, 79, 99, 121, 133, 141, 164,
-	173, 181, 185, 193, 233, 299, 313, 351, 377, 540,
-	569, 909, 2, 14, 410, 7, 11, 19, 71, 79,
-	131, 1, 3, 5, 6, 18, 19, 20, 22, 28,
-	29, 39, 43, 49, 75, 85, 92, 111, 126, 136,
-	159, 162, 237, 349, 381, 767, 969, 2, 4, 14,
-	26, 58, 60, 64, 100, 122, 212, 566, 638, 1,
-	3, 7, 15, 43, 57, 61, 75, 145, 217, 247,
-	3, 5, 11, 17, 21, 27, 81, 101, 107, 327,	/* 600 */
-	383, 387, 941, 2, 4, 8, 10, 14, 18, 22,
-	24, 26, 28, 36, 42, 58, 64, 78, 158, 198,
-	206, 424, 550, 676, 904, 5, 11, 71, 113, 115,
-	355, 473, 563, 883, 1, 2, 8, 9, 10, 12,
-	22, 29, 32, 50, 57, 69, 81, 122, 138, 200,
-	296, 514, 656, 682, 778, 881, 4, 8, 12, 24,
-	48, 52, 64, 84, 96, 1, 3, 9, 13, 15,
-	17, 19, 23, 47, 57, 67, 73, 77, 81, 83,
-	191, 301, 321, 435, 867, 869, 917, 3, 4, 7,
-	10, 15, 18, 19, 24, 27, 39, 60, 84, 111,	/* 700 */
-	171, 192, 222, 639, 954, 2, 6, 26, 32, 66,
-	128, 170, 288, 320, 470, 1, 9, 45, 177, 585,
-	1, 4, 5, 7, 8, 11, 19, 25, 28, 35,
-	65, 79, 212, 271, 361, 461, 10, 18, 54, 70,
-	3, 7, 11, 19, 63, 75, 95, 127, 155, 163,
-	171, 283, 563, 2, 3, 5, 6, 8, 9, 25,
-	32, 65, 113, 119, 155, 177, 299, 335, 426, 462,
-	617, 896, 10, 12, 18, 24, 28, 40, 90, 132,
-	214, 238, 322, 532, 858, 940, 9, 149, 177, 419,
-	617, 8, 14, 74, 80, 274, 334, 590, 608, 614,	/* 800 */
-	650, 1, 3, 11, 13, 19, 21, 31, 49, 59,
-	69, 73, 115, 129, 397, 623, 769, 12, 16, 52,
-	160, 192, 216, 376, 436, 1, 3, 21, 27, 37,
-	43, 91, 117, 141, 163, 373, 421, 2, 4, 44,
-	182, 496, 904, 25, 113, 2, 14, 34, 38, 42,
-	78, 90, 178, 778, 974, 3, 11, 15, 19, 31,
-	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 */
-	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,
-	245, 445, 447, 883, 4, 16, 48, 60, 240, 256,
-	304, 5, 221, 641, 2, 8, 14, 16, 44, 46,
-	82, 172, 196, 254, 556, 806, 1, 5, 33, 121,
-	125, 305, 445, 473, 513, 2, 6, 18, 22, 34,
-	54, 98, 122, 146, 222, 306, 422, 654, 682, 862,
-	3, 31, 63, 303, 4, 6, 8, 10, 16, 32,
-	38, 42, 52, 456, 576, 668, 1, 5, 11, 17,	/* 1000 */
-	67, 137, 157, 203, 209, 227, 263, 917, 2, 4,
-	6, 16, 32, 50, 76, 80, 96, 104, 162, 212,
-	230, 260, 480, 612, 1, 3, 9, 21, 23, 41,
-	47, 57, 69, 83, 193, 249, 291, 421, 433, 997,
-	8, 68, 108, 3, 5, 7, 9, 11, 17, 23,
-	31, 35, 43, 47, 83, 85, 99, 101, 195, 267,
-	281, 363, 391, 519, 623, 653, 673, 701, 2, 6,
-	10, 18, 26, 40, 46, 78, 230, 542, 1, 17,
-	21, 53, 253, 226, 3, 15, 27, 63, 87, 135,
-	543, 2, 16, 20, 22, 40, 82, 112, 178, 230,	/* 1100 */
-	302, 304, 328, 374, 442, 472, 500, 580, 694, 1,
-	5, 7, 15, 19, 23, 25, 27, 43, 65, 99,
-	125, 141, 165, 201, 211, 331, 369, 389, 445, 461,
-	463, 467, 513, 583, 835
+        2, 3, 5, 7, 13, 17, 19, 31, 61, 89,             /* element 0 */
+        107, 127, 521, 607, 1, 2, 3, 4, 6, 7,
+        11, 18, 34, 38, 43, 55, 64, 76, 94, 103,
+        143, 206, 216, 306, 324, 391, 458, 470, 827, 2,
+        4, 8, 10, 12, 14, 18, 32, 48, 54, 72,
+        148, 184, 248, 270, 274, 420, 1, 5, 9, 17,
+        21, 29, 45, 177, 1, 3, 7, 13, 15, 21,
+        43, 63, 99, 109, 159, 211, 309, 343, 415, 469,
+        781, 871, 939, 2, 26, 50, 54, 126, 134, 246,
+        354, 362, 950, 3, 7, 23, 287, 291, 795, 1,
+        2, 4, 5, 10, 14, 17, 31, 41, 73, 80,            /* 100 */
+        82, 116, 125, 145, 157, 172, 202, 224, 266, 289,
+        293, 463, 2, 4, 6, 16, 20, 36, 54, 60,
+        96, 124, 150, 252, 356, 460, 612, 654, 664, 698,
+        702, 972, 1, 3, 5, 21, 41, 49, 89, 133,
+        141, 165, 189, 293, 305, 395, 651, 665, 771, 801,
+        923, 953, 1, 2, 3, 7, 10, 13, 18, 27,
+        37, 51, 74, 157, 271, 458, 530, 891, 4, 6,
+        12, 46, 72, 244, 264, 544, 888, 3, 9, 11,
+        17, 23, 35, 39, 75, 105, 107, 155, 215, 335,
+        635, 651, 687, 1, 2, 4, 5, 8, 10, 14,           /* 200 */
+        28, 37, 38, 70, 121, 122, 160, 170, 253, 329,
+        362, 454, 485, 500, 574, 892, 962, 4, 16, 76,
+        148, 184, 1, 5, 7, 11, 13, 23, 33, 35,
+        37, 47, 115, 205, 235, 271, 409, 739, 837, 887,
+        2, 3, 6, 8, 10, 22, 35, 42, 43, 46,
+        56, 91, 102, 106, 142, 190, 208, 266, 330, 360,
+        382, 462, 503, 815, 2, 6, 10, 20, 44, 114,
+        146, 156, 174, 260, 306, 380, 654, 686, 702, 814,
+        906, 1, 3, 24, 105, 153, 188, 605, 795, 813,
+        839, 2, 10, 14, 18, 50, 114, 122, 294, 362,     /* 300 */
+        554, 582, 638, 758, 7, 31, 67, 251, 767, 1,
+        2, 3, 4, 5, 6, 8, 9, 14, 15, 16,
+        22, 28, 29, 36, 37, 54, 59, 85, 93, 117,
+        119, 161, 189, 193, 256, 308, 322, 327, 411, 466,
+        577, 591, 902, 928, 946, 4, 14, 70, 78, 1,
+        5, 7, 9, 13, 15, 29, 33, 39, 55, 81,
+        95, 205, 279, 581, 807, 813, 1, 9, 10, 19,
+        22, 57, 69, 97, 141, 169, 171, 195, 238, 735,
+        885, 2, 6, 8, 42, 50, 62, 362, 488, 642,
+        846, 1, 3, 5, 7, 15, 33, 41, 57, 69,            /* 400 */
+        75, 77, 131, 133, 153, 247, 305, 351, 409, 471,
+        1, 2, 4, 5, 8, 10, 20, 22, 25, 26,
+        32, 44, 62, 77, 158, 317, 500, 713, 12, 16,
+        72, 160, 256, 916, 3, 5, 9, 13, 17, 19,
+        25, 39, 63, 67, 75, 119, 147, 225, 419, 715,
+        895, 2, 3, 8, 11, 14, 16, 28, 32, 39,
+        66, 68, 91, 98, 116, 126, 164, 191, 298, 323,
+        443, 714, 758, 759, 4, 6, 12, 22, 28, 52,
+        78, 94, 124, 162, 174, 192, 204, 304, 376, 808,
+        930, 972, 5, 9, 21, 45, 65, 77, 273, 677,       /* 500 */
+        1, 4, 5, 7, 9, 11, 13, 17, 19, 23,
+        29, 37, 49, 61, 79, 99, 121, 133, 141, 164,
+        173, 181, 185, 193, 233, 299, 313, 351, 377, 540,
+        569, 909, 2, 14, 410, 7, 11, 19, 71, 79,
+        131, 1, 3, 5, 6, 18, 19, 20, 22, 28,
+        29, 39, 43, 49, 75, 85, 92, 111, 126, 136,
+        159, 162, 237, 349, 381, 767, 969, 2, 4, 14,
+        26, 58, 60, 64, 100, 122, 212, 566, 638, 1,
+        3, 7, 15, 43, 57, 61, 75, 145, 217, 247,
+        3, 5, 11, 17, 21, 27, 81, 101, 107, 327,        /* 600 */
+        383, 387, 941, 2, 4, 8, 10, 14, 18, 22,
+        24, 26, 28, 36, 42, 58, 64, 78, 158, 198,
+        206, 424, 550, 676, 904, 5, 11, 71, 113, 115,
+        355, 473, 563, 883, 1, 2, 8, 9, 10, 12,
+        22, 29, 32, 50, 57, 69, 81, 122, 138, 200,
+        296, 514, 656, 682, 778, 881, 4, 8, 12, 24,
+        48, 52, 64, 84, 96, 1, 3, 9, 13, 15,
+        17, 19, 23, 47, 57, 67, 73, 77, 81, 83,
+        191, 301, 321, 435, 867, 869, 917, 3, 4, 7,
+        10, 15, 18, 19, 24, 27, 39, 60, 84, 111,        /* 700 */
+        171, 192, 222, 639, 954, 2, 6, 26, 32, 66,
+        128, 170, 288, 320, 470, 1, 9, 45, 177, 585,
+        1, 4, 5, 7, 8, 11, 19, 25, 28, 35,
+        65, 79, 212, 271, 361, 461, 10, 18, 54, 70,
+        3, 7, 11, 19, 63, 75, 95, 127, 155, 163,
+        171, 283, 563, 2, 3, 5, 6, 8, 9, 25,
+        32, 65, 113, 119, 155, 177, 299, 335, 426, 462,
+        617, 896, 10, 12, 18, 24, 28, 40, 90, 132,
+        214, 238, 322, 532, 858, 940, 9, 149, 177, 419,
+        617, 8, 14, 74, 80, 274, 334, 590, 608, 614,    /* 800 */
+        650, 1, 3, 11, 13, 19, 21, 31, 49, 59,
+        69, 73, 115, 129, 397, 623, 769, 12, 16, 52,
+        160, 192, 216, 376, 436, 1, 3, 21, 27, 37,
+        43, 91, 117, 141, 163, 373, 421, 2, 4, 44,
+        182, 496, 904, 25, 113, 2, 14, 34, 38, 42,
+        78, 90, 178, 778, 974, 3, 11, 15, 19, 31,
+        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 */
+        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,
+        245, 445, 447, 883, 4, 16, 48, 60, 240, 256,
+        304, 5, 221, 641, 2, 8, 14, 16, 44, 46,
+        82, 172, 196, 254, 556, 806, 1, 5, 33, 121,
+        125, 305, 445, 473, 513, 2, 6, 18, 22, 34,
+        54, 98, 122, 146, 222, 306, 422, 654, 682, 862,
+        3, 31, 63, 303, 4, 6, 8, 10, 16, 32,
+        38, 42, 52, 456, 576, 668, 1, 5, 11, 17,        /* 1000 */
+        67, 137, 157, 203, 209, 227, 263, 917, 2, 4,
+        6, 16, 32, 50, 76, 80, 96, 104, 162, 212,
+        230, 260, 480, 612, 1, 3, 9, 21, 23, 41,
+        47, 57, 69, 83, 193, 249, 291, 421, 433, 997,
+        8, 68, 108, 3, 5, 7, 9, 11, 17, 23,
+        31, 35, 43, 47, 83, 85, 99, 101, 195, 267,
+        281, 363, 391, 519, 623, 653, 673, 701, 2, 6,
+        10, 18, 26, 40, 46, 78, 230, 542, 1, 17,
+        21, 53, 253, 226, 3, 15, 27, 63, 87, 135,
+        543, 2, 16, 20, 22, 40, 82, 112, 178, 230,      /* 1100 */
+        302, 304, 328, 374, 442, 472, 500, 580, 694, 1,
+        5, 7, 15, 19, 23, 25, 27, 43, 65, 99,
+        125, 141, 165, 201, 211, 331, 369, 389, 445, 461,
+        463, 467, 513, 583, 835
 };
 
 
@@ -303,82 +299,82 @@ read -once "lucas.cal";
  * when n_p is below a given limit.
  *
  * input:
- *	high_n	skip tests on n_p[i] > high_n
- *	[quiet] if given and != 0, then do not print individual test results
+ *      high_n  skip tests on n_p[i] > high_n
+ *      [quiet] if given and != 0, then do not print individual test results
  *
  * returns:
- *	1	all is ok
- *	0	something went wrong
+ *      1       all is OK
+ *      0       something went wrong
  */
 define
 lucas_chk(high_n, quiet)
 {
-	local i;	/* index */
-	local result;	/* 0 => non-prime, 1 => prime, -1 => bad test */
-	local error;	/* number of errors and bad tests found */
+        local i;        /* index */
+        local result;   /* 0 => non-prime, 1 => prime, -1 => bad test */
+        local error;    /* number of errors and bad tests found */
 
-	/*
-	 * firewall
-	 */
-	if (!isint(high_n)) {
-		ldebug("test_lucas", "high_n is non-int");
-		quit "FATAL: bad args: high_n must be an integer";
-	}
-	if (param(0) == 1) {
-		quiet = 0;
-	}
+        /*
+         * firewall
+         */
+        if (!isint(high_n)) {
+                ldebug("test_lucas", "high_n is non-int");
+                quit "FATAL: bad args: high_n must be an integer";
+        }
+        if (param(0) == 1) {
+                quiet = 0;
+        }
 
-	/*
-	 * scan thru the above prime table
-	 */
-	error = 0;
-	for (i=0; i < prime_cnt; ++i) {
+        /*
+         * scan thru the above prime table
+         */
+        error = 0;
+        for (i=0; i < prime_cnt; ++i) {
 
-		/* skip primes where h>=2^n */
-		if (highbit(h_p[i]) >= n_p[i]) {
-			if (config("resource_debug") & 3) {
-				print "h>=2^n skip:", h_p[i]:"*2^":n_p[i]:"-1";
-			}
-			continue;
-		}
+                /* skip primes where h>=2^n */
+                if (highbit(h_p[i]) >= n_p[i]) {
+                        if (config("resource_debug") & 8) {
+                                print "h>=2^n skip:", h_p[i]:"*2^":n_p[i]:"-1";
+                        }
+                        continue;
+                }
 
-		/* test the prime if it is small enough */
-		if (n_p[i] <= high_n) {
+                /* test the prime if it is small enough */
+                if (n_p[i] <= high_n) {
 
-			/* test the table value */
-			result = lucas(h_p[i], n_p[i]);
+                        /* test the table value */
+                        result = lucas(h_p[i], n_p[i]);
 
-			/* report the test */
-			if (result == 0) {
-				print "ERROR, bad primality test of",\
-				    h_p[i]:"*2^":n_p[i]:"-1";
-				++error;
-			} else if (result == 1) {
-				if (quiet == 0) {
-					print h_p[i]:"*2^":n_p[i]:"-1 is prime";
-				}
-			} else if (result == -1) {
-				print "ERROR, failed to compute v(1) for",\
-				    h_p[i]:"*2^":n_p[i]:"-1";
-				++error;
-			} else {
-				print "ERROR, bogus return value:", result;
-				++error;
-			}
-		}
-	}
+                        /* report the test */
+                        if (result == 0) {
+                                print "ERROR, bad primality test of",\
+                                    h_p[i]:"*2^":n_p[i]:"-1";
+                                ++error;
+                        } else if (result == 1) {
+                                if (quiet == 0) {
+                                        print h_p[i]:"*2^":n_p[i]:"-1 is prime";
+                                }
+                        } else if (result == -1) {
+                                print "ERROR, failed to compute v(1) for",\
+                                    h_p[i]:"*2^":n_p[i]:"-1";
+                                ++error;
+                        } else {
+                                print "ERROR, bogus return value:", result;
+                                ++error;
+                        }
+                }
+        }
 
-	/* return the full status */
-	if (error == 0) {
-		if (quiet == 0) {
-			print "lucas_chk(":high_n:") passed";
-		}
-		return 1;
-	} else if (error == 1) {
-		print "lucas_chk(":high_n:") failed", error, "test";
-		return 0;
-	} else {
-		print "lucas_chk(":high_n:") failed", error, "tests";
-		return 0;
-	}
+        /* return the full status */
+        if (error == 0) {
+                if (quiet == 0) {
+                        print "lucas_chk(":high_n:") passed";
+                }
+                return 1;
+        } else if (error == 1) {
+                print "lucas_chk(":high_n:") failed", error, "test";
+                return 0;
+        } else {
+                print "lucas_chk(":high_n:") failed", error, "tests";
+                return 0;
+        }
 }

cal/lucas_tbl.cal

@@ -1,165 +0,0 @@
-/*
- * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
- *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: lucas_tbl.cal,v 29.1 1999/12/14 09:15:31 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://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.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

@@ -11,22 +11,18 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: mersenne.cal,v 29.1 1999/12/14 09:15:31 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
  *
- * Under source code control:	1991/05/22 21:56:36
- * File existed as early as:	1991
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -36,26 +32,26 @@
 
 define mersenne(p)
 {
-	local u, i, p_mask;
+        local u, i, p_mask;
 
-	/* firewall */
-	if (! isint(p))
-		quit "p is not an integer";
+        /* firewall */
+        if (! isint(p))
+                quit "p is not an integer";
 
-	/* two is a special case */
-	if (p == 2)
-		return 1;
+        /* 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;
+        /* 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);
-	}
+        /* 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);
+        /* 2^p-1 is prime iff u(p) = 0 mod 2^p-1 */
+        return (u == 0);
 }

cal/mfactor.cal

@@ -1,7 +1,7 @@
 /*
  * mfactor - return the lowest factor of 2^n-1, for n > 0
  *
- * Copyright (C) 1999  Landon Curt Noll
+ * Copyright (C) 1999,2021  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
@@ -9,23 +9,19 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: mfactor.cal,v 29.1 1999/12/14 09:15:31 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
  *
- * Under source code control:	1996/07/06 06:09:40
- * File existed as early as:	1996
- *
- * chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -33,12 +29,12 @@
  *
  * 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))
+ *      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
+ *      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.
  *
@@ -49,61 +45,61 @@
  *
  * We need only test factors of the form:
  *
- *	(Q*g*n + hx) + 1
+ *      (Q*g*n + hx) + 1
  *
  * where:
  *
- *	g is an integer >= 0
- *	hx is computed from hset[] difference value described above
+ *      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
+ *      2*k*n + 1
  *
  * implies that:
  *
- *	k = (Q*g + hx/n)/2
+ *      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)
+ * 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[].
+ * 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);
+ *      (* 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):
+ * 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
+ *      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
+ *      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
+ * 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.
  *
@@ -112,8 +108,8 @@
  * 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.
+ *       multiplied by n plus other optimizations.  Thus, the CPU
+ *       times you may get will not likely match the above values.
  */
 
 
@@ -122,198 +118,198 @@
  *
  * Mersenne numbers are numbers of the form:
  *
- *	2^n-1	for integer n > 0
+ *      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
+ *      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)
+ *      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
+ *      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.
+ *       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;
+        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)";
-	}
+        /*
+         * 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];
+        /*
+         * 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 */
+        /*
+         * 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;
-	}
+                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;
+        /*
+         * 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, runtime());
-		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, runtime());
-			fflush(files(1));
-			loop = 0;
-		}
+        /*
+         * 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);
+                /*
+                 * skip if divisible 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;
+        /*
+         * 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]]])"
+        print "mfactor(n [, start_k=1 [, rept_loop=10000 [, p_elim=17]]])"
 }

cal/mod.cal

@@ -9,204 +9,200 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: mod.cal,v 29.1 1999/12/14 09:15:31 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
  *
- * Under source code control:	1990/02/15 01:50:34
- * File existed as early as:	before 1990
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 
-obj mod {a};			/* definition of the object */
+obj mod {a};                    /* definition of the object */
 
-global mod_value = 100;		/* modulus value (value of N) */
+global mod_value = 100;         /* modulus value (value of N) */
 
 
 define lmod(a)
 {
-	local obj mod	x;
+        local obj mod   x;
 
-	if (!isreal(a) || !isint(a))
-		quit "Bad argument for lmod function";
-	x.a = a % mod_value;
-	return x;
+        if (!isreal(a) || !isint(a))
+                quit "Bad argument for lmod function";
+        x.a = a % mod_value;
+        return x;
 }
 
 
 define mod_print(a)
 {
-	if (digits(mod_value) <= 20)
-		print a.a, "(mod", mod_value : ")" :;
-	else
-		print a.a, "(mod N)" :;
+        if (digits(mod_value) <= 20)
+                print a.a, "(mod", mod_value : ")" :;
+        else
+                print a.a, "(mod N)" :;
 }
 
 
 define mod_one()
 {
-	return lmod(1);
+        return lmod(1);
 }
 
 
 define mod_cmp(a, b)
 {
-	if (isnum(a))
-		return (a % mod_value) != b.a;
-	if (isnum(b))
-		return (b % mod_value) != a.a;
-	return a.a != b.a;
+        if (isnum(a))
+                return (a % mod_value) != b.a;
+        if (isnum(b))
+                return (b % mod_value) != a.a;
+        return a.a != b.a;
 }
 
 
 define mod_rel(a, b)
 {
-	if (isnum(a))
-		a = lmod(a);
-	if (isnum(b))
-		b = lmod(b);
-	if (a.a < b.a)
-		return -1;
-	return a.a != b.a;
+        if (isnum(a))
+                a = lmod(a);
+        if (isnum(b))
+                b = lmod(b);
+        if (a.a < b.a)
+                return -1;
+        return a.a != b.a;
 }
 
 
 define mod_add(a, b)
 {
-	local obj mod	x;
+        local obj mod   x;
 
-	if (isnum(b)) {
-		if (!isint(b))
-			quit "Adding non-integer";
-		x.a = (a.a + b) % mod_value;
-		return x;
-	}
-	if (isnum(a)) {
-		if (!isint(a))
-			quit "Adding non-integer";
-		x.a = (a + b.a) % mod_value;
-		return x;
-	}
-	x.a = (a.a + b.a) % mod_value;
-	return x;
+        if (isnum(b)) {
+                if (!isint(b))
+                        quit "Adding non-integer";
+                x.a = (a.a + b) % mod_value;
+                return x;
+        }
+        if (isnum(a)) {
+                if (!isint(a))
+                        quit "Adding non-integer";
+                x.a = (a + b.a) % mod_value;
+                return x;
+        }
+        x.a = (a.a + b.a) % mod_value;
+        return x;
 }
 
 
 define mod_sub(a, b)
 {
-	return a + (-b);
+        return a + (-b);
 }
 
 
 define mod_neg(a)
 {
-	local obj mod	x;
+        local obj mod   x;
 
-	x.a = mod_value - a.a;
-	return x;
+        x.a = mod_value - a.a;
+        return x;
 }
 
 
 define mod_mul(a, b)
 {
-	local obj mod	x;
+        local obj mod   x;
 
-	if (isnum(b)) {
-		if (!isint(b))
-			quit "Multiplying by non-integer";
-		x.a = (a.a * b) % mod_value;
-		return x;
-	}
-	if (isnum(a)) {
-		if (!isint(a))
-			quit "Multiplying by non-integer";
-		x.a = (a * b.a) % mod_value;
-		return x;
-	}
-	x.a = (a.a * b.a) % mod_value;
-	return x;
+        if (isnum(b)) {
+                if (!isint(b))
+                        quit "Multiplying by non-integer";
+                x.a = (a.a * b) % mod_value;
+                return x;
+        }
+        if (isnum(a)) {
+                if (!isint(a))
+                        quit "Multiplying by non-integer";
+                x.a = (a * b.a) % mod_value;
+                return x;
+        }
+        x.a = (a.a * b.a) % mod_value;
+        return x;
 }
 
 
 define mod_square(a)
 {
-	local obj mod	x;
+        local obj mod   x;
 
-	x.a = a.a^2 % mod_value;
-	return x;
+        x.a = a.a^2 % mod_value;
+        return x;
 }
 
 
 define mod_inc(a)
 {
-	local x;
+        local x;
 
-	x = a;
-	if (++x.a == mod_value)
-		x.a = 0;
-	return x;
+        x = a;
+        if (++x.a == mod_value)
+                x.a = 0;
+        return x;
 }
 
 
 define mod_dec(a)
 {
-	local x;
+        local x;
 
-	x = a;
-	if (--x.a < 0)
-		x.a = mod_value - 1;
-	return x;
+        x = a;
+        if (--x.a < 0)
+                x.a = mod_value - 1;
+        return x;
 }
 
 
 define mod_inv(a)
 {
-	local obj mod	x;
+        local obj mod   x;
 
-	x.a = minv(a.a, mod_value);
-	return x;
+        x.a = minv(a.a, mod_value);
+        return x;
 }
 
 
 define mod_div(a, b)
 {
-	local c;
-	local obj mod x;
-	local obj mod y;
-	if (isnum(a))
-		a = lmod(a);
-	if (isnum(b))
-		b = lmod(b);
-	c = gcd(a.a, b.a);
-	x.a = a.a / c;
-	y.a = b.a / c;
-	return x * inverse(y);
+        local c;
+        local obj mod x;
+        local obj mod y;
+        if (isnum(a))
+                a = lmod(a);
+        if (isnum(b))
+                b = lmod(b);
+        c = gcd(a.a, b.a);
+        x.a = a.a / c;
+        y.a = b.a / c;
+        return x * inverse(y);
 }
 
 
 define mod_pow(a, b)
 {
-	local x, y, z;
+        local x, y, z;
 
-	obj mod x;
-	y = a;
-	z = b;
-	if (b < 0) {
-		y = inverse(a);
-		z = -b;
-	}
-	x.a = pmod(y.a, z, mod_value);
-	return x;
+        obj mod x;
+        y = a;
+        z = b;
+        if (b < 0) {
+                y = inverse(a);
+                z = -b;
+        }
+        x.a = pmod(y.a, z, mod_value);
+        return x;
 }
 
 

cal/natnumset.cal

@@ -1,7 +1,7 @@
 /*
  * natnumset - functions for sets of natural numbers not exceeding a fixed bound
  *
- * Copyright (C) 1999  Ernest Bowen
+ * Copyright (C) 1999,2021  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
@@ -9,22 +9,18 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: natnumset.cal,v 29.1 1999/12/14 09:15:31 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
  *
- * Under source code control:	1997/09/07 23:53:51
- * File existed as early as:	1997
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -44,14 +40,14 @@
  *
  * In an assignment of a set-valued lvalue to an lvalue, as in
  *
- *		A = set(1,2,3);
- *		B = A;
+ *              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()
+ *              B = A | set()
  *
  * The functions empty() and full() return the empty set and the set of all
  * integers in [0,B] respectively.
@@ -61,58 +57,58 @@
  * 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.
+ *      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.
+ *       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.
+ *      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).
+ *      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 | 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
+ *      ~A      = complement of A, integers not in A
+ *      #A      = number of integers 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
+ *      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 = 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)
+ *      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
+ * Expressions 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
+ *      A + 3 * A ^ 2 + (A - B) ^ 3
  *
  * returns the set of integers expressible as
  *
- *	a_1 + 3 * a_2 ^ 2 + (a_3 - b) ^3
+ *      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.
  *
@@ -123,28 +119,28 @@
  * 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.
+ *      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 + ...
+ *      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.
+ *      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 */
+static N;               /* Number of integers in [0,B], = B + 1 */
+static M;               /* Maximum string size required, = N // 8 */
 
 obj set {s};
 
@@ -152,17 +148,17 @@ define isset(a) = istype(a, obj set);
 
 define setbound(n)
 {
-	local v;
+        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;
+        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);
@@ -171,90 +167,90 @@ define empty() = obj set = {""};
 
 define full()
 {
-	local v;
+        local v;
 
-	obj set v;
-	v.s = M * char(-1);
-	if (!ismult(N, 8)) v.s[M-1] = 255 >> (8 - N & 7);
-	return 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);
+        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);
+        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);
+        if (n < N && n >= 0)
+                setbit(a.s, n, 0);
 }
 
 define set()
 {
-	local i, v, s;
+        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);
+        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;
+        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)};
+        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;
+        local i, s, m;
 
-	if (isnull(b)) {
-		if (isnull(a)) {
-			a = 0;
-			b = N - 1;
-		}
-		else b = 0;
-	}
+        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);
+        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);
@@ -265,56 +261,56 @@ define set_not(a) = !a.s;
 
 define set_cmp(a,b)
 {
-	if (isset(a) && isset(b))
-		return a.s != b.s;
-	return 1;
+        if (isset(a) && isset(b))
+                return a.s != b.s;
+        return 1;
 }
 
 define set_rel(a,b)
 {
-	local c;
+        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);
+        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");
+        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);
+        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);
 }
 
 
@@ -322,295 +318,295 @@ 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);
+        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);
+        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;
+        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);
+        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;
+        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");
+        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;
+        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");
+        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;
+        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);
+        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;
+        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);
+        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;
+        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;
+        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 = str("\0\1\3\7\17\37\77\177\377");
+        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);
+        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;
+        local i, max, s;
 
-	if (!isset(a))
-		quit "Non-set argument for isinterval";
+        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;
+        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;
+        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");
+        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;
+        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);
+        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;
+        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);
+        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;
+        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);
+        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;
+        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 ")",;
+        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 */
+local N, M;     /* End scope of static variables N, M */

cal/palindrome.cal

@@ -0,0 +1,641 @@
+/*
+ * palindrome - palindrome utilities
+ *
+ * Copyright (C) 2021  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.
+ *
+ * Under source code control:   2021/11/06 14:35:37
+ * File existed as early as:    2021
+ *
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
+ */
+
+
+/*
+ * digitof - return the a digit of a value
+ *
+ * NOTE: We assume base 10 digits and place 1 is the units digit.
+ *
+ * given:
+ *      val     value to find a digit of
+ *      place   digit place
+ *
+ * returns:
+ *      value (>= 0 and < 10) that is the place-th digit of val
+ *      or 0 if place is not a digit of val
+ */
+define digitof(val, place)
+{
+    local d;    /* length of val in digits */
+
+    /* determine length */
+    d = digits(val);
+
+    /* firewall - return 0 if digit place doesn't exist */
+    if (place < 1 || place > d) {
+        return 0;
+    }
+
+    /* return the place-th digit of val as a single digit */
+    return  (val // (10^(place-1))) % 10;
+}
+
+
+/*
+ * copalplace - determine the other place in a palindrome
+ *
+ * NOTE: We assume base 10 digits and place 1 is the units digit.
+ *
+ * given:
+ *      d       digits of a value
+ *      place   digit place
+ *
+ * returns:
+ *      given palindrome val, the other digit paired with place
+ *      or 0 if place is not a digit of val
+ */
+define copalplace(d, place)
+{
+    /* firewall - return 0 if digit place doesn't exist */
+    if (d < 1 || place < 1 || place > d) {
+        return 0;
+    }
+
+    /* return digit coplace */
+    return d+1 - place;
+}
+
+
+/*
+ * upperhalf - return the upper half of a palindrome
+ *
+ * NOTE: We assume base 10 digits and place 1 is the units digit.
+ *
+ * NOTE: When the value has an odd number of digits, the upper half
+ *       includes the middle digit.
+ *
+ * given:
+ *      val     a value
+ *
+ * returns:
+ *      the upper half digits of a value
+ */
+define upperhalf(val)
+{
+    local d;            /* length of val in digits */
+    local halfd;        /* length of upper hand of val */
+
+    /* determine length */
+    d = digits(val);
+    halfd = d // 2;
+
+    /* return upper half */
+    return (val // 10^halfd);
+}
+
+
+/*
+ * mkpal - make a value into a palindrome
+ *
+ * NOTE: We assume base 10 digits and place 1 is the units digit.
+ *
+ * given:
+ *      val     a value
+ *
+ * returns:
+ *      val as a palindrome with lower half being reverse digits of val
+ */
+define mkpal(val)
+{
+    local d;    /* length of val in digits */
+    local i;    /* counter */
+    local ret;  /* palindrome being formed */
+
+    /* determine length */
+    d = digits(val);
+
+    /* insert digits in reverse order at the bottom */
+    ret = val;
+    for (i=0; i < d; ++i) {
+        ret = ret*10 + digit(val, i);
+    }
+    return ret;
+}
+
+
+/*
+ * mkpalmiddigit - make a value into a palindrome with a middle digit
+ *
+ * NOTE: We assume base 10 digits and place 1 is the units digit.
+ *
+ * given:
+ *      val     a value
+ *      digit   the digit to put into the middle of the palindrome
+ *
+ * returns:
+ *      val as a palindrome with lower half being reverse digits of val
+ *              and digit as a middle digit
+ */
+define mkpalmiddigit(val, digit)
+{
+    local d;    /* length of val in digits */
+    local i;    /* counter */
+    local ret;  /* palindrome being formed */
+
+    /* determine length */
+    d = digits(val);
+
+    /* insert digits in reverse order at the bottom */
+    ret = val*10 + digit;
+    for (i=0; i < d; ++i) {
+        ret = ret*10 + digit(val, i);
+    }
+    return ret;
+}
+
+
+/*
+ * ispal - determine if a value is a palindrome
+ *
+ * NOTE: We assume base 10 digits and place 1 is the units digit.
+ *
+ * given:
+ *      val     a value
+ *
+ * returns:
+ *      1 ==> val is a palindrome
+ *      0 ==> val is NOT a palindrome
+ */
+define ispal(val)
+{
+    local half;         /* upper half of digits of val */
+    local digit;        /* middle digit */
+
+    /* case: val has an even number of digits */
+    if (iseven(digits(val))) {
+
+        /* test palindrome-ness */
+        return (val == mkpal(upperhalf(val)));
+
+    /* case: val can an odd number of digits */
+    } else {
+
+        /* test palindrome-ness */
+        half = upperhalf(val);
+        digit = half % 10;
+        half //= 10;
+        return (val == mkpalmiddigit(half, digit));
+    }
+}
+
+
+/*
+ * palnextpal - return next palindrome from a known palindrome
+ *
+ * NOTE: We assume base 10 digits and place 1 is the units digit.
+ *
+ * given:
+ *      pal     a palindrome
+ *
+ * returns:
+ *      next palindrome > pal
+ */
+define palnextpal(pal)
+{
+    local paldigits;    /* digits in pal */
+    local half;         /* upper half of newval */
+    local newhalf;      /* half+1 */
+    local newpal;       /* new palindrome */
+
+    /* case: negative palindrome */
+    if (pal < 0) {
+        return -(palprevpal(-pal));
+    }
+
+    /*
+     * start with upper half
+     */
+    half = upperhalf(pal);
+
+    /*
+     * prep to find a larger palindrome
+     */
+    newhalf = half+1;
+
+    /*
+     * form palindrome from new upper half
+     *
+     * We need to watch for the corner case where changing the
+     * half changes the number of digits as this will impact
+     * or even/odd number of digits processing.
+     */
+    paldigits = digits(pal);
+    if (digits(newhalf) == digits(half)) {
+        /* no change in half digits: process as normal */
+        if (iseven(paldigits)) {
+            newpal = mkpal(newhalf);
+        } else {
+            newpal = mkpalmiddigit(newhalf // 10, newhalf % 10);
+        }
+    } else {
+        /* change in half digits: process as opposite */
+        if (iseven(paldigits)) {
+            newpal = mkpalmiddigit(newhalf // 10, newhalf % 10);
+        } else {
+            newpal = mkpal(newhalf);
+        }
+    }
+
+    /*
+     * return the new palindrome
+     */
+    return newpal;
+}
+
+
+/*
+ * nextpal - return next palindrome from a value
+ *
+ * NOTE: We assume base 10 digits and place 1 is the units digit.
+ *
+ * given:
+ *      val     a value
+ *
+ * returns:
+ *      next palindrome > val
+ */
+define nextpal(val)
+{
+    local newval;       /* val+1 */
+    local newvaldigits; /* digits in newval */
+    local half;         /* upper half of newval */
+    local pal;          /* palindrome test value */
+    local newpal;       /* new palindrome */
+
+    /* case: negative value */
+    if (val < 0) {
+        return -(prevpal(-val));
+    }
+
+    /*
+     * start looking from a larger value
+     */
+    newval = val+1;
+    newvaldigits = digits(newval);
+
+    /* case: single digit palindrome */
+    if (newvaldigits < 2) {
+        return newval;
+    }
+
+    /*
+     * start with next upper half
+     */
+    half = upperhalf(newval);
+
+    /*
+     * form palindrome from upper half
+     *
+     * We need to deal with even vs. odd digit counts
+     * when forming a palindrome from a half as the
+     * half may not or may include the middle digit.
+     */
+    if (iseven(newvaldigits)) {
+        pal = mkpal(half);
+    } else {
+        pal = mkpalmiddigit(half // 10, half % 10);
+    }
+
+    /*
+     * case: we found a larger palindrome, we are done
+     */
+    if (pal > val) {
+        return pal;
+    }
+
+    /*
+     * we need to find an even larger palindrome
+     */
+    newpal = palnextpal(pal);
+
+    /*
+     * return the new palindrome
+     */
+    return newpal;
+}
+
+
+/*
+ * palprevpal - return previous palindrome from a palindrome
+ *
+ * NOTE: We assume base 10 digits and place 1 is the units digit.
+ *
+ * given:
+ *      pal     a palindrome
+ *
+ * returns:
+ *      previous palindrome < pal
+ */
+define palprevpal(pal)
+{
+    local paldigits;    /* digits in pal */
+    local half;         /* upper half of newval */
+    local newhalf;      /* half+1 */
+    local newpal;       /* new palindrome */
+
+    /* case: negative value */
+    if (pal < 0) {
+        return -(palnextpal(-pal));
+    }
+
+    /* case: single digit palindrome */
+    if (pal < 10) {
+        newpal = pal-1;
+        return newpal;
+    }
+
+    /* case: 10 or 11 */
+    if (pal < 12) {
+        newpal = 9;
+        return newpal;
+    }
+
+    /*
+     * start with upper half
+     */
+    half = upperhalf(pal);
+
+    /*
+     * prep to find a smaller palindrome
+     */
+    newhalf = half-1;
+
+    /*
+     * form palindrome from new upper half
+     *
+     * We need to watch for the corner case where changing the
+     * half changes the number of digits as this will impact
+     * or even/odd number of digits processing.
+     */
+    paldigits = digits(pal);
+    if (digits(newhalf) == digits(half)) {
+        /* no change in half digits: process as normal */
+        if (iseven(paldigits)) {
+            newpal = mkpal(newhalf);
+        } else {
+            newpal = mkpalmiddigit(newhalf // 10, newhalf % 10);
+        }
+    } else {
+        /* change in half digits: process as opposite */
+        if (iseven(paldigits)) {
+            newpal = mkpalmiddigit(newhalf // 10, newhalf % 10);
+        } else {
+            newpal = mkpal(newhalf);
+        }
+    }
+
+    /*
+     * return the new palindrome
+     */
+    return newpal;
+}
+
+
+/*
+ * prevpal - return previous palindrome from a value
+ *
+ * NOTE: We assume base 10 digits and place 1 is the units digit.
+ *
+ * given:
+ *      val     a value
+ *
+ * returns:
+ *      previous palindrome < val
+ */
+define prevpal(val)
+{
+    local newval;       /* val-1 */
+    local newvaldigits; /* digits in newval */
+    local half;         /* upper half of newval */
+    local pal;          /* palindrome test value */
+    local newpal;       /* new palindrome */
+
+    /* case: negative value */
+    if (val < 0) {
+        return -(nextpal(-val));
+    }
+
+    /*
+     * start looking from a smaller value
+     */
+    newval = val-1;
+    newvaldigits = digits(newval);
+
+    /* case: single digit palindrome */
+    if (newvaldigits < 2) {
+        return newval;
+    }
+
+    /*
+     * start with previous upper half
+     */
+    half = upperhalf(newval);
+
+    /*
+     * form palindrome from upper half
+     *
+     * We need to deal with even vs. odd digit counts
+     * when forming a palindrome from a half as the
+     * half may not or may include the middle digit.
+     */
+    if (iseven(newvaldigits)) {
+        pal = mkpal(half);
+    } else {
+        pal = mkpalmiddigit(half // 10, half % 10);
+    }
+
+    /*
+     * case: we found a smaller palindrome, we are done
+     */
+    if (pal < val) {
+        return pal;
+    }
+
+    /*
+     * we need to find an even smaller palindrome
+     */
+    newpal = palprevpal(pal);
+
+    /*
+     * return the new palindrome
+     */
+    return newpal;
+}
+
+
+/*
+ * nextprimepal - return next palindrome that is a (highly probable) prime
+ *
+ * NOTE: We assume base 10 digits and place 1 is the units digit.
+ *
+ * given:
+ *      val     a value
+ *
+ * returns:
+ *      next palindrome (highly probable) prime > val
+ */
+define nextprimepal(val)
+{
+    local pal;          /* palindrome test value */
+    local dpal;         /* digits in pal */
+
+    /*
+     * pre-start under the next palindrome
+     */
+    pal = nextpal(val-1);
+
+    /*
+     * loop until we find a (highly probable) prime or 0
+     */
+    do {
+
+        /* case: negative values and tiny values */
+        if (pal < 2) {
+            return 2;
+        }
+
+        /*
+         * compute the next palindrome
+         */
+        pal = palnextpal(pal);
+        dpal = digits(pal);
+
+        /* case: 11 is the only prime palindrome with even digit count */
+        if (pal == 11) {
+            return 11;
+        }
+
+        /* case: even number of digits and not 11 */
+        if (iseven(dpal)) {
+
+            /*
+             * Except for 11 (which is handled above already), there are
+             * no prime palindrome with even digits.  So we need to
+             * increase the digit count and work with that larger palindrome.
+             */
+            pal = nextpal(10^dpal);
+        }
+
+        /* case: palindrome is even or ends in 5 */
+        if (iseven(pal % 10) || (pal%10 == 10/2)) {
+
+            /*
+             * we need to increase the bottom and top digits
+             * so that we have a chance to be prime
+             */
+            pal += (1 + 10^(dpal-1));
+        }
+        if (config("resource_debug") & 0x8) {
+            print "DEBUG: nextprimepal:", pal;
+        }
+    } while (ptest(pal) == 0 && pal > 0);
+
+    /* return palindrome that his (highly probable) prime or 0 */
+    return pal;
+}
+
+
+/*
+ * prevprimepal - return prev palindrome that is a (highly probable) prime
+ *
+ * NOTE: We assume base 10 digits and place 1 is the units digit.
+ *
+ * given:
+ *      val     a value
+ *
+ * returns:
+ *      prev palindrome (highly probable) prime < val or 0
+ */
+define prevprimepal(val)
+{
+    local pal;          /* palindrome test value */
+    local dpal;         /* digits in pal */
+
+    /*
+     * pre-start over the previous palindrome
+     */
+    pal = prevpal(val+1);
+
+    /*
+     * loop until we find a (highly probable) prime or 0
+     */
+    do {
+
+        /*
+         * case: single digit values are always palindromes
+         */
+        if (val < 10) {
+            /*
+             * The prevcand() call will return 0 if there is no previous prime
+             * such as the case when val < 2.
+             */
+            return prevcand(pal);
+        }
+
+        /*
+         * compute the previous palindrome
+         */
+        pal = palprevpal(pal);
+        dpal = digits(pal);
+
+        /* case: 11 is the only prime palindrome with even digit count */
+        if (pal == 11) {
+            return 11;
+        }
+
+        /* case: 2 digit palindrome and not 11 */
+        if (dpal == 2) {
+            return 7;
+        }
+
+        /* case: even number of digits */
+        if (iseven(dpal)) {
+
+            /*
+             * Except for 11 (which is handled above already), there are
+             * no prime palindrome with even digits.  So we need to
+             * decrease the digit count and work with that smaller palindrome.
+             */
+            pal = prevpal(10^(dpal-1));
+        }
+
+        /* case: palindrome is even or ends in 5 */
+        if (iseven(pal % 10) || (pal%10 == 10/2)) {
+
+            /*
+             * we need to decrease the bottom and top digits
+             * so that we have a chance to be prime
+             */
+            pal -= (1 + 10^(dpal-1));
+        }
+        if (config("resource_debug") & 0x8) {
+            print "DEBUG: prevprimepal:", pal;
+        }
+    } while (ptest(pal) == 0 && pal > 0);
+
+    /* return palindrome that his (highly probable) prime or 0 */
+    return pal;
+}

cal/pell.cal

@@ -1,7 +1,7 @@
 /*
  * pell - solve Pell's equation
  *
- * Copyright (C) 1999  David I. Bell
+ * Copyright (C) 1999,2021  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
@@ -9,86 +9,82 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: pell.cal,v 29.1 1999/12/14 09:15:31 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
  *
- * Under source code control:	1990/02/15 01:50:34
- * File existed as early as:	before 1990
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * 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.
+ * Type the solution to Pell's equation for a particular D.
  */
 
 
 define pell(D)
 {
-	local X, Y;
+        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;
+        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
+ *      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];
+        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;
+        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

@@ -1,7 +1,7 @@
 /*
  * pi - various routines to calculate pi
  *
- * Copyright (C) 1999  David I. Bell
+ * Copyright (C) 1999-2004,2021  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
@@ -9,22 +9,18 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: pi.cal,v 29.1 1999/12/14 09:15:31 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
  *
- * Under source code control:	1991/05/22 21:56:37
- * File existed as early as:	1991
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -35,50 +31,50 @@
 
 define qpi(epsilon)
 {
-	local niter, yn, ym, tm, an, am, t, tn, sqrt2, epsilon2, count, digits;
-	local bits, bits2;
+        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));
+        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>
+ * Written by Klaus Alexander Seistrup <klaus at seistrup dot dk>
  * on a dull Friday evening in November 1999.
  *
  * Inspired by an algorithm conceived by Lambert Meertens.
@@ -90,58 +86,58 @@ define qpi(epsilon)
 
 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;
+        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++;
+        while (1) {
+                /*
+                * Next approximation
+                */
+                p = k * k;
+                q = k + ++k;
 
-		a2 = a;
-		b2 = b;
+                a2 = a;
+                b2 = b;
 
-		a = a1;
-		a1 = p * a2 + q * a1;
-		b = b1;
-		b1 = p * b2 + q * b1;
+                a = a1;
+                a1 = p * a2 + q * a1;
+                b = b1;
+                b1 = p * b2 + q * b1;
 
-		/*
-		* Print common digits
-		*/
-		d = a // b;
-		d1 = a1 // 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);
-	}
+                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

@@ -9,63 +9,59 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: pix.cal,v 29.1 1999/12/14 09:15:31 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
  *
- * Under source code control:	1996/07/09 03:14:14
- * File existed as early as:	1996
- *
- * chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * 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"
+ * 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.
+ *       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 */
+        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;
+        /*
+         * 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;
+        /*
+         * 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

@@ -9,44 +9,40 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: pollard.cal,v 29.1 1999/12/14 09:15:31 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
  *
- * Under source code control:	1991/05/22 21:56:37
- * File existed as early as:	1991
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 
 define pfactor(N, B, ai, af)
 {
-	local	a, k, i, d;
+        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;
+        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/prompt.cal

@@ -1,7 +1,7 @@
 /*
- * prompt - eemonstration of some uses of prompt() and eval()
+ * prompt - demonstration of some uses of prompt() and eval()
  *
- * Copyright (C) 1999  Ernest Bowen
+ * Copyright (C) 1999,2021  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
@@ -9,22 +9,18 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: prompt.cal,v 29.1 1999/12/14 09:15:32 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
  *
- * Under source code control:	1995/12/18 04:43:25
- * File existed as early as:	1995
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -36,7 +32,7 @@
  * entering "end", "exit" or "quit"; "end" returns to the level from
  * which adder() is called, e.g. with:
  *
- *		for (;;) adder()
+ *              for (;;) adder()
  *
  * entering "end" would start a new edition with sum = 0; "quit" and
  * "exit" return to the top level.
@@ -47,27 +43,27 @@
  * thus the string may include variables, assignments, functions, etc.
  * as in:
  *
- *		2 + 3
- *		x = 2 + 3, x^3
- *		x^2
- *		local x = 2; while (x < 100) x *= 2; x % 100
- *		x
- *		exp(2, 1e-5)
- *		sum
- *		print sum^2;
- *		3; print sum^2;
+ *              2 + 3
+ *              x = 2 + 3, x^3
+ *              x^2
+ *              local x = 2; while (x < 100) x *= 2; x % 100
+ *              x
+ *              exp(2, 1e-5)
+ *              sum
+ *              print sum^2;
+ *              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)
+ * calc but eval("print 7") causes an exit from calc. XXX)
  *
  * If the value returned is not a number (e.g. the name of a list or matrix,
  * or if the string has syntax errors as in "2 + ", in which case the
@@ -76,44 +72,44 @@
  *
  * Calling showvalues(str) assumes str defines a function of x as in:
  *
- *	"sin(x)", "x^2 + 3*x", "exp(x, 1e-5)".
+ *      "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 response to the ? prompt. Operation is terminated by
  * entering "end", "exit" or "quit".
  */
 
 
 define adder() {
-	global sum = 0;
-	local s, t;
-	for (;;) {
-		s = prompt("? ");
-		if (s == "end")
-			break;
-		t = eval(s);
-		if (!isnum(t)) {
-			print "Please enter a number";
-			continue;
-		}
-		sum += t;
-		print "\t":sum;
-	}
+        global sum = 0;
+        local s, t;
+        for (;;) {
+                s = prompt("? ");
+                if (s == "end")
+                        break;
+                t = eval(s);
+                if (!isnum(t)) {
+                        print "Please enter a number";
+                        continue;
+                }
+                sum += t;
+                print "\t":sum;
+        }
 }
 
-global x;
+global prompt_x;
 
 define showvalues(str) {
-	local s;
-	for (;;) {
-		s = prompt("? ");
-		if (s == "end")
-			break;
-		x = eval(s);
-		if (!isnum(x)) {
-			print "Please enter a number";
-			continue;
-		}
-		print "\t":eval(str);
-	}
+        local s;
+        for (;;) {
+                s = prompt("? ");
+                if (s == "end")
+                        break;
+                prompt_x = eval(s);
+                if (!isnum(prompt_x)) {
+                        print "Please enter a number";
+                        continue;
+                }
+                print "\t":eval(str);
+        }
 }

cal/psqrt.cal

@@ -9,22 +9,18 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: psqrt.cal,v 29.1 1999/12/14 09:15:32 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
  *
- * Under source code control:	1990/02/15 01:50:35
- * File existed as early as:	before 1990
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -35,40 +31,40 @@
 
 define psqrt(u, p)
 {
-	local	p1, q, n, y, r, v, w, t, k;
+        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);
+        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

@@ -1,24 +1,42 @@
 /*
  * qtime - Display time as English sentence
  *
+ * Copyright (C) 1999,2021  Klaus Alexander Seistrup and Landon Curt Noll
+ *
+ * Written by: Klaus Alexander Seistrup <kseis at magnetic-ink dot 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.
+ *
+ * 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)
+ *      qtime(utc_hr_offset)
  *
- *	utc_hr_offset	Offset from UTC in hours.
- *
- * Written by: Klaus Alexander Seistrup <kseis@magnetic-ink.dk>
- * With minor mods by: Landon Curt Noll <http://reality.sgi.com/chongo/>
+ *      utc_hr_offset   Offset from UTC in hours.
  *
  * See:
- *	http://www.magnetic-ink.dk/download/qtime.html
+ *      http://www.magnetic-ink.dk/download/qtime.html
  *
  * for examples of qtime() written on other languages.
- *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: qtime.cal,v 29.1 1999/12/14 09:15:32 chongo Exp $
- * @(#) $Source: /usr/local/src/cmd/calc/cal/RCS/qtime.cal,v $
- *
- * This file is not covered under version 2.1 of the GNU LGPL.
  */
 
 
@@ -27,42 +45,42 @@
  */
 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;
+        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;
+        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 ".";
+        /*
+         * 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,7 +1,7 @@
 /*
- * quat - alculate using quaternions of the form: a + bi + cj + dk
+ * quat - calculate using quaternions of the form: a + bi + cj + dk
  *
- * Copyright (C) 1999  David I. Bell
+ * Copyright (C) 1999,2021  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
@@ -9,216 +9,213 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: quat.cal,v 29.1 1999/12/14 09:15:32 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
  *
- * Under source code control:	1990/02/15 01:50:35
- * File existed as early as:	before 1990
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
  * Routines to handle quaternions of the form:
- *	a + bi + cj + dk
+ *      a + bi + cj + dk
  *
  * Note: In this module, quaternians are manipulated in the form:
- *	s + v
+ *      s + v
  * Where s is a scalar and v is a vector of size 3.
  */
 
 
-obj quat {s, v};		/* definition of the quaternion object */
+obj quat {s, v};                /* definition of the quaternion object */
 
 
 define quat(a,b,c,d)
 {
-	local obj quat	x;
+        local obj quat  x;
 
-	x.s = isnull(a) ? 0 : a;
-	mat x.v[3];
-	x.v[0] = isnull(b) ? 0 : b;
-	x.v[1] = isnull(c) ? 0 : c;
-	x.v[2] = isnull(d) ? 0 : d;
-	return x;
+        x.s = isnull(a) ? 0 : a;
+        mat x.v[3];
+        x.v[0] = isnull(b) ? 0 : b;
+        x.v[1] = isnull(c) ? 0 : c;
+        x.v[2] = isnull(d) ? 0 : d;
+        return x;
 }
 
 
 define quat_print(a)
 {
-	print "quat(" : a.s : ", " : a.v[0] : ", " : a.v[1] : ", " : a.v[2] : ")" :;
+        print "quat(" : a.s : ", " : a.v[0] : ", " :
+              a.v[1] : ", " : a.v[2] : ")" :;
 }
 
 
 define quat_norm(a)
 {
-	return a.s^2 + dp(a.v, a.v);
+        return a.s^2 + dp(a.v, a.v);
 }
 
 
 define quat_abs(a, e)
 {
-	return sqrt(a.s^2 + dp(a.v, a.v), e);
+        return sqrt(a.s^2 + dp(a.v, a.v), e);
 }
 
 
 define quat_conj(a)
 {
-	local obj quat	x;
+        local obj quat  x;
 
-	x.s = a.s;
-	x.v = -a.v;
-	return x;
+        x.s = a.s;
+        x.v = -a.v;
+        return x;
 }
 
 
 define quat_add(a, b)
 {
-	local obj quat	x;
+        local obj quat  x;
 
-	if (!istype(b, x)) {
-		x.s = a.s + b;
-		x.v = a.v;
-		return x;
-	}
-	if (!istype(a, x)) {
-		x.s = a + b.s;
-		x.v = b.v;
-		return x;
-	}
-	x.s = a.s + b.s;
-	x.v = a.v + b.v;
-	if (x.v)
-		return x;
-	return x.s;
+        if (!istype(b, x)) {
+                x.s = a.s + b;
+                x.v = a.v;
+                return x;
+        }
+        if (!istype(a, x)) {
+                x.s = a + b.s;
+                x.v = b.v;
+                return x;
+        }
+        x.s = a.s + b.s;
+        x.v = a.v + b.v;
+        if (x.v)
+                return x;
+        return x.s;
 }
 
 
 define quat_sub(a, b)
 {
-	local obj quat	x;
+        local obj quat  x;
 
-	if (!istype(b, x)) {
-		x.s = a.s - b;
-		x.v = a.v;
-		return x;
-	}
-	if (!istype(a, x)) {
-		x.s = a - b.s;
-		x.v = -b.v;
-		return x;
-	}
-	x.s = a.s - b.s;
-	x.v = a.v - b.v;
-	if (x.v)
-		return x;
-	return x.s;
+        if (!istype(b, x)) {
+                x.s = a.s - b;
+                x.v = a.v;
+                return x;
+        }
+        if (!istype(a, x)) {
+                x.s = a - b.s;
+                x.v = -b.v;
+                return x;
+        }
+        x.s = a.s - b.s;
+        x.v = a.v - b.v;
+        if (x.v)
+                return x;
+        return x.s;
 }
 
 
 define quat_inc(a)
 {
-	local	x;
+        local   x;
 
-	x = a;
-	x.s++;
-	return x;
+        x = a;
+        x.s++;
+        return x;
 }
 
 
 define quat_dec(a)
 {
-	local	x;
+        local   x;
 
-	x = a;
-	x.s--;
-	return x;
+        x = a;
+        x.s--;
+        return x;
 }
 
 
 define quat_neg(a)
 {
-	local obj quat	x;
+        local obj quat  x;
 
-	x.s = -a.s;
-	x.v = -a.v;
-	return x;
+        x.s = -a.s;
+        x.v = -a.v;
+        return x;
 }
 
 
 define quat_mul(a, b)
 {
-	local obj quat	x;
+        local obj quat  x;
 
-	if (!istype(b, x)) {
-		x.s = a.s * b;
-		x.v = a.v * b;
-	} else if (!istype(a, x)) {
-		x.s = b.s * a;
-		x.v = b.v * a;
-	} else {
-		x.s = a.s * b.s - dp(a.v, b.v);
-		x.v = a.s * b.v + b.s * a.v + cp(a.v, b.v);
-	}
-	if (x.v)
-		return x;
-	return x.s;
+        if (!istype(b, x)) {
+                x.s = a.s * b;
+                x.v = a.v * b;
+        } else if (!istype(a, x)) {
+                x.s = b.s * a;
+                x.v = b.v * a;
+        } else {
+                x.s = a.s * b.s - dp(a.v, b.v);
+                x.v = a.s * b.v + b.s * a.v + cp(a.v, b.v);
+        }
+        if (x.v)
+                return x;
+        return x.s;
 }
 
 
 define quat_div(a, b)
 {
-	local obj quat	x;
+        local obj quat  x;
 
-	if (!istype(b, x)) {
-		x.s = a.s / b;
-		x.v = a.v / b;
-		return x;
-	}
-	return a * quat_inv(b);
+        if (!istype(b, x)) {
+                x.s = a.s / b;
+                x.v = a.v / b;
+                return x;
+        }
+        return a * quat_inv(b);
 }
 
 
 define quat_inv(a)
 {
-	local	x, q2;
+        local   x, q2;
 
-	obj quat x;
-	q2 = a.s^2 + dp(a.v, a.v);
-	x.s = a.s / q2;
-	x.v = a.v / (-q2);
-	return x;
+        obj quat x;
+        q2 = a.s^2 + dp(a.v, a.v);
+        x.s = a.s / q2;
+        x.v = a.v / (-q2);
+        return x;
 }
 
 
 define quat_scale(a, b)
 {
-	local obj quat	x;
+        local obj quat  x;
 
-	x.s = scale(a.s, b);
-	x.v = scale(a.v, b);
-	return x;
+        x.s = scale(a.s, b);
+        x.v = scale(a.v, b);
+        return x;
 }
 
 
 define quat_shift(a, b)
 {
-	local obj quat	x;
+        local obj quat  x;
 
-	x.s = a.s << b;
-	x.v = a.v << b;
-	if (x.v)
-		return x;
-	return x.s;
+        x.s = a.s << b;
+        x.v = a.v << b;
+        if (x.v)
+                return x;
+        return x.s;
 }
 
 if (config("resource_debug") & 3) {

cal/randbitrun.cal

@@ -1,7 +1,7 @@
 /*
- * randbitrun - check rand bit run lengths of the a55 generator
+ * randbitrun - check rand bit run lengths of the subtractive 100 shuffle generator
  *
- * Copyright (C) 1999  Landon Curt Noll
+ * Copyright (C) 1999,2023  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
@@ -9,23 +9,19 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: randbitrun.cal,v 29.1 1999/12/14 09:15:32 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
  *
- * Under source code control:	1995/02/13 03:43:11
- * File existed as early as:	1995
- *
- * chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -36,30 +32,30 @@
 
 define randbitrun(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 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 */
+    local mat prob[1:MAX_RUN];  /* prob[x] = probability of 'x' length run */
 
     /*
      * parse args
      */
     if (param(0) == 0) {
-	run_cnt = 65536;
+        run_cnt = 65536;
     }
 
     /*
      * run setup
      */
-    max_run = 0;		/* no runs yet */
-    long_run_cnt = 0;		/* no long runs set */
-    current = randbit(1);	/* our first number */
+    max_run = 0;                /* no runs yet */
+    long_run_cnt = 0;           /* no long runs set */
+    current = randbit(1);       /* our first number */
     run = 1;
 
     /*
@@ -67,10 +63,10 @@ define randbitrun(run_cnt)
      *
      * A bit run length of 'r' occurs with a probability of:
      *
-     *			1/2^n;
+     *                  1/2^n;
      */
     for (i=1; i <= MAX_RUN; ++i) {
-	prob[i] = 1.0/(1<<i);
+        prob[i] = 1.0/(1<<i);
     }
 
     /*
@@ -78,31 +74,31 @@ define randbitrun(run_cnt)
      */
     for (i=0; i < run_cnt; ++i) {
 
-	/* get our current number */
-	last = current;
-	current = randbit(1);
+        /* get our current number */
+        last = current;
+        current = randbit(1);
 
-	/* look for a run break */
-	if (current != last) {
+        /* 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];
-	    }
+            /*  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 = randbit(1);
-	    run = 1;
+            /* start a new run */
+            current = randbit(1);
+            run = 1;
 
-	/* note the continuing run */
-	} else {
-	    ++run;
-	}
+        /* note the continuing run */
+        } else {
+            ++run;
+        }
     }
     /* determine the number of runs found */
     tally_sum = matsum(tally) + long_run_cnt;
@@ -113,9 +109,9 @@ define randbitrun(run_cnt)
     printf("rand 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\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/randmprime.cal

@@ -1,7 +1,7 @@
 /*
  * randmprime - generate a random prime of the form h*2^n-1
  *
- * Copyright (C) 1999  Landon Curt Noll
+ * Copyright (C) 1999,2021  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
@@ -9,23 +9,19 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: randmprime.cal,v 29.1 1999/12/14 09:15:32 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
  *
- * Under source code control:	1994/03/14 23:11:21
- * File existed as early as:	1994
- *
- * chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 
@@ -36,37 +32,37 @@ read -once "lucas.cal"
  * randmprime - find a random prime of the form h*2^n-1 of a given size
  *
  * given:
- *	bits	minimum bits in prime to return
- *	seed	random seed for srandom()
- *	[dbg]	if given, enable debugging
+ *      bits    minimum bits in prime to return
+ *      seed    random seed for srandom()
+ *      [dbg]   if given, enable debugging
  *
  * returns:
- *	a prime of the form h*2^n-1
+ *      a prime of the form h*2^n-1
  */
 define
 randmprime(bits, seed, dbg)
 {
-    local n;		/* n as in h*2^n-1 */
-    local h;		/* h as in h*2^n-1 */
-    local plush;	/* value added to h since the beginning */
-    local init;		/* initial cpu time */
-    local start;	/* cpu time before last test */
-    local stop;		/* cpu time afte last test */
-    local tmp;		/* just a tmp place holder value */
-    local ret;		/* h*2^n-1 that is prime */
+    local n;            /* n as in h*2^n-1 */
+    local h;            /* h as in h*2^n-1 */
+    local plush;        /* value added to h since the beginning */
+    local init;         /* initial CPU time */
+    local start;        /* CPU time before last test */
+    local stop;         /* CPU time after last test */
+    local tmp;          /* just a tmp place holder value */
+    local ret;          /* h*2^n-1 that is prime */
 
     /* firewall */
     if (param(0) < 2 || param(0) > 3) {
-	quit "bad usage: rndprime(dig, seed [,dbg])";
+        quit "bad usage: rndprime(dig, seed [,dbg])";
     }
     if (!isint(bits) || bits < 0 || !isint(seed) || seed < 0) {
-	quit "args must be non-negative integers";
+        quit "args must be non-negative integers";
     }
     if (bits < 1) {
-	bits = 1;
+        bits = 1;
     }
     if (param(0) == 2 || dbg < 0) {
-	dbg = 0;
+        dbg = 0;
     }
 
     /* seed generator */
@@ -80,57 +76,57 @@ randmprime(bits, seed, dbg)
        ++n;
     }
     if (dbg >= 1) {
-	print "DEBUG3: initial h =", h;
-	print "DEBUG3: initial n =", n;
+        print "DEBUG3: initial h =", h;
+        print "DEBUG3: initial n =", n;
     }
 
     /*
      * loop until we find a prime
      */
     if (dbg >= 1) {
-	start = runtime();
-	init = runtime();
-	plush = 0;
-	print "DEBUG1: testing (h+" : plush : ")*2^" : n : "-1";
+        start = usertime();
+        init = usertime();
+        plush = 0;
+        print "DEBUG1: testing (h+" : plush : ")*2^" : n : "-1";
     }
     while (lucas(h,n) == 0) {
 
-	/* bump h, and n if needed */
-	if (dbg >= 2) {
-	    stop = runtime();
-	    print "DEBUG2: last test:", stop-start, "	total time:", stop-init;
-	}
-	if (dbg >= 1) {
-	    print "DEBUG1: composite: (h+" : plush : ")*2^" : n : "-1";
-	    plush += 2;
-	}
-	h += 2;
-	while (highbit(h) >= n) {
-	   ++n;
-	}
-	if (dbg >= 1) {
-	    print "DEBUG1: testing (h+" : plush : ")*2^" : n : "-1";
-	    start = stop;
-	}
+        /* bump h, and n if needed */
+        if (dbg >= 2) {
+            stop = usertime();
+            print "DEBUG2: last test:", stop-start, "   total time:", stop-init;
+        }
+        if (dbg >= 1) {
+            print "DEBUG1: composite: (h+" : plush : ")*2^" : n : "-1";
+            plush += 2;
+        }
+        h += 2;
+        while (highbit(h) >= n) {
+           ++n;
+        }
+        if (dbg >= 1) {
+            print "DEBUG1: testing (h+" : plush : ")*2^" : n : "-1";
+            start = stop;
+        }
     }
 
     /* found a prime */
     if (dbg >= 2) {
-	stop = runtime();
-	print "DEBUG2: last test:", stop-start, "   total time:", stop-init;
-	print "DEBUG3: " : h : "*2^" : n : "-1 is prime";
+        stop = usertime();
+        print "DEBUG2: last test:", stop-start, "   total time:", stop-init;
+        print "DEBUG3: " : h : "*2^" : n : "-1 is prime";
     }
     if (dbg >= 1) {
-	print "DEBUG1: prime: (h+" : plush : ")*2^" : n : "-1";
+        print "DEBUG1: prime: (h+" : plush : ")*2^" : n : "-1";
     }
     ret = h*2^n-1;
     if (dbg >= 3) {
-	print "DEBUG3: highbit(h):", highbit(h);
-	print "DEBUG3: digits(h):", digits(h);
-	print "DEBUG3: highbit(n):", highbit(n);
-	print "DEBUG3: digits(2^n):", int(n*ln(10)/ln(2)+1);
-	print "DEBUG3: highbit(h*2^n-1):", highbit(ret);
-	print "DEBUG3: digits(h*2^n)-1:", digits(ret);
+        print "DEBUG3: highbit(h):", highbit(h);
+        print "DEBUG3: digits(h):", digits(h);
+        print "DEBUG3: highbit(n):", highbit(n);
+        print "DEBUG3: digits(2^n):", int(n*ln(10)/ln(2)+1);
+        print "DEBUG3: highbit(h*2^n-1):", highbit(ret);
+        print "DEBUG3: digits(h*2^n)-1:", digits(ret);
     }
     return ret;
 }

cal/randombitrun.cal

@@ -9,23 +9,19 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: randombitrun.cal,v 29.1 1999/12/14 09:15:32 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
  *
- * Under source code control:	1995/02/13 03:43:11
- * File existed as early as:	1995
- *
- * chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -36,30 +32,30 @@
 
 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 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 */
+    local mat prob[1:MAX_RUN];  /* prob[x] = probability of 'x' length run */
 
     /*
      * parse args
      */
     if (param(0) == 0) {
-	run_cnt = 65536;
+        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 */
+    max_run = 0;                /* no runs yet */
+    long_run_cnt = 0;           /* no long runs set */
+    current = randombit(1);     /* our first number */
     run = 1;
 
     /*
@@ -67,10 +63,10 @@ define randombitrun(run_cnt)
      *
      * A bit run length of 'r' occurs with a probability of:
      *
-     *			1/2^n;
+     *                  1/2^n;
      */
     for (i=1; i <= MAX_RUN; ++i) {
-	prob[i] = 1.0/(1<<i);
+        prob[i] = 1.0/(1<<i);
     }
 
     /*
@@ -78,31 +74,31 @@ define randombitrun(run_cnt)
      */
     for (i=0; i < run_cnt; ++i) {
 
-	/* get our current number */
-	last = current;
-	current = randombit(1);
+        /* get our current number */
+        last = current;
+        current = randombit(1);
 
-	/* look for a run break */
-	if (current != last) {
+        /* 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];
-	    }
+            /*  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;
+            /* start a new run */
+            current = randombit(1);
+            run = 1;
 
-	/* note the continuing run */
-	} else {
-	    ++run;
-	}
+        /* note the continuing run */
+        } else {
+            ++run;
+        }
     }
     /* determine the number of runs found */
     tally_sum = matsum(tally) + long_run_cnt;
@@ -113,9 +109,9 @@ define randombitrun(run_cnt)
     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\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

@@ -9,23 +9,19 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: randomrun.cal,v 29.1 1999/12/14 09:15:32 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
  *
- * Under source code control:	1997/02/19 03:35:59
- * File existed as early as:	1997
- *
- * chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -45,30 +41,30 @@
 
 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 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 */
+    local mat prob[1:MAX_RUN];  /* prob[x] = probability of 'x' length run */
 
     /*
      * parse args
      */
     if (param(0) == 0) {
-	run_cnt = 65536;
+        run_cnt = 65536;
     }
 
     /*
      * run setup
      */
-    max_run = 0;		/* no runs yet */
-    long_run_cnt = 0;		/* no long runs set */
-    current = random();		/* our first number */
+    max_run = 0;                /* no runs yet */
+    long_run_cnt = 0;           /* no long runs set */
+    current = random();         /* our first number */
     run = 1;
 
     /*
@@ -76,10 +72,10 @@ define randomrun(run_cnt)
      *
      * A run length of 'r' occurs with a probability of:
      *
-     *			1/r! - 1/(r+1)!
+     *                  1/r! - 1/(r+1)!
      */
     for (i=1; i <= MAX_RUN; ++i) {
-	prob[i] = 1.0/fact(i) - 1.0/fact(i+1);
+        prob[i] = 1.0/fact(i) - 1.0/fact(i+1);
     }
 
     /*
@@ -87,31 +83,31 @@ define randomrun(run_cnt)
      */
     for (i=0; i < run_cnt; ++i) {
 
-	/* get our current number */
-	last = current;
-	current = random();
+        /* get our current number */
+        last = current;
+        current = random();
 
-	/* look for a run break */
-	if (current < last) {
+        /* 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];
-	    }
+            /*  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;
+            /* start a new run */
+            current = random();
+            run = 1;
 
-	/* note the continuing run */
-	} else {
-	    ++run;
-	}
+        /* note the continuing run */
+        } else {
+            ++run;
+        }
     }
     /* determine the number of runs found */
     tally_sum = matsum(tally) + long_run_cnt;
@@ -122,9 +118,9 @@ define randomrun(run_cnt)
     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\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

@@ -9,22 +9,18 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: randrun.cal,v 29.1 1999/12/14 09:15:32 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
  *
- * Under source code control:	1995/02/12 20:00:06
- * File existed as early as:	1995
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -44,30 +40,30 @@
 
 define randrun(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 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 */
+    local mat prob[1:MAX_RUN];  /* prob[x] = probability of 'x' length run */
 
     /*
      * parse args
      */
     if (param(0) == 0) {
-	run_cnt = 65536;
+        run_cnt = 65536;
     }
 
     /*
      * run setup
      */
-    max_run = 0;		/* no runs yet */
-    long_run_cnt = 0;		/* no long runs set */
-    current = rand();		/* our first number */
+    max_run = 0;                /* no runs yet */
+    long_run_cnt = 0;           /* no long runs set */
+    current = rand();           /* our first number */
     run = 1;
 
     /*
@@ -75,10 +71,10 @@ define randrun(run_cnt)
      *
      * A run length of 'r' occurs with a probability of:
      *
-     *			1/r! - 1/(r+1)!
+     *                  1/r! - 1/(r+1)!
      */
     for (i=1; i <= MAX_RUN; ++i) {
-	prob[i] = 1.0/fact(i) - 1.0/fact(i+1);
+        prob[i] = 1.0/fact(i) - 1.0/fact(i+1);
     }
 
     /*
@@ -86,31 +82,31 @@ define randrun(run_cnt)
      */
     for (i=0; i < run_cnt; ++i) {
 
-	/* get our current number */
-	last = current;
-	current = rand();
+        /* get our current number */
+        last = current;
+        current = rand();
 
-	/* look for a run break */
-	if (current < last) {
+        /* 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];
-	    }
+            /*  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 = rand();
-	    run = 1;
+            /* start a new run */
+            current = rand();
+            run = 1;
 
-	/* note the continuing run */
-	} else {
-	    ++run;
-	}
+        /* note the continuing run */
+        } else {
+            ++run;
+        }
     }
     /* determine the number of runs found */
     tally_sum = matsum(tally) + long_run_cnt;
@@ -121,9 +117,9 @@ define randrun(run_cnt)
     printf("rand 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\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/repeat.cal

@@ -0,0 +1,49 @@
+/*
+ * 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.
+ *
+ * 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,75 @@
+/*
+ * screen - ANSI control sequences
+ *
+ * This file was created by Ernest Bowen <ebowen at une dot edu dot au>.
+ *
+ * This file is not covered under version 2.1 of the GNU LGPL.
+ * This file is covered under "The unlicense":
+ *
+ *      https://unlicense.org
+ *
+ * In particular:
+ *
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * For more information, please refer to <http://unlicense.org/>
+ *
+ * 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

@@ -9,30 +9,26 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: seedrandom.cal,v 29.1 1999/12/14 09:15:33 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
  *
- * Under source code control:	1996/01/01 08:21:00
- * File existed as early as:	1996
- *
- * chongo <was here> /\oo/\	http://reality.sgi.com/chongo/
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * 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)
+ *      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.
@@ -42,118 +38,118 @@
  * 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)
+ *      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
+ *      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.
+ *       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 */
+        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";
-	}
+        /*
+         * 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;
+        /*
+         * 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") & 3) {
-		print "/* 1st Blum prime */ p=", p;
-	}
+        /*
+         * 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") & 3) {
-		print "/* 2nd Blum prime */ q=", q;
-	}
+        /*
+         * 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") & 3) {
-		print "/* seed quadratic residue */ r=", r;
-		print "/* newn", binsize, "bit quadratic residue*/ newn=", n;
-	}
-	old_state = srandom(r, n);
+        /*
+         * 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);
+        /*
+         * restore other states that we altered
+         */
+        random_junk = srandom(random_state);
 
-	/*
-	 * return the previous random state
-	 */
-	return old_state;
+        /*
+         * return the previous random state
+         */
+        return old_state;
 }
 
 if (config("resource_debug") & 3) {

cal/set8700.line

@@ -0,0 +1,425 @@
+##
+## set8700 - dotest line tests for the 8700 set of regress.cal
+##
+## Copyright (C) 2006,2021  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.
+##
+## 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 protection
+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 "initialization"
+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/smallfactors.cal

@@ -0,0 +1,71 @@
+/*
+ * smallfactors - find the factors of a number < 2^32
+ *
+ * Copyright (C) 2013 Christoph Zurnieden
+ *
+ * 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.
+ */
+
+
+static resource_debug_level;
+resource_debug_level = config("resource_debug", 0);
+
+
+define smallfactors(x0)
+{
+    local d q x flist tuple w;
+
+    if (x >= (2 ^ 32) - 1)
+        return newerror("smallfactors: number must be < 2^32 -1");
+
+    tuple = mat[2];
+    flist = list();
+    x = x0;
+    d = 2;
+    q = 0;
+    tuple[0] = d;
+    if (x < 2)
+        return 0;
+    do {
+        q = x // d;
+            while (x == (q * d)) {
+            tuple[0] = d;
+            tuple[1]++;
+            x = floor(q);
+            q = x // d;
+        }
+        d = nextprime(d);
+        if (tuple[1] > 0)
+            append(flist, tuple);
+        tuple = mat[2];
+    } while (d <= x);
+    return flist;
+}
+
+define printsmallfactors(flist)
+{
+    local k;
+    for (k = 0; k < size(flist); k++) {
+        print flist[k][0]:"^":flist[k][1];
+    }
+}
+
+
+config("resource_debug", resource_debug_level),;
+if (config("resource_debug") & 3) {
+    print "smallfactors(x0)";
+    print "printsmallfactors(flist)";
+
+}

cal/solve.cal

@@ -9,22 +9,18 @@
  *
  * 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
+ * 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.
- * 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- * @(#) $Revision: 29.1 $
- * @(#) $Id: solve.cal,v 29.1 1999/12/14 09:15:33 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
  *
- * Under source code control:	1990/02/15 01:50:37
- * File existed as early as:	before 1990
- *
- * Share and enjoy!  :-)	http://reality.sgi.com/chongo/tech/comp/calc/
+ * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  */
 
 /*
@@ -36,34 +32,35 @@
 
 define solve(low, high, epsilon)
 {
-	local flow, fhigh, fmid, mid, places;
+        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(flow) < 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;
-		}
-	}
+        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/splitbits.cal

@@ -0,0 +1,83 @@
+/*
+ * splitbits - split an integer into list on bit boundardies of a fixed size
+ *
+ * Copyright (C) 2018,2023  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.
+ *
+ * Under source code control:   2006/06/07 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 splitbits errors
+ */
+static E_SPLITBITS_1, E_SPLITBITS_2, E_SPLITBITS_3;
+if (! iserror(E_SPLITBITS_1)) E_SPLITBITS_1 = newerror("1st argument to splitbits must be an integer");
+if (! iserror(E_SPLITBITS_2)) E_SPLITBITS_2 = newerror("2nd argument to splitbits must be an integer");
+if (! iserror(E_SPLITBITS_3)) E_SPLITBITS_3 = newerror("2nd argument must be an integer > 0");
+
+
+/*
+ * define splitbits function
+ */
+define splitbits(x, b)
+{
+    local ret;          /* list to return */
+    local mask;         /* 2^b-1 */
+    local x_is_reg = 0; /* true if x < 0 */
+
+    /* firewall */
+    if (! isint(x)) {
+        return error(E_SPLITBITS_1);
+    }
+    if (! isint(b)) {
+        return error(E_SPLITBITS_2);
+    }
+    if (b <= 0) {
+        return error(E_SPLITBITS_3);
+    }
+
+    /* special case: x == 0 */
+    if (x == 0) {
+        return list(0);
+    }
+
+    /* setup for splitting x */
+    ret = list();
+    mask = 2^b-1;
+    if (x < 0) {
+        x_is_reg = 1;
+        x = abs(x);
+    }
+
+    /* split x */
+    while (x > 0) {
+        printf("%d %x\n", size(ret), x);
+        if (x_is_reg) {
+            append(ret, xor(x & mask, mask));
+        } else {
+            append(ret, x & mask);
+        }
+        x >>= b;
+    }
+
+    /* return list */
+    return ret;
+}

cal/statistics.cal

@@ -0,0 +1,498 @@
+/*
+ * statistics - Some assorted statistics functions.
+ *
+ * Copyright (C) 2013,2021 Christoph Zurnieden
+ *
+ * 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.
+ *
+ * Under source code control:   2013/08/11 01:31:28
+ * File existed as early as:    2013
+ */
+
+
+static resource_debug_level;
+resource_debug_level = config("resource_debug", 0);
+
+
+/*
+ *  get dependencies
+ */
+read -once factorial2 brentsolve
+
+
+/*******************************************************************************
+ *
+ *
+ *                Continuous distributions
+ *
+ *
+ ******************************************************************************/
+
+/* regularized incomplete gamma function like in Octave, hence the name */
+define gammaincoctave(z,a){
+  local tmp;
+  tmp = gamma(z);
+  return (tmp-gammainc(a,z))/tmp;
+}
+
+/* Inverse incomplete beta function. Old and slow. */
+static __CZ__invbeta_a;
+static __CZ__invbeta_b;
+static __CZ__invbeta_x;
+define __CZ__invbeta(x){
+   return __CZ__invbeta_x-__CZ__ibetaas63(x,__CZ__invbeta_a,__CZ__invbeta_b);
+}
+
+define invbetainc_slow(x,a,b){
+  local flag ret eps;
+  /* place checks and balances here */
+  eps = epsilon();
+  if(.5 < x){
+    __CZ__invbeta_x = 1 - x;
+    __CZ__invbeta_a = b;
+    __CZ__invbeta_b = a;
+    flag = 1;
+  }
+  else{
+    __CZ__invbeta_x = x;
+    __CZ__invbeta_a = a;
+    __CZ__invbeta_b = b;
+    flag = 0;
+  }
+
+  ret =  brentsolve2(0,1,1);
+
+  if(flag == 1)
+    ret = 1-ret;
+  epsilon(eps);
+  return ret;
+}
+
+/* Inverse incomplete beta function. Still old but not as slow as the function
+   above. */
+/*
+  Purpose:
+
+    invbetainc computes inverse of the incomplete Beta function.
+
+  Licensing:
+
+    This code is distributed under the GNU LGPL license.
+
+  Modified:
+
+    10 August 2013
+
+  Author:
+
+    Original FORTRAN77 version by GW Cran, KJ Martin, GE Thomas.
+    C version by John Burkardt.
+    Calc version by Christoph Zurnieden
+
+  Reference:
+
+    GW Cran, KJ Martin, GE Thomas,
+    Remark AS R19 and Algorithm AS 109:
+    A Remark on Algorithms AS 63: The Incomplete Beta Integral
+    and AS 64: Inverse of the Incomplete Beta integral,
+    Applied Statistics,
+    Volume 26, Number 1, 1977, pages 111-114.
+
+  Parameters:
+
+    Input,  P, Q, the parameters of the incomplete
+    Beta function.
+
+    Input,  BETA, the logarithm of the value of
+    the complete Beta function.
+
+    Input,  ALPHA, the value of the incomplete Beta
+    function.  0 <= ALPHA <= 1.
+
+    Output,  the argument of the incomplete
+    Beta function which produces the value ALPHA.
+
+  Local Parameters:
+
+    Local, SAE, the most negative decimal exponent
+    which does not cause an underflow.
+*/
+define invbetainc(x,a,b){
+  return __CZ__invbetainc(a,b,lnbeta(a,b),x);
+}
+
+define __CZ__invbetainc(p,q,beta,alpha){
+  local a acu adj fpu g h iex indx pp prev qq r s sae sq t tx value;
+  local w xin y yprev places eps;
+
+  /* Dirty trick, don't try at home */
+  eps= epsilon(epsilon()^2);
+  sae = -((log(1/epsilon())/log(2))//2);
+  fpu = 10.0^sae;
+
+  places = highbit(1 + int(1/epsilon())) + 1;
+  value = alpha;
+  if( p <= 0.0 ){
+    epsilon(eps);
+    return newerror("invbeta: argument p <= 0");
+  }
+  if( q <= 0.0 ){
+    epsilon(eps);
+    return newerror("invbeta: argument q <= 0");
+  }
+
+  if( alpha < 0.0 || 1.0 < alpha ){
+    epsilon(eps);
+    return newerror("invbeta: argument alpha out of domain");
+  }
+  if( alpha == 0.0 ){
+    epsilon(eps);
+    return 0;
+  }
+  if( alpha == 1.0 ){
+    epsilon(eps);
+    return 1;
+  }
+  if ( 0.5 < alpha ){
+    a = 1.0 - alpha;
+    pp = q;
+    qq = p;
+    indx = 1;
+  }
+  else{
+    a = alpha;
+    pp = p;
+    qq = q;
+    indx = 0;
+  }
+  r = sqrt ( - ln ( a * a ) );
+
+  y = r-(2.30753+0.27061*r)/(1.0+(0.99229+0.04481*r)*r);
+
+  if ( 1.0 < pp && 1.0 < qq ){
+    r = ( y * y - 3.0 ) / 6.0;
+    s = 1.0 / ( pp + pp - 1.0 );
+    t = 1.0 / ( qq + qq - 1.0 );
+    h = 2.0 / ( s + t );
+    w = y*sqrt(h+r)/h-(t-s)*(r+5.0/6.0-2.0/(3.0*h));
+    value = pp / ( pp + qq * exp ( w + w ) );
+  }
+  else{
+    r = qq + qq;
+    t = 1.0 / ( 9.0 * qq );
+    t = r *  ( 1.0 - t + y * sqrt ( t )^ 3 );
+
+    if ( t <= 0.0 ){
+      value = 1.0 - exp ( ( ln ( ( 1.0 - a ) * qq ) + beta ) / qq );
+    }
+    else{
+      t = ( 4.0 * pp + r - 2.0 ) / t;
+
+      if ( t <= 1.0 ) {
+        value = exp ( ( ln ( a * pp ) + beta ) / pp );
+      }
+      else{
+        value = 1.0 - 2.0 / ( t + 1.0 );
+      }
+    }
+  }
+  r = 1.0 - pp;
+  t = 1.0 - qq;
+  yprev = 0.0;
+  sq = 1.0;
+  prev = 1.0;
+
+  if ( value < 0.0001 )
+    value = 0.0001;
+
+  if ( 0.9999 < value )
+    value = 0.9999;
+
+  acu = 10^sae;
+
+  for ( ; ; ){
+    y = bround(__CZ__ibetaas63( value, pp, qq, beta),places);
+    xin = value;
+    y = bround(exp(ln(y-a)+(beta+r*ln(xin)+t*ln(1.0- xin ) )),places);
+
+    if ( y * yprev <= 0.0 ) {
+      prev = max ( sq, fpu );
+    }
+
+    g = 1.0;
+
+    for ( ; ; ){
+      for ( ; ; ){
+        adj = g * y;
+        sq = adj * adj;
+        if ( sq < prev ){
+          tx = value - adj;
+          if ( 0.0 <= tx && tx <= 1.0 )  break;
+        }
+        g = g / 3.0;
+      }
+      if ( prev <= acu ){
+        if ( indx )
+          value = 1.0 - value;
+        epsilon(eps);
+        return value;
+      }
+      if ( y * y <= acu ){
+        if ( indx )
+          value = 1.0 - value;
+        epsilon(eps);
+        return value;
+      }
+      if ( tx != 0.0 && tx != 1.0 )
+        break;
+      g = g / 3.0;
+    }
+    if ( tx == value )  break;
+    value = tx;
+    yprev = y;
+  }
+  if ( indx )
+    value = 1.0 - value;
+
+  epsilon(eps);
+  return value;
+}
+
+/*******************************************************************************
+ *
+ *
+ *                Beta distribution
+ *
+ *
+ ******************************************************************************/
+
+define betapdf(x,a,b){
+  if(x<0 || x>1) return newerror("betapdf: parameter x out of domain");
+  if(a<=0) return newerror("betapdf: parameter a out of domain");
+  if(b<=0) return newerror("betapdf: parameter b out of domain");
+
+  return 1/beta(a,b) *x^(a-1)*(1-x)^(b-1);
+}
+
+define betacdf(x,a,b){
+  if(x<0 || x>1) return newerror("betacdf: parameter x out of domain");
+  if(a<=0) return newerror("betacdf: parameter a out of domain");
+  if(b<=0) return newerror("betacdf: parameter b out of domain");
+
+  return betainc(x,a,b);
+}
+
+define betacdfinv(x,a,b){
+  return invbetainc(x,a,b);
+}
+
+define betamedian(a,b){
+  local t106 t104 t103 t105 approx ret;
+  if(a == b) return 1/2;
+  if(a == 1 && b > 0) return 1-(1/2)^(1/b);
+  if(a > 0 && b == 1) return   (1/2)^(1/a);
+  if(a == 3 && b == 2){
+    /* Yes, the author is not ashamed to ask Maxima for the exact solution
+       of a quartic equation. */
+    t103 = ( (2^(3/2))/27 +4/27  )^(1/3);
+    t104 = sqrt( ( 9*t103^2 + 4*t103 + 2  )/(t103)  )/3;
+    t105 = -t103-2/(9*t103) +8/9;
+    t106 = sqrt( (27*t104*t105+16)/(t104)  )/(2*3^(3/2));
+    return -t106+t104/2+1/3;
+  }
+  if(a == 2 && b == 3){
+    t103 = ( (2^(3/2))/27 +4/27  )^(1/3);
+    t104 = sqrt( ( 9*t103^2 + 4*t103 + 2  )/(t103)  )/3;
+    t105 = -t103-2/(9*t103) +8/9;
+    t106 = sqrt( (27*t104*t105+16)/(t104)  )/(2*3^(3/2));
+    return 1-(-t106+t104/2+1/3);
+  }
+  return invbetainc(1/2,a,b);
+}
+
+define betamode(a,b){
+  if(a + b == 2) return newerror("betamod: a + b = 2 = division by zero");
+  return (a-1)/(a+b-2);
+}
+
+define betavariance(a,b){
+  return (a*b)/( (a+b)^2*(a+b+1) );
+}
+
+define betalnvariance(a,b){
+  return polygamma(1,a)-polygamma(a+b);
+}
+
+define betaskewness(a,b){
+  return (2*(b-a)*sqrt(a+b+1))/( (a+b+1)*sqrt(a*b) );
+}
+
+define betakurtosis(a,b){
+  local num denom;
+
+  num = 6*( (a-b)^2*(a+b+1)-a*b*(a+b+2));
+  denom = a*b*(a+b+2)*(a+b+3);
+  return num/denom;
+}
+
+define betaentropy(a,b){
+  return lnbeta(a,b)-(a-1)*psi(a)-(b-1)*psi(b)+(a+b+1)*psi(a+b);
+
+}
+
+/*******************************************************************************
+ *
+ *
+ *                Normal (Gaussian) distribution
+ *
+ *
+ ******************************************************************************/
+
+
+define normalpdf(x,mu,sigma){
+  return 1/(sqrt(2*pi()*sigma^2))*exp( ( (x-mu)^2 )/( 2*sigma^2 ) );
+}
+
+define normalcdf(x,mu,sigma){
+  return 1/2*(1+erf( ( x-mu )/( sqrt(2*sigma^2) )  )  );
+}
+
+define probit(p){
+  if(p<0 || p > 1) return newerror("probit: p out of domain 0<=p<=1");
+  return sqrt(2)*erfinv(2*p-1);
+}
+
+define normalcdfinv(p,mu,sigma){
+  if(p<0 || p > 1) return newerror("normalcdfinv: p out of domain 0<=p<=1");
+  return mu+ sigma*probit(p);
+}
+
+define normalmean(mu,sigma){return mu;}
+
+define normalmedian(mu,sigma){return mu;}
+
+define normalmode(mu,sigma){return mu;}
+
+define normalvariance(mu,sigma){return sigma^2;}
+
+define normalskewness(mu,sigma){return 0;}
+
+define normalkurtosis(mu,sigma){return 0;}
+
+define normalentropy(mu,sigma){
+  return 1/3*ln( 2*pi()*exp(1)*sigma^2 );
+}
+
+/* moment generating f. */
+define normalmgf(mu,sigma,t){
+  return exp(mu*t+1/2*sigma^2*t^2);
+}
+
+/* characteristic f. */
+define normalcf(mu,sigma,t){
+  return exp(mu*t-1/2*sigma^2*t^2);
+}
+
+
+/*******************************************************************************
+ *
+ *
+ *                Chi-squared distribution
+ *
+ *
+ ******************************************************************************/
+
+define chisquaredpdf(x,k){
+  if(!isint(k) || k<0) return newerror("chisquaredpdf: k not in N");
+  if(im(x) || x<0) return newerror("chisquaredpdf: x not in +R");
+  /* The gamma function does not check for half integers, do it here? */
+  return 1/(2^(k/2)*gamma(k/2))*x^((k/2)-1)*exp(-x/2);
+}
+
+define chisquaredpcdf(x,k){
+  if(!isint(k) || k<0) return newerror("chisquaredcdf: k not in N");
+  if(im(x) || x<0) return newerror("chisquaredcdf: x not in +R");
+
+  return 1/(gamma(k/2))*gammainc(k/2,x/2);
+}
+
+define chisquaredmean(x,k){return k;}
+
+define chisquaredmedian(x,k){
+  /* TODO: implement a FAST inverse incomplete gamma-{q,p} function */
+  return k*(1-2/(9*k))^3;
+}
+
+define chisquaredmode(x,k){return max(k-2,0);}
+define chisquaredvariance(x,k){return 2*k;}
+define chisquaredskewness(x,k){return sqrt(8/k);}
+define chisquaredkurtosis(x,k){return 12/k;}
+define chisquaredentropy(x,k){
+  return k/2+ln(2*gamma(k/2)) + (1-k/2)*psi(k/2);
+}
+
+define chisquaredmfg(k,t){
+  if(t>=1/2)return newerror("chisquaredmfg: t >= 1/2");
+  return (1-2*t)^(k/2);
+}
+
+define chisquaredcf(k,t){
+  return (1-2*1i*t)^(k/2);
+}
+
+
+/*
+ * restore internal function from resource debugging
+ */
+config("resource_debug", resource_debug_level),;
+if (config("resource_debug") & 3) {
+    print "gammaincoctave(z,a)";
+    print "invbetainc(x,a,b)";
+    print "betapdf(x,a,b)";
+    print "betacdf(x,a,b)";
+    print "betacdfinv(x,a,b)";
+    print "betamedian(a,b)";
+    print "betamode(a,b)";
+    print "betavariance(a,b)";
+    print "betalnvariance(a,b)";
+    print "betaskewness(a,b)";
+    print "betakurtosis(a,b)";
+    print "betaentropy(a,b)";
+    print "normalpdf(x,mu,sigma)";
+    print "normalcdf(x,mu,sigma)";
+    print "probit(p)";
+    print "normalcdfinv(p,mu,sigma)";
+    print "normalmean(mu,sigma)";
+    print "normalmedian(mu,sigma)";
+    print "normalmode(mu,sigma)";
+    print "normalvariance(mu,sigma)";
+    print "normalskewness(mu,sigma)";
+    print "normalkurtosis(mu,sigma)";
+    print "normalentropy(mu,sigma)";
+    print "normalmgf(mu,sigma,t)";
+    print "normalcf(mu,sigma,t)";
+    print "chisquaredpdf(x,k)";
+    print "chisquaredpcdf(x,k)";
+    print "chisquaredmean(x,k)";
+    print "chisquaredmedian(x,k)";
+    print "chisquaredmode(x,k)";
+    print "chisquaredvariance(x,k)";
+    print "chisquaredskewness(x,k)";
+    print "chisquaredkurtosis(x,k)";
+    print "chisquaredentropy(x,k)";
+    print "chisquaredmfg(k,t)";
+    print "chisquaredcf(k,t)";
+}
+