add new aversin and acoversin builtin functions.

Added new aversin(x, [,eps]) for inverse versed sine and acoversin(x, [,eps])
for inverse coversed sine.

Improved trig function help files to reference use of complex arguments
that while supported were not documented.

Removed old Makefile testing rules for make dbx and make gdb.

Improved "make run" to execute calccalc using shared libraries
from the local directory, and with reading of the startup scripts
disabled.

Changed "make prep" to perform various tests that are used to
help verify that calc is ready for a release.

Added Makefile testing rule testfuncsort to check for the sort
of the builtin function list.  Changed the order that builtin
functions are listed by "show builtin" and the help/builtin to
match the sorting of "LANG=C LC_ALL=C sort -d -u".

.gitignore

@@ -56,6 +56,8 @@ endian
 endian_calc.h
 fposval
 fposval.h
+func.show
+func.sort
 have_arc4random
 have_arc4random.h
 have_ban_pragma

CHANGES

@@ -100,7 +100,31 @@ The following are the changes from calc version 2.14.3.5 to date:
     the LIMIT range for such eps values.
 
     Added new versin(x, [,eps]) for versed sine and coversin(x, [,eps])
-    for versed cosine.
+    for inverse versed sine.
+
+    Added new aversin(x, [,eps]) for inverse versed sine and acoversin(x, [,eps])
+    for inverse coversed sine.
+
+    Improved trig function help files to reference use of complex arguments
+    that while supported were not documented.
+
+    Removed old Makefile testing rules for make dbx and make gdb.
+
+    Improved "make run" to execute calccalc using shared libraries
+    from the local directory, and with reading of the startup scripts
+    disabled.
+
+    Changed "make prep" to perform various tests that are used to
+    help verify that calc is ready for a release.  Added the
+    update_ver tool, (formerly verupdate) and the trailblank tool
+    that existed outside of the calc source base but neverthless
+    used in the calc release process.  Both of these tools are used
+    by "make prep".
+
+    Added Makefile testing rule "make testfuncsort" to check for
+    the sort of the builtin function list.  Changed the order that
+    builtin functions are listed by "show builtin" and the help/builtin
+    to match the sorting of "LANG=C LC_ALL=C sort -d -u".
 
 
 The following are the changes from calc version 2.14.3.4 to 2.14.3.5:

Makefile

@@ -327,9 +327,18 @@ STATIC_FIRST_TARGETS= ${LICENSE} .static
 LATE_TARGETS= calc.1 calc.usage \
 	      cal/.all help/.all help/builtin cscript/.all
 
+# calc tools - tools used by the maintainers of the calc source base
+#
+# trailblank - find trailing blanks and other file format picky issues
+# update_ver - update version numbers in Makefile.config
+#
+TRAILBLANK= trailblank
+UPDATE_VER= update_ver
+CALC_TOOLS= ${TRAILBLANK} ${UPDATE_VER}
+
 # complete list of targets
 #
-TARGETS= ${EARLY_TARGETS} ${BLD_TYPE} ${LATE_TARGETS}
+TARGETS= ${EARLY_TARGETS} ${BLD_TYPE} ${LATE_TARGETS} ${CALC_TOOLS}
 
 # rules that are not also names of files
 #
@@ -372,9 +381,6 @@ check_include:
 	    exit 1; \
 	fi
 
-prep:
-	${Q} ${MAKE} -f ${MAKE_FILE} all DEBUG='-g3'
-
 calc-dynamic-only: ${DYNAMIC_FIRST_TARGETS} ${EARLY_TARGETS} \
 		   ${CALC_DYNAMIC_LIBS} ${SYM_DYNAMIC_LIBS} calc${EXT} \
 		   ${SAMPLE_TARGETS} ${LATE_TARGETS}
@@ -2979,6 +2985,7 @@ env:
 	@echo 'SAMPLE_STATIC_TARGETS=${SAMPLE_STATIC_TARGETS}'; echo ''
 	@echo 'SAMPLE_TARGETS=${SAMPLE_TARGETS}'; echo ''
 	@echo 'SCRIPTDIR=${SCRIPTDIR}'; echo ''
+	@echo 'SDIFF=${SDIFF}'; echo ''
 	@echo 'SED=${SED}'; echo ''
 	@echo 'SHELL=${SHELL}'; echo ''
 	@echo 'SORT=${SORT}'; echo ''
@@ -3089,27 +3096,82 @@ debug:
 
 ###
 #
-# testing rules
+# maintainer rules - rules that are useful for people who maintain the calc source
 #
-# make run
+# testfuncsort
-#	* only run calc interactively with the ${CALC_ENV} environment
 #
-# make dbx
+#    Check on the sort of the builtin function list.
-#	* run the dbx debugger on calc with the ${CALC_ENV} environment
+#    If the builtins[] array in func.c is in dictionary sorted order,
+#    this rule prints nothing.  If there is a builtin function that
+#    is out of order, sdiff is used to print the builtin function sort
+#    problem and does an exit 1.
 #
-# make gdb
+# prep
-#	* run the gdb debugger on calc with the ${CALC_ENV} environment
+#
+#    Perform tests and build actions that are needed prior to a release
+#    of calc.  The "make prep" should NOT exit non-zero but instead it
+#    should print "All is OK" and exit 0.
+#
+# run
+#
+#    Execute calc using shared libraries from the local directory.
+#    Run calc with reading of the startup scripts disabled.
 #
 ###
 
+testfuncsort: ./calc${EXT}
+	@${RM} -f func.show func.sort
+	@CALCPATH=./cal LD_LIBRARY_PATH=. DYLD_LIBRARY_PATH=. CALCHELP=./help CALCCUSTOMHELP=./custom \
+		./calc${EXT} -d -u show builtin | grep '^[A-Za-z0-9]' > func.show
+	@CALCPATH=./cal LD_LIBRARY_PATH=. DYLD_LIBRARY_PATH=. CALCHELP=./help CALCCUSTOMHELP=./custom \
+		./calc${EXT} -d -u show builtin | grep '^[A-Za-z0-9]' | LANG=C LC_ALL=C ${SORT} -d -u > func.sort
+	@-if ! cmp -s func.show func.sort; then \
+	    echo 1>&2; \
+	    echo "ERROR: builtins[] arrray in func.c is not in dictionary sorted order" 1>&2; \
+	    echo 1>&2; \
+	    echo "CALCPATH=./cal LD_LIBRARY_PATH=. DYLD_LIBRARY_PATH=. CALCHELP=./help CALCCUSTOMHELP=./custom" \
+		 "./calc${EXT} -d -u show builtin | grep '^[A-Za-z0-9]' > func.show" 1>&2; \
+	    echo "CALCPATH=./cal LD_LIBRARY_PATH=. DYLD_LIBRARY_PATH=. CALCHELP=./help CALCCUSTOMHELP=./custom" \
+		 "./calc${EXT} -d -u show builtin | grep '^[A-Za-z0-9]' | LANG=C LC_ALL=C ${SORT} -d -u > func.sort" 1>&2; \
+	    echo 1>&2; \
+	    echo ${SDIFF} func.show func.sort 1>&2; \
+	    echo 1>&2; \
+	    ${SDIFF} func.show func.sort 1>&2; \
+	    exit 1; \
+	fi
+	@${RM} -f func.show func.sort
+
+prep:
+	echo '=-=-= start of ${MAKE} clobber =-=-='
+	${MAKE} clobber
+	echo '=-=-= end of ${MAKE} clobber =-=-='
+	echo '=-=-= start of ${TRAILBLANK} =-=-='
+	./${TRAILBLANK}
+	echo '=-=-= end of ${TRAILBLANK} =-=-='
+	echo '=-=-= start of ${MAKE} all CCWERR=-Werror =-=-='
+	${MAKE} all CCWERR=-Werror
+	echo '=-=-= end of ${MAKE} all CCWERR=-Werror =-=-='
+	echo '=-=-= start of ${MAKE} tags =-=-='
+	${MAKE} tags
+	echo '=-=-= end of ${MAKE} tags =-=-='
+	echo '=-=-= start of ${MAKE} depend =-=-='
+	${MAKE} depend
+	echo '=-=-= end of ${MAKE} depend =-=-='
+	echo '=-=-= start of ${MAKE} testfuncsort =-=-='
+	${MAKE} testfuncsort
+	echo '=-=-= end of ${MAKE} testfuncsort =-=-='
+	echo '=-=-= start of ${UPDATE_VER} =-=-='
+	./${UPDATE_VER}
+	echo '=-=-= end of ${UPDATE_VER} =-=-='
+	echo '=-=-= start of ${MAKE} chk =-=-='
+	${MAKE} chk
+	echo '=-=-= end of ${MAKE} chk =-=-='
+	@echo
+	@echo All is OK
+	@echo
+
 run:
-	${CALC_ENV} ./calc${EXT}
+	CALCPATH=./cal LD_LIBRARY_PATH=. DYLD_LIBRARY_PATH=. CALCHELP=./help CALCCUSTOMHELP=./custom ./calc${EXT} -q
-
-dbx:
-	${CALC_ENV} dbx ./calc${EXT}
-
-gdb:
-	${CALC_ENV} gdb ./calc${EXT}
 
 ###
 #
@@ -3329,6 +3391,7 @@ clobber: clean
 	    echo ${RM} -rf .DS_Store; \
 	    ${RM} -rf .DS_Store; \
 	fi
+	${RM} -f func.show func.sort
 	${V} echo '=-=-=-=-= ${MAKE_FILE} end of $@ rule =-=-=-=-='
 
 # install everything

Makefile.config

@@ -1302,6 +1302,7 @@ MV= mv
 PWDCMD= pwd
 RM= rm
 RMDIR= rmdir
+SDIFF= sdiff
 SED= sed
 SORT= sort
 SPLINT= splint

cal/regress.cal

@@ -3507,7 +3507,7 @@ define test_trig()
 	tnum = test3400(1, 3401);
 	vrfy(tnum++ == 3407,	'3407: tnum == 3407');
 
-	/* test versed sine */
+	/* test versed trigonometric sine */
 	pi = pi(1e-20);
 	vrfy(round(versin(0.2, 1e-10), 10) == 0.0199334222,
 	    strcat(str(tnum++),
@@ -3533,7 +3533,7 @@ define test_trig()
 	    strcat(str(tnum++),
 		   ': round(versin(2 + 3i, 1e-10), 10) == 5.189625691+9.1092278938i'));
 
-	/* test coversed sine */
+	/* test coversed trigonometric sine */
 	pi = pi(1e-20);
 	vrfy(round(coversin(0.2, 1e-10), 10) == 0.8013306692,
 	    strcat(str(tnum++),
@@ -3559,6 +3559,32 @@ define test_trig()
 	    strcat(str(tnum++),
 		   ': round(coversin(2 + 3i, 1e-10), 10) == -8.1544991469+4.16890696i'));
 
+	/* test inverse versed trigonometric sine */
+	vrfy(round(aversin(0.5, 1e-10), 10) == 1.0471975512,
+	    strcat(str(tnum++),
+		   ': round(aversin(0.5, 1e-10), 10) == 1.0471975512'));
+	vrfy(aversin(0) == 0,
+		    strcat(str(tnum++), ': aversin(0) == 0'));
+	vrfy(round(aversin(-5, 1e-10), 10) == 0.1673829554+2.4921599676i,
+	    strcat(str(tnum++),
+		   ': round(aversin(0.5, 1e-10), 10) == 0.1673829554+2.4921599676i'));
+	vrfy(round(aversin(2 + 3i, 1e-10), 10) == 1.8783999763+1.8641615439i,
+	    strcat(str(tnum++),
+		   ': round(aversin(2 + 3i, 1e-10), 10) == 1.8783999763+1.8641615439i'));
+
+	/* test inverse coversed trigonometric sine */
+	vrfy(round(acoversin(0.5, 1e-10), 10) == 0.5235987756,
+	    strcat(str(tnum++),
+		   ': round(acoversin(0.5, 1e-10), 10) == 0.5235987756'));
+	vrfy(acoversin(1) == 0,
+		    strcat(str(tnum++), ': acoversin(1) == 0'));
+	vrfy(round(acoversin(-5, 1e-10), 10) == 1.4034133718-2.4921599681i,
+	    strcat(str(tnum++),
+		   ': round(acoversin(0.5, 1e-10), 10) == 1.4034133718-2.4921599681i'));
+	vrfy(round(acoversin(2 + 3i, 1e-10), 10) == -0.3076036495-1.8641615442i,
+	    strcat(str(tnum++),
+		   ': round(acoversin(2 + 3i, 1e-10), 10) == -0.3076036495-1.8641615442i'));
+
 	print strcat(str(tnum++), ': Ending test_trig');
 }
 print '051: parsed test_trig()';

calcerr.tbl

@@ -553,6 +553,12 @@ E_LOGN_5	Non-numeric second argument for logn
 E_VERSIN1	Bad epsilon for versin
 E_VERSIN2	Bad first argument for versin
 E_VERSIN3	Too-large im(argument) for versin
+E_AVERSIN1	Bad epsilon for aversin
+E_AVERSIN2	Bad first argument for aversin
+E_AVERSIN3	Too-large im(argument) for aversin
 E_COVERSIN1	Bad epsilon for coversin
 E_COVERSIN2	Bad first argument for coversin
 E_COVERSIN3	Too-large im(argument) for coversin
+E_ACOVERSIN1	Bad epsilon for acoversin
+E_ACOVERSIN2	Bad first argument for acoversin
+E_ACOVERSIN3	Too-large im(argument) for acoversin

cmath.h

@@ -123,7 +123,9 @@ E_FUNC COMPLEX *c_agd(COMPLEX *c, NUMBER *epsilon);
  * historical trig functions
  */
 E_FUNC COMPLEX *c_versin(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_aversin(COMPLEX *c, NUMBER *epsilon);
 E_FUNC COMPLEX *c_coversin(COMPLEX *c, NUMBER *epsilon);
+E_FUNC COMPLEX *c_acoversin(COMPLEX *c, NUMBER *epsilon);
 
 
 

comfunc.c

@@ -1355,12 +1355,12 @@ c_versin(COMPLEX *c, NUMBER *epsilon)
 		not_reached();
 	}
 	if (check_epsilon(epsilon) == false) {
-		math_error("Invalid epsilon value for complex versin");
+		math_error("Invalid epsilon arg for %s", __func__);
 		not_reached();
 	}
 
 	/*
-	 * return r = 1 - cos(x)
+	 * calculate complex trig function value
 	 */
 	ctmp = c_cos(c, epsilon);
 	if (ctmp == NULL) {
@@ -1368,11 +1368,61 @@ c_versin(COMPLEX *c, NUMBER *epsilon)
 		not_reached();
 	}
 	r = c_sub(&_cone_, ctmp);
+
+	/*
+	 * return complex 1 - cos(x)
+	 */
 	comfree(ctmp);
 	return r;
 }
 
 
+/*
+ * c_aversin - inverse versed sine for COMPLEX values
+ *
+ * This uses the formula:
+ *
+ *	aversin(x) = acos(1 - x)
+ *
+ * given:
+ *	q	    complex value to pass to the trig function
+ *	epsilon	    error tolerance / precision for trig calculation
+ *
+ * returns:
+ *	complex value result of trig function on q with error epsilon
+ */
+COMPLEX *
+c_aversin(COMPLEX *c, NUMBER *epsilon)
+{
+	COMPLEX *r;	/* inverse trig value result */
+	COMPLEX *x;	/* argument to inverse trig function */
+
+	/*
+	 * firewall
+	 */
+	if (c == NULL) {
+		math_error("%s: c is NULL", __func__);
+		not_reached();
+	}
+	if (check_epsilon(epsilon) == false) {
+		math_error("Invalid epsilon arg for %s", __func__);
+		not_reached();
+	}
+
+	/*
+	 * calculate complex inverse trig function value
+	 */
+	x = c_sub(&_cone_, c);
+	r = c_acos(x, epsilon);
+	comfree(x);
+
+	/*
+	 * return complex acos(1 - x)
+	 */
+	return r;
+}
+
+
 /*
  * c_coversin - coversed sine for COMPLEX values
  *
@@ -1401,12 +1451,12 @@ c_coversin(COMPLEX *c, NUMBER *epsilon)
 		not_reached();
 	}
 	if (check_epsilon(epsilon) == false) {
-		math_error("Invalid epsilon value for complex coversin");
+		math_error("Invalid epsilon arg for %s", __func__);
 		not_reached();
 	}
 
 	/*
-	 * return r = 1 - sin(x)
+	 * calculate complex trig function value
 	 */
 	ctmp = c_sin(c, epsilon);
 	if (ctmp == NULL) {
@@ -1414,6 +1464,56 @@ c_coversin(COMPLEX *c, NUMBER *epsilon)
 		not_reached();
 	}
 	r = c_sub(&_cone_, ctmp);
+
+	/*
+	 * return complex 1 - sin(x)
+	 */
 	comfree(ctmp);
 	return r;
 }
+
+
+/*
+ * c_acoversin - inverse versed sine for COMPLEX values
+ *
+ * This uses the formula:
+ *
+ *	acoversin(x) = asin(1 - x)
+ *
+ * given:
+ *	q	    complex value to pass to the trig function
+ *	epsilon	    error tolerance / precision for trig calculation
+ *
+ * returns:
+ *	complex value result of trig function on q with error epsilon
+ */
+COMPLEX *
+c_acoversin(COMPLEX *c, NUMBER *epsilon)
+{
+	COMPLEX *r;	/* inverse trig value result */
+	COMPLEX *x;	/* argument to inverse trig function */
+
+	/*
+	 * firewall
+	 */
+	if (c == NULL) {
+		math_error("%s: c is NULL", __func__);
+		not_reached();
+	}
+	if (check_epsilon(epsilon) == false) {
+		math_error("Invalid epsilon arg for %s", __func__);
+		not_reached();
+	}
+
+	/*
+	 * calculate complex inverse trig function value
+	 */
+	x = c_sub(&_cone_, c);
+	r = c_asin(x, epsilon);
+	comfree(x);
+
+	/*
+	 * return complex asin(1 - x)
+	 */
+	return r;
+}

func.c

@@ -10641,7 +10641,7 @@ f_versin(int count, VALUE **vals)
 	}
 
 	/*
-	 * compute sine to a given error tolerance
+	 * compute trig function to a given error tolerance
 	 */
 	switch (vals[0]->v_type) {
 		case V_NUM:
@@ -10655,6 +10655,10 @@ f_versin(int count, VALUE **vals)
 			}
 			result.v_com = c;
 			result.v_type = V_COM;
+
+			/*
+			 * case: complex trig function returned real, convert result to NUMBER
+			 */
 			if (cisreal(c)) {
 				result.v_num = qlink(c->real);
 				result.v_type = V_NUM;
@@ -10668,6 +10672,88 @@ f_versin(int count, VALUE **vals)
 }
 
 
+/*
+ * f_aversin - inverse versed sine
+ */
+S_FUNC VALUE
+f_aversin(int count, VALUE **vals)
+{
+	VALUE result;
+	COMPLEX *c;
+	NUMBER *eps;
+
+	/* initialize VALUE */
+	result.v_subtype = V_NOSUBTYPE;
+
+	/*
+	 * set error tolerance for builtin function
+	 *
+	 * Use eps VALUE arg if given and value is in a valid range.
+	 */
+	eps = conf->epsilon;
+	if (count == 2) {
+		if (verify_eps(vals[1]) == false) {
+			return error_value(E_AVERSIN1);
+		}
+		eps = vals[1]->v_num;
+	}
+
+	/*
+	 * compute inverse trig function to a given error tolerance
+	 */
+	if (vals[0]->v_type == V_NUM) {
+
+		/* try to compute result using real triv function */
+		result.v_num = qaversin_or_NULL(vals[0]->v_num, eps);
+
+		/*
+		 * case: trig function returned a NUMBER
+		 */
+		if (result.v_num != NULL) {
+			result.v_type = V_NUM;
+
+		/*
+		 * case: trig function returned NULL - need to try COMPLEX trig function
+		 */
+		} else {
+			/* convert NUMBER argument from NUMBER to COMPLEX */
+			vals[0]->v_com = qqtoc(vals[0]->v_num, &_qone_);
+			vals[0]->v_type = V_COM;
+		}
+	}
+	if (vals[0]->v_type == V_COM) {
+
+		/*
+		 * case: argument was COMPLEX or
+		 *	 trig function returned NULL and argument was converted to COMPLEX
+		 */
+		c = c_aversin(vals[0]->v_com, eps);
+		if (c == NULL) {
+			return error_value(E_AVERSIN3);
+		}
+		result.v_com = c;
+		result.v_type = V_COM;
+
+		/*
+		 * case: complex trig function returned real, convert result to NUMBER
+		 */
+		if (cisreal(c)) {
+			result.v_num = qlink(c->real);
+			result.v_type = V_NUM;
+			comfree(c);
+		}
+	}
+	if (vals[0]->v_type != V_NUM && vals[0]->v_type != V_COM) {
+
+		/*
+		 * case: argument type is not valid for this function
+		 */
+		return error_value(E_AVERSIN2);
+	}
+	return result;
+}
+
+
 /*
  * f_coversin - coversed sine
  */
@@ -10695,7 +10781,7 @@ f_coversin(int count, VALUE **vals)
 	}
 
 	/*
-	 * compute cosinr to a given error tolerance
+	 * compute trig function to a given error tolerance
 	 */
 	switch (vals[0]->v_type) {
 		case V_NUM:
@@ -10709,6 +10795,10 @@ f_coversin(int count, VALUE **vals)
 			}
 			result.v_com = c;
 			result.v_type = V_COM;
+
+			/*
+			 * case: complex trig function returned real, convert result to NUMBER
+			 */
 			if (cisreal(c)) {
 				result.v_num = qlink(c->real);
 				result.v_type = V_NUM;
@@ -10722,6 +10812,88 @@ f_coversin(int count, VALUE **vals)
 }
 
 
+/*
+ * f_acoversin - inverse coversed sine
+ */
+S_FUNC VALUE
+f_acoversin(int count, VALUE **vals)
+{
+	VALUE result;
+	COMPLEX *c;
+	NUMBER *eps;
+
+	/* initialize VALUE */
+	result.v_subtype = V_NOSUBTYPE;
+
+	/*
+	 * set error tolerance for builtin function
+	 *
+	 * Use eps VALUE arg if given and value is in a valid range.
+	 */
+	eps = conf->epsilon;
+	if (count == 2) {
+		if (verify_eps(vals[1]) == false) {
+			return error_value(E_ACOVERSIN1);
+		}
+		eps = vals[1]->v_num;
+	}
+
+	/*
+	 * compute inverse trig function to a given error tolerance
+	 */
+	if (vals[0]->v_type == V_NUM) {
+
+		/* try to compute result using real triv function */
+		result.v_num = qacoversin_or_NULL(vals[0]->v_num, eps);
+
+		/*
+		 * case: trig function returned a NUMBER
+		 */
+		if (result.v_num != NULL) {
+			result.v_type = V_NUM;
+
+		/*
+		 * case: trig function returned NULL - need to try COMPLEX trig function
+		 */
+		} else {
+			/* convert NUMBER argument from NUMBER to COMPLEX */
+			vals[0]->v_com = qqtoc(vals[0]->v_num, &_qone_);
+			vals[0]->v_type = V_COM;
+		}
+	}
+	if (vals[0]->v_type == V_COM) {
+
+		/*
+		 * case: argument was COMPLEX or
+		 *	 trig function returned NULL and argument was converted to COMPLEX
+		 */
+		c = c_acoversin(vals[0]->v_com, eps);
+		if (c == NULL) {
+			return error_value(E_ACOVERSIN3);
+		}
+		result.v_com = c;
+		result.v_type = V_COM;
+
+		/*
+		 * case: complex trig function returned real, convert result to NUMBER
+		 */
+		if (cisreal(c)) {
+			result.v_num = qlink(c->real);
+			result.v_type = V_NUM;
+			comfree(c);
+		}
+	}
+	if (vals[0]->v_type != V_NUM && vals[0]->v_type != V_COM) {
+
+		/*
+		 * case: argument type is not valid for this function
+		 */
+		return error_value(E_ACOVERSIN2);
+	}
+	return result;
+}
+
+
 #endif /* !FUNCLIST */
 
 
@@ -10767,15 +10939,17 @@ STATIC CONST struct builtin builtins[] = {
 	{"access", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_access},
 	 "determine accessibility of file a for mode b"},
 	{"acos", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_acos},
-	 "arccosine of a within accuracy b"},
+	 "inverse cosine of a within accuracy b"},
 	{"acosh", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_acosh},
 	 "inverse hyperbolic cosine of a within accuracy b"},
 	{"acot", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_acot},
-	 "arccotangent of a within accuracy b"},
+	 "inverse cotangent of a within accuracy b"},
 	{"acoth", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_acoth},
 	 "inverse hyperbolic cotangent of a within accuracy b"},
+	{"acoversin", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_acoversin},
+	 "inverse coversed sine of a within accuracy b"},
 	{"acsc", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_acsc},
-	 "arccosecant of a within accuracy b"},
+	 "inverse cosecant of a within accuracy b"},
 	{"acsch", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_acsch},
 	 "inverse csch of a within accuracy b"},
 	{"agd", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_agd},
@@ -10789,21 +10963,23 @@ STATIC CONST struct builtin builtins[] = {
 	{"argv", 0, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_argv},
 	 "calc argc or argv string"},
 	{"asec", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_asec},
-	 "arcsecant of a within accuracy b"},
+	 "inverse secant of a within accuracy b"},
 	{"asech", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_asech},
 	 "inverse hyperbolic secant of a within accuracy b"},
 	{"asin", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_asin},
-	 "arcsine of a within accuracy b"},
+	 "inverse sine of a within accuracy b"},
 	{"asinh", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_asinh},
 	 "inverse hyperbolic sine of a within accuracy b"},
 	{"assoc", 0, 0, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_assoc},
 	 "create new association array"},
 	{"atan", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_atan},
-	 "arctangent of a within accuracy b"},
+	 "inverse tangent of a within accuracy b"},
 	{"atan2", 2, 3, FE, OP_NOP, {.numfunc_3 = qatan2}, {.null = NULL},
 	 "angle to point (b,a) within accuracy c"},
 	{"atanh", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_atanh},
 	 "inverse hyperbolic tangent of a within accuracy b"},
+	{"aversin", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_aversin},
+	 "inverse versed sine of a within accuracy b"},
 	{"avg", 0, IN, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_avg},
 	 "arithmetic mean of values"},
 	{"base", 0, 1, 0, OP_NOP, {.numfunc_cnt = f_base}, {.null = NULL},
@@ -10826,12 +11002,12 @@ STATIC CONST struct builtin builtins[] = {
 	 "round value a to b number of binary places"},
 	{"btrunc", 1, 2, 0, OP_NOP, {.numfunc_cnt = f_btrunc}, {.null = NULL},
 	 "truncate a to b number of binary places"},
-	{"calc_tty", 0, 0, 0, OP_NOP, {.null = NULL}, {.valfunc_0 = f_calc_tty},
-	 "set tty for interactivity"},
 	{"calclevel", 0, 0, 0, OP_NOP, {.null = NULL}, {.valfunc_0 = f_calclevel},
 	 "current calculation level"},
 	{"calcpath", 0, 0, 0, OP_NOP, {.null = NULL}, {.valfunc_0 = f_calcpath},
 	 "current CALCPATH search path value"},
+	{"calc_tty", 0, 0, 0, OP_NOP, {.null = NULL}, {.valfunc_0 = f_calc_tty},
+	 "set tty for interactivity"},
 	{"catalan", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_catalan},
 	 "catalan number for index a"},
 	{"ceil", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_ceil},
@@ -10921,20 +11097,14 @@ STATIC CONST struct builtin builtins[] = {
 	 "evaluate expression from string to value"},
 	{"exp", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_exp},
 	 "exponential of value a within accuracy b"},
-	{"factor", 1, 3, 0, OP_NOP, {.numfunc_cnt = f_factor}, {.null = NULL},
-	 "lowest prime factor < b of a, return c if error"},
-	{"fcnt", 2, 2, 0, OP_NOP, {.numfunc_2 = f_faccnt}, {.null = NULL},
-	 "count of times one number divides another"},
-	{"fib", 1, 1, 0, OP_NOP, {.numfunc_1 = qfib}, {.null = NULL},
-	 "Fibonacci number F(n)"},
-	{"forall", 2, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_2 = f_forall},
-	 "do function for all elements of list or matrix"},
-	{"frem", 2, 2, 0, OP_NOP, {.numfunc_2 = qfacrem}, {.null = NULL},
-	 "number with all occurrences of factor removed"},
 	{"fact", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_fact},
 	 "factorial"},
+	{"factor", 1, 3, 0, OP_NOP, {.numfunc_cnt = f_factor}, {.null = NULL},
+	 "lowest prime factor < b of a, return c if error"},
 	{"fclose", 0, IN, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_fclose},
 	 "close file"},
+	{"fcnt", 2, 2, 0, OP_NOP, {.numfunc_2 = f_faccnt}, {.null = NULL},
+	 "count of times one number divides another"},
 	{"feof", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_feof},
 	 "whether EOF reached for file"},
 	{"ferror", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_ferror},
@@ -10954,12 +11124,16 @@ STATIC CONST struct builtin builtins[] = {
 	{"fgetstr", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_fgetstr},
 	 "read next null-terminated string from file, null\n"
 	 "\t\t\tcharacter is kept"},
+	{"fib", 1, 1, 0, OP_NOP, {.numfunc_1 = qfib}, {.null = NULL},
+	 "Fibonacci number F(n)"},
 	{"files", 0, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_files},
 	 "return opened file or max number of opened files"},
 	{"floor", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_floor},
 	 "greatest integer less than or equal to number"},
 	{"fopen", 2, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_2 = f_fopen},
 	 "open file name a in mode b"},
+	{"forall", 2, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_2 = f_forall},
+	 "do function for all elements of list or matrix"},
 	{"fpathopen", 2, 3, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_fpathopen},
 	 "open file name a in mode b, search for a along\n"
 	 "\t\t\tCALCPATH or path c"},
@@ -10971,6 +11145,8 @@ STATIC CONST struct builtin builtins[] = {
 	 "write one or more strings to a file"},
 	{"fputstr", 2, IN, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_fputstr},
 	 "write one or more null-terminated strings to a file"},
+	{"frac", 1, 1, 0, OP_FRAC, {.numfunc_1 = qfrac}, {.null = NULL},
+	 "fractional part of value"},
 	{"free", 0, IN, FA, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_free},
 	 "free listed or all global variables"},
 	{"freebernoulli", 0, 0, 0, OP_NOP, {.null = NULL}, {.valfunc_0 = f_freebern},
@@ -10983,6 +11159,8 @@ STATIC CONST struct builtin builtins[] = {
 	 "free redc data cache"},
 	{"freestatics", 0, 0, 0, OP_NOP, {.null = NULL}, {.valfunc_0 = f_freestatics},
 	 "free all un-scoped static variables"},
+	{"frem", 2, 2, 0, OP_NOP, {.numfunc_2 = qfacrem}, {.null = NULL},
+	 "number with all occurrences of factor removed"},
 	{"freopen", 2, 3, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_freopen},
 	 "reopen a file stream to a named file"},
 	{"fscan", 2, IN, FA, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_fscan},
@@ -10997,8 +11175,6 @@ STATIC CONST struct builtin builtins[] = {
 	 "return the size of the file"},
 	{"ftell", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_ftell},
 	 "return the file position"},
-	{"frac", 1, 1, 0, OP_FRAC, {.numfunc_1 = qfrac}, {.null = NULL},
-	 "fractional part of value"},
 	{"g2d", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_g2d},
 	 "convert gradians to degrees"},
 	{"g2gm", 3, 4, FA, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_g2gm},
@@ -11032,22 +11208,22 @@ STATIC CONST struct builtin builtins[] = {
 	 "high bit number in base 2 representation"},
 	{"hm2h", 2, 3, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_hm2h},
 	 "convert a hours, b min to hours, rounding type c\n"},
-	{"hms2h", 3, 4, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_hms2h},
-	 "convert a hours, b min, c sec to hours, rounding type d\n"},
 	{"hmean", 0, IN, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_hmean},
 	 "harmonic mean of values"},
+	{"hms2h", 3, 4, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_hms2h},
+	 "convert a hours, b min, c sec to hours, rounding type d\n"},
 	{"hnrmod", 4, 4, 0, OP_NOP, {.numfunc_4 = f_hnrmod}, {.null = NULL},
 	 "v mod h*2^n+r, h>0, n>0, r  =  -1, 0 or 1"},
 	{"hypot", 2, 3, FE, OP_NOP, {.numfunc_3 = qhypot}, {.null = NULL},
 	 "hypotenuse of right triangle within accuracy c"},
 	{"ilog", 2, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_2 = f_ilog},
 	 "integral log of a to integral base b"},
-	{"ilogn", 2, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_2 = f_ilog},
-	 "same is ilog"},
 	{"ilog10", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_ilog10},
 	 "integral log of a number base 10"},
 	{"ilog2", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_ilog2},
 	 "integral log of a number base 2"},
+	{"ilogn", 2, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_2 = f_ilog},
+	 "same is ilog"},
 	{"im", 1, 1, 0, OP_IM, {.null = NULL}, {.null = NULL},
 	 "imaginary part of complex number"},
 	{"indices", 2, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_2 = f_indices},
@@ -11062,22 +11238,32 @@ STATIC CONST struct builtin builtins[] = {
 	 "multiplicative inverse of value"},
 	{"iroot", 2, 2, 0, OP_NOP, {.numfunc_2 = qiroot}, {.null = NULL},
 	 "integer b'th root of a"},
+	{"isalnum", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isalnum},
+	 "whether character is alpha-numeric"},
+	{"isalpha", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isalpha},
+	 "whether character is alphabetic"},
 	{"isassoc", 1, 1, 0, OP_ISASSOC, {.null = NULL}, {.null = NULL},
 	 "whether a value is an association"},
 	{"isatty", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isatty},
 	 "whether a file is a tty"},
 	{"isblk", 1, 1, 0, OP_ISBLK, {.null = NULL}, {.null = NULL},
 	 "whether a value is a block"},
+	{"iscntrl", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_iscntrl},
+	 "whether character is a control character"},
 	{"isconfig", 1, 1, 0, OP_ISCONFIG, {.null = NULL}, {.null = NULL},
 	 "whether a value is a config state"},
 	{"isdefined", 1, 1, 0, OP_ISDEFINED, {.null = NULL}, {.null = NULL},
 	 "whether a string names a function"},
+	{"isdigit", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isdigit},
+	 "whether character is a digit"},
 	{"iserror", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_iserror},
 	 "where a value is an error"},
 	{"iseven", 1, 1, 0, OP_ISEVEN, {.null = NULL}, {.null = NULL},
 	 "whether a value is an even integer"},
 	{"isfile", 1, 1, 0, OP_ISFILE, {.null = NULL}, {.null = NULL},
 	 "whether a value is a file"},
+	{"isgraph", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isgraph},
+	 "whether character is a graphical character"},
 	{"ishash", 1, 1, 0, OP_ISHASH, {.null = NULL}, {.null = NULL},
 	 "whether a value is a hash state"},
 	{"isident", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isident},
@@ -11086,6 +11272,8 @@ STATIC CONST struct builtin builtins[] = {
 	 "whether a value is an integer"},
 	{"islist", 1, 1, 0, OP_ISLIST, {.null = NULL}, {.null = NULL},
 	 "whether a value is a list"},
+	{"islower", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_islower},
+	 "whether character is lower case"},
 	{"ismat", 1, 1, 0, OP_ISMAT, {.null = NULL}, {.null = NULL},
 	 "whether a value is a matrix"},
 	{"ismult", 2, 2, 0, OP_NOP, {.numfunc_2 = f_ismult}, {.null = NULL},
@@ -11098,14 +11286,18 @@ STATIC CONST struct builtin builtins[] = {
 	 "whether a value is an object"},
 	{"isobjtype", 1, 1, 0, OP_ISOBJTYPE, {.null = NULL}, {.null = NULL},
 	 "whether a string names an object type"},
-	{"isodd", 1, 1, 0, OP_ISODD, {.null = NULL}, {.null = NULL},
-	 "whether a value is an odd integer"},
 	{"isoctet", 1, 1, 0, OP_ISOCTET, {.null = NULL}, {.null = NULL},
 	 "whether a value is an octet"},
+	{"isodd", 1, 1, 0, OP_ISODD, {.null = NULL}, {.null = NULL},
+	 "whether a value is an odd integer"},
 	{"isprime", 1, 2, 0, OP_NOP, {.numfunc_cnt = f_isprime}, {.null = NULL},
 	 "whether a is a small prime, return b if error"},
+	{"isprint", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isprint},
+	 "whether character is printable"},
 	{"isptr", 1, 1, 0, OP_ISPTR, {.null = NULL}, {.null = NULL},
 	 "whether a value is a pointer"},
+	{"ispunct", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_ispunct},
+	 "whether character is a punctuation"},
 	{"isqrt", 1, 1, 0, OP_NOP, {.numfunc_1 = qisqrt}, {.null = NULL},
 	 "integer part of square root"},
 	{"isrand", 1, 1, 0, OP_ISRAND, {.null = NULL}, {.null = NULL},
@@ -11116,14 +11308,20 @@ STATIC CONST struct builtin builtins[] = {
 	 "whether a value is a real number"},
 	{"isrel", 2, 2, 0, OP_NOP, {.numfunc_2 = f_isrel}, {.null = NULL},
 	 "whether two numbers are relatively prime"},
-	{"isstr", 1, 1, 0, OP_ISSTR, {.null = NULL}, {.null = NULL},
-	 "whether a value is a string"},
 	{"issimple", 1, 1, 0, OP_ISSIMPLE, {.null = NULL}, {.null = NULL},
 	 "whether value is a simple type"},
+	{"isspace", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isspace},
+	 "whether character is a space character"},
 	{"issq", 1, 1, 0, OP_NOP, {.numfunc_1 = f_issquare}, {.null = NULL},
 	 "whether or not number is a square"},
+	{"isstr", 1, 1, 0, OP_ISSTR, {.null = NULL}, {.null = NULL},
+	 "whether a value is a string"},
 	{"istype", 2, 2, 0, OP_ISTYPE, {.null = NULL}, {.null = NULL},
 	 "whether the type of a is same as the type of b"},
+	{"isupper", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isupper},
+	 "whether character is upper case"},
+	{"isxdigit", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isxdigit},
+	 "whether character is a hexadecimal digit"},
 	{"jacobi", 2, 2, 0, OP_NOP, {.numfunc_2 = qjacobi}, {.null = NULL},
 	 "-1  = > a is not quadratic residue mod b\n"
 	 "\t\t\t1  = > b is composite, or a is quad residue of b"},
@@ -11203,37 +11401,11 @@ STATIC CONST struct builtin builtins[] = {
 	 "numerator of fraction"},
 	{"ord", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_ord},
 	 "integer corresponding to character value"},
-	{"isupper", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isupper},
-	 "whether character is upper case"},
-	{"islower", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_islower},
-	 "whether character is lower case"},
-	{"isalnum", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isalnum},
-	 "whether character is alpha-numeric"},
-	{"isalpha", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isalpha},
-	 "whether character is alphabetic"},
-	{"iscntrl", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_iscntrl},
-	 "whether character is a control character"},
-	{"isdigit", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isdigit},
-	 "whether character is a digit"},
-	{"isgraph", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isgraph},
-	 "whether character is a graphical character"},
-	{"isprint", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isprint},
-	 "whether character is printable"},
-	{"ispunct", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_ispunct},
-	 "whether character is a punctuation"},
-	{"isspace", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isspace},
-	 "whether character is a space character"},
-	{"isxdigit", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_isxdigit},
-	 "whether character is a hexadecimal digit"},
 	{"param", 1, 1, 0, OP_ARGVALUE, {.null = NULL}, {.null = NULL},
 	 "value of parameter n (or parameter count if n\n"
 	 "\t\t\tis zero)"},
 	{"perm", 2, 2, 0, OP_NOP, {.numfunc_2 = qperm}, {.null = NULL},
 	 "permutation number a!/(a-b)!"},
-	{"prevcand", 1, 5, 0, OP_NOP, {.numfunc_cnt = f_prevcand}, {.null = NULL},
-	 "largest value  =  =  d mod e < a, ptest(a,b,c) true"},
-	{"prevprime", 1, 2, 0, OP_NOP, {.numfunc_cnt = f_pprime}, {.null = NULL},
-	 "return previous small prime, return b if err"},
 	{"pfact", 1, 1, 0, OP_NOP, {.numfunc_1 = qpfact}, {.null = NULL},
 	 "product of primes up till number"},
 	{"pi", 0, 1, FE, OP_NOP, {.numfunc_1 = qpi}, {.null = NULL},
@@ -11255,14 +11427,18 @@ STATIC CONST struct builtin builtins[] = {
 	 "number of bits in a that match b (or 1)"},
 	{"power", 2, 3, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_power},
 	 "value a raised to the power b within accuracy c"},
-	{"protect", 1, 3, FA, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_protect},
+	{"prevcand", 1, 5, 0, OP_NOP, {.numfunc_cnt = f_prevcand}, {.null = NULL},
-	 "read or set protection level for variable"},
+	 "largest value  =  =  d mod e < a, ptest(a,b,c) true"},
-	{"ptest", 1, 3, 0, OP_NOP, {.numfunc_cnt = f_primetest}, {.null = NULL},
+	{"prevprime", 1, 2, 0, OP_NOP, {.numfunc_cnt = f_pprime}, {.null = NULL},
-	 "probabilistic primality test"},
+	 "return previous small prime, return b if err"},
 	{"printf", 1, IN, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_printf},
 	 "print formatted output to stdout"},
 	{"prompt", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_prompt},
 	 "prompt for input line using value a"},
+	{"protect", 1, 3, FA, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_protect},
+	 "read or set protection level for variable"},
+	{"ptest", 1, 3, 0, OP_NOP, {.numfunc_cnt = f_primetest}, {.null = NULL},
+	 "probabilistic primality test"},
 	{"push", 1, IN, FA, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_listpush},
 	 "push values onto front of list"},
 	{"putenv", 1, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_putenv},
@@ -11368,26 +11544,22 @@ STATIC CONST struct builtin builtins[] = {
 	 "assign value to stoponerror flag"},
 	{"str", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_str},
 	 "simple value converted to string"},
-        {"strtoupper", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_strtoupper},
+	{"strcasecmp", 2, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_2 = f_strcasecmp},
-         "Make string upper case"},
+	 "compare two strings case independent"},
-        {"strtolower", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_strtolower},
-         "Make string lower case"},
 	{"strcat", 1,IN, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_strcat},
 	 "concatenate strings together"},
 	{"strcmp", 2, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_2 = f_strcmp},
 	 "compare two strings"},
-	{"strcasecmp", 2, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_2 = f_strcasecmp},
-	 "compare two strings case independent"},
 	{"strcpy", 2, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_2 = f_strcpy},
 	 "copy string to string"},
 	{"strerror", 0, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_strerror},
 	 "string describing error type"},
 	{"strlen", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_strlen},
 	 "length of string"},
-	{"strncmp", 3, 3, 0, OP_NOP, {.null = NULL}, {.valfunc_3 = f_strncmp},
-	 "compare strings a, b to c characters"},
 	{"strncasecmp", 3, 3, 0, OP_NOP, {.null = NULL}, {.valfunc_3 = f_strncasecmp},
 	 "compare strings a, b to c characters case independent"},
+	{"strncmp", 3, 3, 0, OP_NOP, {.null = NULL}, {.valfunc_3 = f_strncmp},
+	 "compare strings a, b to c characters"},
 	{"strncpy", 3, 3, 0, OP_NOP, {.null = NULL}, {.valfunc_3 = f_strncpy},
 	 "copy up to c characters from string to string"},
 	{"strpos", 2, 2, 0, OP_NOP, {.null = NULL}, {.valfunc_2 = f_strpos},
@@ -11398,6 +11570,10 @@ STATIC CONST struct builtin builtins[] = {
 	 "scan a string for assignments to one or more variables"},
 	{"strscanf", 2, IN, FA, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_strscanf},
 	 "formatted scan of string for assignments to variables"},
+        {"strtolower", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_strtolower},
+         "Make string lower case"},
+        {"strtoupper", 1, 1, 0, OP_NOP, {.null = NULL}, {.valfunc_1 = f_strtoupper},
+         "Make string upper case"},
 	{"substr", 3, 3, 0, OP_NOP, {.null = NULL}, {.valfunc_3 = f_substr},
 	 "substring of a from position b for c chars"},
 	{"sum", 0, IN, 0, OP_NOP, {.null = NULL}, {.valfunc_cnt = f_sum},

help/Makefile

@@ -199,37 +199,38 @@ BLT_HELP_FILES= ${BLT_HELP_FILES_3} ${BLT_HELP_FILES_5} \
 #
 # to keep this list in nice sorted order.
 #
-DETAIL_HELP= abs access acos acosh acot acoth acsc acsch address agd \
+DETAIL_HELP= abs access acos acosh acot acoth acoversin acsc acsch \
-	append appr arg argv arrow asec asech asin asinh assign atan atan2 \
+	address agd append appr arg argv arrow asec asech asin asinh assign \
-	atanh avg base base2 bernoulli bit blk blkcpy blkfree blocks bround \
+	atan atan2 atanh aversin avg base base2 bernoulli bit blk blkcpy \
-	btrunc calc_tty calclevel calcpath catalan ceil cfappr cfsim char \
+	blkfree blocks bround btrunc calc_tty calclevel calcpath catalan ceil \
-	cmdbuf cmp comb conj cos cosh cot coth count coversin cp csc csch \
+	cfappr cfsim char cmdbuf cmp comb conj cos cosh cot coth count \
-	ctime d2dm d2dms d2g d2r delete den dereference det digit digits \
+	coversin cp csc csch ctime d2dm d2dms d2g d2r delete den dereference \
-	display dms2d dp epsilon errcount errmax errno error estr euler eval \
+	det digit digits display dms2d dp epsilon errcount errmax errno error \
-	exp fact factor fclose fcnt feof ferror fflush fgetc fgetfield \
+	estr euler eval exp fact factor fclose fcnt feof ferror fflush fgetc \
-	fgetfile fgetline fgets fgetstr fib files floor fopen forall fpathopen \
+	fgetfield fgetfile fgetline fgets fgetstr fib files floor fopen forall \
-	fprintf fputc fputs fputstr frac free freebernoulli freeeuler \
+	fpathopen fprintf fputc fputs fputstr frac free freebernoulli \
-	freeglobals freeredc freestatics frem freopen fscan fscanf fseek fsize \
+	freeeuler freeglobals freeredc freestatics frem freopen fscan fscanf \
-	ftell g2d g2gm g2gms g2r gcd gcdrem gd getenv gms2g h2hm h2hms hash \
+	fseek fsize ftell g2d g2gm g2gms g2r gcd gcdrem gd getenv gms2g h2hm \
-	head highbit hmean hms2h hnrmod hypot ilog ilog10 ilog2 im indices \
+	h2hms hash head highbit hmean hms2h hnrmod hypot ilog ilog10 ilog2 im \
-	inputlevel insert int inverse iroot isalnum isalpha isassoc isatty \
+	indices inputlevel insert int inverse iroot isalnum isalpha isassoc \
-	isblk iscntrl isconfig isdefined isdigit iserror iseven isfile isgraph \
+	isatty isblk iscntrl isconfig isdefined isdigit iserror iseven isfile \
-	ishash isident isint islist islower ismat ismult isnull isnum isobj \
+	isgraph ishash isident isint islist islower ismat ismult isnull isnum \
-	isobjtype isodd isprime isprint isptr ispunct isqrt isrand israndom \
+	isobj isobjtype isodd isprime isprint isptr ispunct isqrt isrand \
-	isreal isrel issimple isspace issq isstr istype isupper isxdigit \
+	israndom isreal isrel issimple isspace issq isstr istype isupper \
-	jacobi join lcm lcmfact lfactor ln log log2 logn lowbit ltol makelist \
+	isxdigit jacobi join lcm lcmfact lfactor ln log log2 logn lowbit ltol \
-	matdim matfill matmax matmin matsum mattrace mattrans max memsize meq \
+	makelist matdim matfill matmax matmin matsum mattrace mattrans max \
-	min minv mmin mne mod modify name near newerror nextcand nextprime \
+	memsize meq min minv mmin mne mod modify name near newerror nextcand \
-	norm null num oldvalue ord param perm pfact pi pix places pmod polar \
+	nextprime norm null num oldvalue ord param perm pfact pi pix places \
-	poly pop popcnt pound power prevcand prevprime printf prompt protect \
+	pmod polar poly pop popcnt pound power prevcand prevprime printf \
-	ptest push putenv quo quomod r2d r2g rand randbit random randombit \
+	prompt protect ptest push putenv quo quomod r2d r2g rand randbit \
-	randperm rcin rcmul rcout rcpow rcsq re remove reverse rewind rm root \
+	random randombit randperm rcin rcmul rcout rcpow rcsq re remove \
-	round rsearch runtime saveval scale scan scanf search sec sech seed \
+	reverse rewind rm root round rsearch runtime saveval scale scan scanf \
-	segment select sgn sha1 sin sinh size sizeof sleep sort sqrt srand \
+	search sec sech seed segment select sgn sha1 sin sinh size sizeof \
-	srandom ssq stoponerror str strcasecmp strcat strcmp strcpy strerror \
+	sleep sort sqrt srand srandom ssq stoponerror str strcasecmp strcat \
-	strlen strncasecmp strncmp strncpy strpos strprintf strscan strscanf \
+	strcmp strcpy strerror strlen strncasecmp strncmp strncpy strpos \
-	strtolower strtoupper substr sum swap system systime tail tan tanh \
+	strprintf strscan strscanf strtolower strtoupper substr sum swap \
-	test time trunc usertime versin version xor
+	system systime tail tan tanh test time trunc usertime versin version \
+	xor
 
 # This list is of files that are clones of DETAIL_HELP files.  They are
 # built from DETAIL_HELP files.

help/acos

@@ -5,13 +5,13 @@ SYNOPSIS
     acos(x [,eps])
 
 TYPES
-    x		real, -1 <= x <= 1
+    x		number (real or complex)
     eps		0 < real < 1, defaults to epsilon()
 
     return	real
 
 DESCRIPTION
-    Returns the acos of x to a multiple of eps with error less in
+    Returns the inverse cosine of x to a multiple of eps with error less in
     absolute value than .75 * eps.
 
     v = acos(x) is the number in [0, pi] for which cos(v) = x.
@@ -20,14 +20,25 @@ EXAMPLE
     ; print acos(.5, 1e-5), acos(.5, 1e-10), acos(.5, 1e-15), acos(.5, 1e-20)
     1.0472 1.0471975512 1.047197551196598 1.04719755119659774615
 
+    ; print acos(5), acos(5i)
+    2.29243166956117768776i 1.57079632679489661923-2.31243834127275262025i
+
+    ; print acos(5+5i)
+    0.79039774680951249644-2.64919617780647114961i
+
 LIMITS
     0 < eps < 1
 
 LINK LIBRARY
     NUMBER *qacos(NUMBER *x, NUMBER *eps)
+    COMPLEX *c_acos(COMPLEX *c, NUMBER *epsilon)
 
 SEE ALSO
-    asin, atan, asec, acsc, acot, epsilon
+    sin, cos, tan, cot, sec, csc
+    asin, atan, acot, asec, acsc
+    versin, coversin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 1999,2023  Landon Curt Noll
 ##

help/acot

@@ -5,29 +5,38 @@ SYNOPSIS
     acot(x [,eps])
 
 TYPES
-    x		real
+    x		number (real or complex)
     eps		0 < real < 1, defaults to epsilon()
 
     return	real
 
 DESCRIPTION
-    Returns the acot of x to a multiple of eps with error less in
+    Returns the inverse cotangent of x to a multiple of eps with error less in
     absolute value than .75 * eps.
 
-    v = acot(x) is the number in (0, pi) for which cot(v) = x.
-
 EXAMPLE
     ; print acot(2, 1e-5),  acot(2, 1e-10), acot(2, 1e-15), acot(2, 1e-20)
     0.46365 0.463647609 0.463647609000806 0.46364760900080611621
 
+    ; print acot(5), acot(5i)
+    0.19739555984988075837 -0.20273255405408219099i
+
+    ; print acos(5+5i)
+    0.79039774680951249644-2.64919617780647114961i
+
 LIMITS
     0 < eps < 1
 
 LINK LIBRARY
     NUMBER *qacot(NUMBER *x, NUMBER *eps)
+    COMPLEX *c_acot(COMPLEX *c, NUMBER *epsilon)
 
 SEE ALSO
-    asin, acos, atan, asec, acsc, epsilon
+    sin, cos, tan, cot, sec, csc
+    asin, acos, atan, asec, acsc
+    versin, coversin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 1999,2021,2023  Landon Curt Noll
 ##

help/acoversin

@@ -0,0 +1,63 @@
+NAME
+    acoversin - inverse coversed trigonometric sine
+
+SYNOPSIS
+    acoversin(x [,eps])
+
+TYPES
+    x		number (real or complex)
+    eps		0 < real < 1, defaults to epsilon()
+
+    return	number
+
+DESCRIPTION
+    Calculate the inverse coversed sine of x to a multiple of eps with error less in
+    absolute value than .75 * eps.
+
+    The coversed sine function is sometimes called covers, or acosiv, or acvs,
+    may be defined as:
+
+	acoversin(x) = asin(1 - x)
+
+EXAMPLE
+    ; print acoversin(.5, 1e-5), acoversin(.5, 1e-10), acoversin(.5, 1e-15), acoversin(.5, 1e-20)
+    0.5236 0.5235987756 0.523598775598299 0.52359877559829887308
+
+    ; print acoversin(1), acoversin(-5), acoversin(2 + 3i)
+    0 1.40341337183925787843-2.49215996813383545614i -0.30760364953071124992-1.86416154415788242834i
+
+LIMITS
+    0 < eps < 1
+
+LINK LIBRARY
+    NUMBER *qacoversin(NUMBER *x, NUMBER *eps)
+    COMPLEX *c_acoversin(COMPLEX *x, NUMBER *eps)
+
+SEE ALSO
+    sin, cos, tan, cot, sec, csc
+    asin, acos, atan, acot, asec, acsc
+    versin, coversin
+    aversin
+    epsilon
+
+## Copyright (C) 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:	2023/08/31 23:07:08
+## 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/

help/acsc

@@ -5,29 +5,38 @@ SYNOPSIS
     acsc(x [,eps])
 
 TYPES
-    x		real, with absolute value >= 1
+    x		number (real or complex)
     eps		0 < real < 1, defaults to epsilon()
 
     return	real
 
 DESCRIPTION
-    Returns the acsc of x to a multiple of eps with error less in
+    Returns the inverse cosecant of x to a multiple of eps with error less in
     absolute value than .75 * eps.
 
-    v = acsc(x) is the number in [-pi/2, pi/2] for which csc(v) = x.
-
 EXAMPLE
     ; print acsc(2, 1e-5), acsc(2, 1e-10), acsc(2, 1e-15), acsc(2, 1e-20)
     0.5236 0.5235987756 0.523598775598299 0.52359877559829887308
 
+    ; print acsc(5), acsc(5i)
+    0.20135792079033079145 -0.19869011034924140648i
+
+    ; print acos(5+5i)
+    0.79039774680951249644-2.64919617780647114961i
+
 LIMITS
     0 < eps < 1
 
 LINK LIBRARY
     NUMBER *qacsc(NUMBER *x, NUMBER *eps)
+    COMPLEX *c_acsc(COMPLEX *c, NUMBER *epsilon)
 
 SEE ALSO
-    asin, acos, atan, asec, acot, epsilon
+    sin, cos, tan, cot, sec, csc
+    asin, acos, atan, acot, asec
+    versin, coversin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 1999,2021,2023  Landon Curt Noll
 ##

help/asec

@@ -5,29 +5,38 @@ SYNOPSIS
     asec(x [,eps])
 
 TYPES
-    x		real, with absolute value >= 1
+    x		number (real or complex)
     eps		0 < real < 1, defaults to epsilon()
 
     return	real
 
 DESCRIPTION
-    Returns the asec of x to a multiple of eps with error less in
+    Returns the inverse secant of x to a multiple of eps with error less in
     absolute value than .75 * eps.
 
-    v = asec(x) is the number in [0, pi] for which sec(v) = x.
-
 EXAMPLE
     ; print asec(2, 1e-5), asec(2, 1e-10), asec(2, 1e-15), asec(2, 1e-20)
     1.0472 1.0471975512 1.047197551196598 1.04719755119659774615
 
+    ; print asec(5), asec(5i)
+    1.36943840600456582778 1.57079632679489661923+0.19869011034924140647i
+
+    ; print acos(5+5i)
+    0.79039774680951249644-2.64919617780647114961i
+
 LIMITS
     0 < eps < 1
 
 LINK LIBRARY
     NUMBER *qasec(NUMBER *x, NUMBER *eps)
+    COMPLEX *c_asec(COMPLEX *c, NUMBER *epsilon)
 
 SEE ALSO
-    asin, acos, atan, acsc, acot, epsilon
+    sin, cos, tan, cot, sec, csc
+    asin, acos, atan, acot, acsc
+    versin, coversin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 1999,2021,2023  Landon Curt Noll
 ##

help/asin

@@ -5,13 +5,13 @@ SYNOPSIS
     asin(x [,eps])
 
 TYPES
-    x		real, -1 <= x <= 1
+    x		number (real or complex)
     eps		0 < real < 1, defaults to epsilon()
 
     return	real
 
 DESCRIPTION
-    Returns the asin of x to a multiple of eps with error less in
+    Returns the inverse sine of x to a multiple of eps with error less in
     absolute value than .75 * eps.
 
     v = asin(x) is the number in [-pi/2, pi/2] for which sin(v) = x.
@@ -20,14 +20,25 @@ EXAMPLE
     ; print asin(.5, 1e-5), asin(.5, 1e-10), asin(.5, 1e-15), asin(.5, 1e-20)
     0.5236 0.5235987756 0.523598775598299 0.52359877559829887308
 
+    ; print asin(5), asin(5i)
+    1.57079632679489661923-2.2924316695611776878i 2.31243834127275262025i
+
+    ; print asin(5+5i)
+    0.78039857998538412279+2.64919617780647114961i
+
 LIMITS
     0 < eps < 1
 
 LINK LIBRARY
     NUMBER *qasin(NUMBER *q, NUMBER *epsilon)
+    COMPLEX *c_asin(COMPLEX *c, NUMBER *epsilon)
 
 SEE ALSO
-    acos, atan, asec, acsc, acot, epsilon
+    sin, cos, tan, cot, sec, csc
+    acos, atan, acot, asec, acsc
+    versin, coversin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 1999,2021,2023  Landon Curt Noll
 ##

help/atan

@@ -5,29 +5,38 @@ SYNOPSIS
     atan(x [,eps])
 
 TYPES
-    x		real
+    x		number (real or complex)
     eps		0 < real < 1, defaults to epsilon()
 
     return	real
 
 DESCRIPTION
-    Returns the atan of x to a multiple of eps with error less in
+    Returns the inverse tangent of x to a multiple of eps with error less in
     absolute value than .75 * eps.
 
-    v = atan(x) is the number in (-pi/2, pi/2) for which tan(v) = x.
-
 EXAMPLE
     ; print atan(2, 1e-5), atan(2, 1e-10), atan(2, 1e-15), atan(2, 1e-20)
     1.10715 1.1071487178 1.107148717794091 1.10714871779409050302
 
+    ; print atan(5), atan(5i)
+    1.37340076694501586086 1.57079632679489661923+0.20273255405408219099i
+
+    ; print acos(5+5i)
+    0.79039774680951249644-2.64919617780647114961i
+
 LIMITS
     0 < eps < 1
 
 LINK LIBRARY
     NUMBER *qatan(NUMBER *x, NUMBER *eps)
+    COMPLEX *c_atan(COMPLEX *c, NUMBER *epsilon)
 
 SEE ALSO
-    asin, acos, asec, acsc, acot, epsilon
+    sin, cos, tan, cot, sec, csc
+    asin, acos, acot, asec, acsc
+    versin, coversin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 1999,2023  Landon Curt Noll
 ##

help/aversin

@@ -0,0 +1,64 @@
+NAME
+    aversin - inverse versed trigonometric sine
+
+SYNOPSIS
+    aversin(x [,eps])
+
+TYPES
+    x		number (real or complex)
+    eps		0 < real < 1, defaults to epsilon()
+
+    return	real
+
+DESCRIPTION
+    Returns the inverse versed sine of x to a multiple of eps with error less in
+    absolute value than .75 * eps.
+
+    The inverse versed sine function is sometimes called avers, sometimes called aver,
+    may be defined as:
+
+	aversin(x) = acos(1 - x)
+
+EXAMPLE
+    ; print aversin(.5, 1e-5), aversin(.5, 1e-10), aversin(.5, 1e-15), aversin(.5, 1e-20)
+    1.0472 1.0471975512 1.047197551196598 1.04719755119659774615
+
+    ; print aversin(0), aversin(-5), aversin(2 + 3i)
+    0 0.16738295495563874081+2.49215996813383545614i 1.87839997632560786916+1.86416154415788242831i
+
+LIMITS
+    0 < eps < 1
+
+LINK LIBRARY
+    NUMBER *qaversin_or_NULL(NUMBER *q, NUMBER *epsilon);
+    NUMBER *qaversin(NUMBER *q, NUMBER *epsilon);
+    COMPLEX *c_aversin(COMPLEX *c, NUMBER *epsilon);
+
+SEE ALSO
+    sin, cos, tan, cot, sec, csc
+    asin, acos, atan, acot, asec, acsc
+    versin, coversin
+    acoversin
+    epsilon
+
+## Copyright (C) 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:	2023/09/03 00:26:24
+## 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/

help/cos

@@ -1,5 +1,5 @@
 NAME
-    cos - cosine
+    cos - trigonometric cosine
 
 SYNOPSIS
     cos(x [,eps])
@@ -33,8 +33,11 @@ LINK LIBRARY
     COMPLEX *c_cos(COMPLEX *x, NUMBER *eps)
 
 SEE ALSO
-    sin, tan, sec, csc, cot, epsilon
+    sin, tan, cot, sec, csc
+    asin, acos, atan, acot, asec, acsc
     versin, coversin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 1999,2021,2023  Landon Curt Noll
 ##

help/cot

@@ -26,8 +26,11 @@ LINK LIBRARY
     COMPLEX *c_acot(COMPLEX *c, NUMBER *eps);
 
 SEE ALSO
-    sin, cos, tan, sec, csc, epsilon
+    sin, cos, tan, sec, csc
+    asin, acos, atan, acot, asec, acsc
     versin, coversin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 1999,2021,2023  Landon Curt Noll
 ##

help/coversin

@@ -1,5 +1,5 @@
 NAME
-    coversin - coversed sine
+    coversin - coversed trigonometric sine
 
 SYNOPSIS
     coversin(x [,eps])
@@ -11,7 +11,7 @@ TYPES
     return	number
 
 DESCRIPTION
-    Calculate the versed cosine of x to a multiple of eps with error less in
+    Calculate the coversed sine of x to a multiple of eps with error less in
     absolute value than .75 * eps.
 
     The coversed sine function is sometimes called covers, or cosiv, or cvs,
@@ -41,8 +41,11 @@ LINK LIBRARY
     COMPLEX *c_coversin(COMPLEX *x, NUMBER *eps)
 
 SEE ALSO
-    sin, cos, tan, sec, csc, cot, epsilon
+    sin, cos, tan, cot, sec, csc
+    asin, acos, atan, acot, asec, acsc
     versin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 2023  Landon Curt Noll
 ##

help/csc

@@ -1,5 +1,5 @@
 NAME
-    csc - trigonometric cosecant function
+    csc - trigonometric cosecant
 
 SYNOPSIS
     csc(x [,eps])
@@ -25,8 +25,11 @@ LINK LIBRARY
     NUMBER *qcsc(NUMBER *x, NUMBER *eps)
 
 SEE ALSO
-    sin, cos, tan, sec, cot, epsilon
+    sin, cos, tan, cot, sec
+    asin, acos, atan, acot, asec, acsc
     versin, coversin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 1999,2023  Landon Curt Noll
 ##

help/sec

@@ -1,5 +1,5 @@
 NAME
-    sec - trigonometric secant function
+    sec - trigonometric secant
 
 SYNOPSIS
     sec(x [,eps])
@@ -26,8 +26,11 @@ LINK LIBRARY
     NUMBER *qsec(NUMBER *x, NUMBER *eps)
 
 SEE ALSO
-    sin, cos, tan, csc, cot, epsilon
+    sin, cos, tan, cot, csc
+    asin, acos, atan, acot, asec, acsc
     versin, coversin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 1999,2023  Landon Curt Noll
 ##

help/sin

@@ -33,8 +33,11 @@ LINK LIBRARY
     COMPLEX *c_sin(COMPLEX *x, NUMBER *eps)
 
 SEE ALSO
-    cos, tan, sec, csc, cot, epsilon
+    cos, tan, cot, sec, csc
+    asin, acos, atan, acot, asec, acsc
     versin, coversin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 1999,2021,2023  Landon Curt Noll
 ##

help/tan

@@ -27,8 +27,11 @@ LINK LIBRARY
     COMPLEX *c_atan(COMPLEX *c, NUMBER *eps);
 
 SEE ALSO
-    sin, cos, sec, csc, cot, epsilon
+    sin, cos, cot, sec, csc
+    asin, acos, atan, acot, asec, acsc
     versin, coversin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 1999,2023  Landon Curt Noll
 ##

help/versin

@@ -1,5 +1,5 @@
 NAME
-    versin - versed sine
+    versin - versed trigonometric sine
 
 SYNOPSIS
     versin(x [,eps])
@@ -41,8 +41,11 @@ LINK LIBRARY
     COMPLEX *c_versin(COMPLEX *x, NUMBER *eps)
 
 SEE ALSO
-    sin, cos, tan, sec, csc, cot, epsilon
+    sin, cos, tan, cot, sec, csc
+    asin, acos, atan, acot, asec, acsc
     coversin
+    aversin. acoversin
+    epsilon
 
 ## Copyright (C) 2023  Landon Curt Noll
 ##

qmath.h

@@ -227,7 +227,11 @@ E_FUNC void qfreeeuler(void);
  * historical trig functions
  */
 E_FUNC NUMBER *qversin(NUMBER *q, NUMBER *epsilon);
+E_FUNC NUMBER *qaversin_or_NULL(NUMBER *q, NUMBER *epsilon);
+E_FUNC NUMBER *qaversin(NUMBER *q, NUMBER *epsilon);
 E_FUNC NUMBER *qcoversin(NUMBER *q, NUMBER *epsilon);
+E_FUNC NUMBER *qacoversin_or_NULL(NUMBER *q, NUMBER *epsilon);
+E_FUNC NUMBER *qacoversin(NUMBER *q, NUMBER *epsilon);
 
 
 /*

qtrans.c

@@ -421,6 +421,8 @@ qcsc(NUMBER *q, NUMBER *epsilon)
 	qfree(csc);
 	return res;
 }
+
+
 /*
  * Calculate the arcsine function.
  * The result is in the range -pi/2 to pi/2.
@@ -437,14 +439,16 @@ qasin(NUMBER *q, NUMBER *epsilon)
 		math_error("Zero epsilon value for asin");
 		not_reached();
 	}
-	if (qiszero(q))
+	if (qiszero(q)) {
 		return qlink(&_qzero_);
+	}
 	ztmp = q->num;
 	neg = ztmp.sign;
 	ztmp.sign = 0;
 	r = zrel(ztmp, q->den);
-	if (r > 0)
+	if (r > 0) {
 		return NULL;
+	}
 	if (r == 0) {
 		epsilon1 = qscale(epsilon, 1L);
 		qtmp2 = qpi(epsilon1);
@@ -1981,8 +1985,6 @@ qacoth(NUMBER *q, NUMBER *epsilon)
  *
  *	versin(x) = 1 - cos(x)
  *
- * This calls qsincos() and discards the value of sin.
- *
  * given:
  *	q	    real value to pass to the trig function
  *	epsilon	    error tolerance / precision for trig calculation
@@ -1997,31 +1999,147 @@ qversin(NUMBER *q, NUMBER *epsilon)
 	NUMBER *versin;
 	long n;
 
-	if (qiszero(epsilon)) {
+	/*
-		math_error("Zero epsilon value for %s", __func__);
+	 * firewall
+	 */
+	if (q == NULL) {
+		math_error("q is NULL for %s", __func__);
 		not_reached();
 	}
+	if (check_epsilon(epsilon) == false) {
+		math_error("Invalid epsilon arg for %s", __func__);
+		not_reached();
+	}
+
+	/*
+	 * calculate trig function value
+	 */
 	n = -qilog2(epsilon);
-	if (qiszero(q) || n < 0)
-		return qlink(&_qzero_);
 	qsincos(q, n + 2, &sin, &cos);
 	qfree(sin);
 	versin = qsub(&_qone_, cos);
 	qfree(cos);
+
+	/*
+	 * round value to nearest epsilon
+	 */
 	res = qmappr(versin, epsilon, 24);
 	qfree(versin);
+
+	/*
+	 * return 1 - cos(x)
+	 */
 	return res;
 }
 
 
 /*
- * qversin - coversed sine for NUMBER values
+ * qaversin_or_NULL - inverse versed sine for NUMBER values
  *
  * This uses the formula:
  *
- *	coversin(x) = 1 - sin(x)
+ *	aversin(x) = acos(1 - x)
  *
- * This calls qsincos() and discards the value of cos.
+ * given:
+ *	q	    real value to pass to the trig function
+ *	epsilon	    error tolerance / precision for trig calculation
+ *
+ * returns:
+ *	!= NULL ==> real value result of trig function on q with error epsilon,
+ *	NULL    ==> trig function value cannot be expressed as a NUMBER
+ *
+ * NOTE: If this function returns NULL, consider calling the equivalent
+ *	 COMPLEX function from comfunc.c.  See the help file for the
+ *	 related builtin for details.
+ */
+NUMBER *
+qaversin_or_NULL(NUMBER *q, NUMBER *epsilon)
+{
+	NUMBER *res;	/* inverse trig value result */
+	NUMBER *x;	/* argument to inverse trig function */
+
+	/*
+	 * firewall
+	 */
+	if (q == NULL) {
+		math_error("q is NULL for %s", __func__);
+		not_reached();
+	}
+	if (check_epsilon(epsilon) == false) {
+		math_error("Invalid epsilon arg for %s", __func__);
+		not_reached();
+	}
+
+	/*
+	 * calculate inverse trig function value
+	 */
+	x = qsub(&_qone_, q);
+	res = qacos(x, epsilon);
+	qfree(x);
+	if (res == NULL) {
+		return NULL;
+	}
+
+	/*
+	 * return acos(1 - x)
+	 */
+	return res;
+}
+
+
+/*
+ * qaversin - inverse versed sine for NUMBER values
+ *
+ * This uses the formula:
+ *
+ *	aversin(x) = acos(1 - x)
+ *
+ * given:
+ *	q	    real value to pass to the trig function
+ *	epsilon	    error tolerance / precision for trig calculation
+ *
+ * returns:
+ *	real value result of trig function on q with error epsilon
+ */
+NUMBER *
+qaversin(NUMBER *q, NUMBER *epsilon)
+{
+	NUMBER *res;	/* inverse trig value result */
+
+	/*
+	 * firewall
+	 */
+	if (q == NULL) {
+		math_error("q is NULL for %s", __func__);
+		not_reached();
+	}
+	if (check_epsilon(epsilon) == false) {
+		math_error("Invalid epsilon arg for %s", __func__);
+		not_reached();
+	}
+
+	/*
+	 * calculate inverse trig function value
+	 */
+	res = qaversin_or_NULL(q, epsilon);
+	if (res == NULL) {
+		math_error("cannot compute inverse cos for aversin");
+		not_reached();
+	}
+
+	/*
+	 * return acos(1 - x)
+	 */
+	return res;
+}
+
+
+/*
+ * qcoversin - coversed sine for NUMBER values
+ *
+ * This uses the formula:
+ *
+ *	coversin((x) = 1 - sin(x)
  *
  * given:
  *	q	    real value to pass to the trig function
@@ -2037,10 +2155,21 @@ qcoversin(NUMBER *q, NUMBER *epsilon)
 	NUMBER *coversin;
 	long n;
 
-	if (qiszero(epsilon)) {
+	/*
-		math_error("Zero epsilon value for %s", __func__);
+	 * firewall
+	 */
+	if (q == NULL) {
+		math_error("q is NULL for %s", __func__);
 		not_reached();
 	}
+	if (check_epsilon(epsilon) == false) {
+		math_error("Invalid epsilon arg for %s", __func__);
+		not_reached();
+	}
+
+	/*
+	 * calculate trig function value
+	 */
 	n = -qilog2(epsilon);
 	if (qiszero(q) || n < 0)
 		return qlink(&_qzero_);
@@ -2048,7 +2177,119 @@ qcoversin(NUMBER *q, NUMBER *epsilon)
 	qfree(cos);
 	coversin = qsub(&_qone_, sin);
 	qfree(sin);
+
+	/*
+	 * round value to nearest epsilon
+	 */
 	res = qmappr(coversin, epsilon, 24);
 	qfree(coversin);
+
+	/*
+	 * return 1 - sin(x)
+	 */
+	return res;
+}
+
+
+/*
+ * qacoversin_or_NULL - inverse coversed sine for NUMBER values
+ *
+ * This uses the formula:
+ *
+ *	acoversin(x) = asin(1 - x)
+ *
+ * given:
+ *	q	    real value to pass to the trig function
+ *	epsilon	    error tolerance / precision for trig calculation
+ *
+ * returns:
+ *	real value result of trig function on q with error epsilon
+ *
+ * returns:
+ *	!= NULL ==> real value result of trig function on q with error epsilon,
+ *	NULL    ==> trig function value cannot be expressed as a NUMBER
+ *
+ * NOTE: If this function returns NULL, consider calling the equivalent
+ *	 COMPLEX function from comfunc.c.  See the help file for the
+ *	 related builtin for details.
+ */
+NUMBER *
+qacoversin_or_NULL(NUMBER *q, NUMBER *epsilon)
+{
+	NUMBER *res;	/* inverse trig value result */
+	NUMBER *x;	/* argument to inverse trig function */
+
+	/*
+	 * firewall
+	 */
+	if (q == NULL) {
+		math_error("q is NULL for %s", __func__);
+		not_reached();
+	}
+	if (check_epsilon(epsilon) == false) {
+		math_error("Invalid epsilon arg for %s", __func__);
+		not_reached();
+	}
+
+	/*
+	 * calculate inverse trig function value
+	 */
+	x = qsub(&_qone_, q);
+	res = qasin(x, epsilon);
+	qfree(x);
+	if (res == NULL) {
+		return NULL;
+	}
+
+	/*
+	 * return asin(1 - x)
+	 */
+	return res;
+}
+
+
+/*
+ * qacoversin - inverse coversed sine for NUMBER values
+ *
+ * This uses the formula:
+ *
+ *	acoversin(x) = asin(1 - x)
+ *
+ * given:
+ *	q	    real value to pass to the trig function
+ *	epsilon	    error tolerance / precision for trig calculation
+ *
+ * returns:
+ *	real value result of trig function on q with error epsilon
+ */
+NUMBER *
+qacoversin(NUMBER *q, NUMBER *epsilon)
+{
+	NUMBER *res;	/* inverse trig value result */
+
+	/*
+	 * firewall
+	 */
+	if (q == NULL) {
+		math_error("q is NULL for %s", __func__);
+		not_reached();
+	}
+	if (check_epsilon(epsilon) == false) {
+		math_error("Invalid epsilon arg for %s", __func__);
+		not_reached();
+	}
+
+	/*
+	 * calculate inverse trig function value
+	 */
+	res = qacoversin_or_NULL(q, epsilon);
+	if (res == NULL) {
+		math_error("cannot compute inverse sin for acoversin");
+		not_reached();
+	}
+
+	/*
+	 * return asin(1 - x)
+	 */
 	return res;
 }

trailblank

@@ -0,0 +1,200 @@
+#!/usr/bin/env bash
+#
+# trailblank - find trailing blanks and other file format picky issues
+#
+# This tools is used by "make prep".
+#
+# If all is well, this tool prints nothing and does an exit 0.
+# If a problem is found, this tool prints messages and does a non-0 exit.
+#
+# Copyright (C) 2017,2018,2021-2023  Landon Curt Noll
+#
+# 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.
+#
+# Under source code control:	2017/05/22 03:28:20
+# File existed as early as:	2017
+#
+# chongo <was here> /\oo/\	http://www.isthe.com/chongo/
+# Share and enjoy!  :-)		http://www.isthe.com/chongo/tech/comp/calc/
+
+# exit code
+#
+export EXIT_CODE=0
+
+# Look for leading whiitespace before a tab
+#
+# We exclude binary files, RCS source code history, intermediate
+# compiled files, patch droppings and compiled binary libraries.
+#
+# Last, we have two files that have long lines that, for now,
+# we cannot be as picky about without significant work.
+#
+LEADING_SPACES_BEFORE_TAB=$(
+    find . \( -path './NOTES' -o -path './calc' -o -path './ver_calc' -o \
+	      -name '*.o' -o -name '*.a' -o -name '*ptch*' -o -name 'core*' -o \
+	      -name '*.orig' -o -name '*.rej' -o -name '*.bak' -o \
+	      -name '*.ptch' -o -name 'core.*' -o \
+	      -name '*.so*' -o -name 'calc-static' -o -name 'libcalc.*' -o \
+	      -name 'sample_many' -o -name 'sample_rand' -o \
+	      -path './help/funclist' -o -path './have_stdvs' -o \
+	      -path './endian' -o -path './no_implicit' -o -name 'chk_c' -o \
+	      -path './longbits' -o -name '.*.swp' -o -name 'conf.h' -o \
+	      -path './help/errorcodes.sed' -o -path './cal/set8700.line' -o \
+	      -name '.git' -o -path './custom/libcustcalc*' -o -path './libcustcalc*' -o \
+	      -name 'sample_many-static' -o -name 'sample_rand-static' -o \
+	      -name 'codeql-analysis.yml' -o -name tags -o -name debug.out \
+	   \) -prune -o -type f -print0 | \
+    xargs -0 egrep -l '^	*  *	'
+)
+if [[ -n $LEADING_SPACES_BEFORE_TAB ]]; then
+    echo
+    echo '# files with leading spaces before a tab'
+    echo "$LEADING_SPACES_BEFORE_TAB" | sed -e 's/^\.\///'
+    EXIT_CODE=1
+fi
+
+# Look for trailing whitespace
+#
+# We exclude binary files, RCS source code history, intermediate
+# compiled files, patch droppings and compiled binary libraries.
+#
+# Last, we have two files that have long lines that, for now,
+# we cannot be as picky about without significant work.
+#
+TRAILING_WHITESPACE=$(
+    find . \( -path './NOTES' -o -path './calc' -o -path './ver_calc' -o \
+	      -name '*.o' -o -name '*.a' -o -name '*ptch*' -o -name 'core*' -o \
+	      -name '*.orig' -o -name '*.rej' -o -name '*.bak' -o \
+	      -name '*.ptch' -o -name 'core.*' -o \
+	      -name '*.so*' -o -name 'calc-static' -o -name 'libcalc.*' -o \
+	      -name 'sample_many' -o -name 'sample_rand' -o \
+	      -path './help/funclist' -o -path './have_stdvs' -o \
+	      -path './endian' -o -path './no_implicit' -o -name 'chk_c' -o \
+	      -path './longbits' -o -name '.*.swp' -o -name 'conf.h' -o \
+	      -path './help/errorcodes.sed' -o -path './cal/set8700.line' -o \
+	      -name '.git' -o -path './custom/libcustcalc*' -o -path './libcustcalc*' -o \
+	      -name 'sample_many-static' -o -name 'sample_rand-static' -o \
+	      -name 'codeql-analysis.yml' -o -name tags -o -name debug.out \
+	   \) -prune -o -type f -print0 | \
+    xargs -0 egrep -l '[	 ]$'
+)
+if [[ -n $TRAILING_WHITESPACE ]]; then
+    echo
+    echo '# files with trailing whitespace'
+    echo "$TRAILING_WHITESPACE" | sed -e 's/^\.\///'
+    EXIT_CODE=2
+fi
+
+# Perform special picky tool phase 0 processing
+#
+# Some of these files must have long lines.  Some of these files may not exist.
+#
+if [[ -x /usr/local/bin/picky ]]; then
+    PICKY_PHASE_0A=$(/usr/local/bin/picky -w -s -v ./help/errorcodes.sed ./cal/set8700.line \
+						   .gitignore README.md .lldbinit 2>&1)
+    status="$?"
+    if [[ $status -ne 0 ]]; then
+	echo
+	echo '# picky failed on one of the files with long lines'
+	echo "$PICKY_PHASE_0A" | sed -e 's/\.\///'
+	EXIT_CODE=3
+    fi
+    if [[ -e conf.h ]]; then
+	PICKY_PHASE_0B=$(/usr/local/bin/picky -w -s -v conf.h 2>&1)
+	status="$?"
+	if [[ $status -ne 0 ]]; then
+	    echo
+	    echo '# picky failed on conf.h'
+	    echo "$PICKY_PHASE_0B" | sed -e 's/\.\///'
+	    EXIT_CODE=4
+	fi
+    fi
+    if [[ -e calcerr.h ]]; then
+	PICKY_PHASE_0C=$(/usr/local/bin/picky -w -s -v calcerr.h 2>&1)
+	status="$?"
+	if [[ $status -ne 0 ]]; then
+	    echo
+	    echo '# picky failed on calcerr.h'
+	    echo "$PICKY_PHASE_0C" | sed -e 's/\.\///'
+	    EXIT_CODE=5
+	fi
+    fi
+else
+    echo "# $0: WARNING: /usr/local/bin/picky not found: skipping picky phase 0 checks!" 1>&2
+    echo "#" 1>&2
+fi
+
+# Picky tool processing phase 1
+#
+# We exclude binary files, source code history, intermediate
+# compiled files, patch droppings and compiled binary libraries.
+#
+# Last, we have files that have long lines that, for now,
+# we cannot be as picky about without significant work.
+#
+PICKY_PHASE_1=$(
+    find . \( -path './NOTES' -o -path './calc' -o -path './ver_calc' -o \
+	      -name '*.o' -o -name '*.a' -o -name '*ptch*' -o -name 'core*' -o \
+	      -name '*.orig' -o -name '*.rej' -o -name '*.bak' -o \
+	      -name '*.ptch' -o -name 'core.*' -o \
+	      -name '*.so*' -o -name 'calc-static' -o -name 'libcalc.*' -o \
+	      -name 'sample_many' -o -name 'sample_rand' -o \
+	      -path './help/funclist' -o -path './have_stdvs' -o \
+	      -path './endian' -o -path './no_implicit' -o -name 'chk_c' -o \
+	      -path './longbits' -o -name '.*.swp' -o -name 'conf.h' -o \
+	      -path './help/errorcodes.sed' -o -path './cal/set8700.line' -o \
+	      -name '.git' -o -path './custom/libcustcalc*' -o -path './libcustcalc*' -o \
+	      -name 'sample_many-static' -o -name 'sample_rand-static' -o \
+	      -name 'codeql-analysis.yml' -o -name tags -o -name debug.out \
+	      -o \
+	      -path './help/errorcodes.sed' -o -path './help/errorcodes.sed' -o \
+	      -name '.gitignore' -o -name 'README.md' -o -name '.lldbinit' \
+	   \) -prune -o -type f -print0 | \
+    if [[ -x /usr/local/bin/picky ]]; then
+	xargs -0 /usr/local/bin/picky -s -v -w132
+    else
+	echo "# $0: WARNING: /usr/local/bin/picky not found: skipping picky phase 1 check!" 1>&2
+	echo "#" 1>&2
+	echo "# $0: NOTICE: The picky tool used is from the following GitHub repo:" 1>&2
+	echo "#" 1>&2
+	echo "#		https://github.com/lcn2/picky for the picky tool GitHub repo." 1>&2
+	echo "#" 1>&2
+    fi
+)
+if [[ -n $PICKY_PHASE_1 ]]; then
+    echo
+    echo '# files flagged by picky'
+    echo "$PICKY_PHASE_1" | sed -e 's/^picky: \.\///' -e 's/ / - /'
+    EXIT_CODE=6
+fi
+
+# look for backup Makefiles
+#
+BACKUP_MAKEILES=$(
+    find . -name Makefile.bak -print
+)
+if [[ -n $BACKUP_MAKEILES ]]; then
+    echo
+    echo "# You need execute the following to remove backup Makefiles:"
+    echo
+    echo "$BACKUP_MAKEILES" | while read file; do
+	echo "rm -f $file"
+    done
+    EXIT_CODE=7
+fi
+
+# All Done!!! -- Jessica Noll, Age 2
+#
+exit "$EXIT_CODE"

update_ver

@@ -0,0 +1,189 @@
+#!/bin/bash
+#
+# update_ver - update version numbers in Makefile.config
+#
+# This tools is used by "make prep".
+#
+# The original name for this tool was verupdate.
+#
+# Copyright (C) 2021-2023  Landon Curt Noll
+#
+# 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.
+#
+# Under source code control:	2021/12/12 15:32:43
+# 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/
+
+# setup
+#
+MK_SET1="Makefile.config"
+
+#####################
+# utility functions #
+#####################
+
+# firewall - must have primary Makefiles
+#
+check_primary() {
+    echo "check for primary Makefiles: $MK_SET1"
+    for i in $MK_SET1; do
+	if [[ ! -f $i ]]; then
+	    echo "$0: FATAL: Missing critical: $i" 1>&2
+	fi
+	if [[ ! -s $i ]]; then
+	    echo "$0: FATAL: empty: $i" 1>&2
+	fi
+    done
+    for i in $MK_SET1; do
+	if [[ ! -f $i ]]; then
+	    echo "$0: FATAL: exit 1"
+	    exit 1
+	fi
+	if [[ ! -s $i ]]; then
+	    echo "$0: FATAL: exit 2"
+	    exit 2
+	fi
+    done
+}
+
+# firewall - bak files must not pre-exist
+#
+no_bak() {
+    for i in $MK_SET1; do
+	if [[ -f $i.bak ]]; then
+	    echo "$0: FATAL: bak copy found: $i.bak" 1>&2
+	    echo "$0: FATAL: try: diff -u $i.bak $i" 1>&2
+	    echo "$0: FATAL: consider: rm -f $i.bak" 1>&2
+	fi
+    done
+    for i in $MK_SET1; do
+	if [[ -f $i.bak ]]; then
+	    echo "$0: FATAL: exit 5"
+	    exit 5
+	fi
+    done
+}
+
+# firewall
+#
+check_primary
+no_bak
+
+# generate the version
+#
+echo "make ver_calc >/dev/null 2>&1"
+make ver_calc >/dev/null 2>&1
+status="$?"
+if [[ $status -ne 0 ]]; then
+    echo "$0: FATAL: make ver_calc non-zero exit code: $status" 1>&2
+    echo "$0: FATAL: exit 4"
+    exit 4
+fi
+if [[ ! -x ver_calc ]]; then
+    echo "$0: FATAL: cannot find / did not make ver_calc executable" 1>&2
+    echo "$0: FATAL: exit 5"
+    exit 5
+fi
+CALC_VERSION=$(./ver_calc)
+export CALC_VERSION
+if [[ -z $CALC_VERSION ]]; then
+    echo "$0: FATAL: unable to determine calc version" 1>&2
+    echo "$0: FATAL: exit 6"
+    exit 6
+fi
+CALC_VER=$(./ver_calc -V)
+export CALC_VER
+if [[ -z $CALC_VER ]]; then
+    echo "$0: FATAL: unable to determine calc major version" 1>&2
+    echo "$0: FATAL: exit 7"
+    exit 7
+fi
+
+# re-firewall
+#
+# Just in case the 'make ver_calc' causes some Makefile.config
+# to be reformed, and thus a bak file was created.
+#
+check_primary
+no_bak
+
+# modify version lines
+#
+echo "about to modify: $MK_SET1"
+echo "changing version line to use VERSION= $CALC_VERSION"
+echo "changing major version line to use VER= $CALC_VER"
+perl -p -i -e \
+	's/^VERSION= .*/VERSION= '"$CALC_VERSION"'/; s/^VER= .*/VER= '"$CALC_VER"'/' \
+	$MK_SET1
+status="$?"
+if [[ $status -ne 0 ]]; then
+    echo "$0: FATAL: perl version change for non-zero exit code: $status" 1>&2
+    echo "$0: FATAL: exit 8"
+    exit 8
+fi
+
+# print calc version
+#
+echo
+export VERSION_STRING=
+export VERSION_ERR=
+for i in $MK_SET1; do
+    VERSION_STRING=$(egrep '^VERSION= [1-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*$' "$i")
+    if [[ -z $VERSION_STRING ]]; then
+	echo "$0: FATAL: cannot find VERSION= in $i"
+	VERSION_ERR="$i"
+    else
+	echo "$i: $VERSION_STRING"
+    fi
+done
+if [[ -n $VERSION_ERR ]]; then
+    echo "$0: FATAL: error in finding calc version string"
+    echo "$0: FATAL: exit 9"
+    exit 9
+fi
+
+# print calc major version
+#
+export VER_STRING=
+export VER_ERR=
+for i in $MK_SET1; do
+    VER_STRING=$(egrep '^VER= [1-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*$' "$i")
+    if [[ -z $VER_STRING ]]; then
+	echo "$0: FATAL: cannot find VER= in $i"
+	VER_ERR="$i"
+    else
+	echo "$i: $VER_STRING"
+    fi
+done
+if [[ -n $VER_ERR ]]; then
+    echo "$0: FATAL: error in finding calc major version string"
+    echo "$0: FATAL: exit 10"
+    exit 10
+fi
+
+# print other useful calc strings
+#
+echo
+echo "calc $(./ver_calc) release"
+echo
+echo "Release v$(./ver_calc)"
+
+# All Done!!! -- Jessica Noll, Age 2
+#
+echo
+echo "VERSION in Makefile.config is up to date"
+exit 0