% \iffalse
%<*copyright>
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% dljsLib.sty package,                                 %%
%% Copyright (C) 2001-2021  D. P. Story                 %%
%%   dpstory@uakron.edu                                 %%
%%                                                      %%
%% This program can redistributed and/or modified under %%
%% the terms of the LaTeX Projet Public License         %%
%% Distributed from CTAN archives in directory          %%
%% macros/latex/base/lppl.txt; either version 1 of the  %%
%% License, or (at your option) any later version.      %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%</copyright>
%<package>\NeedsTeXFormat{LaTeX2e}
%<package>\ProvidesPackage{dljslib}
%<package> [2021/04/04 v2.2 Manage a Library of Document Level JavaScripts (dps)]
%<*driver>
\documentclass{ltxdoc}
\usepackage[colorlinks,hyperindex=false]{hyperref}
\pdfstringdefDisableCommands{\let\\\textbackslash}%
%\OnlyDescription  % comment out for implementation details
\EnableCrossrefs
\CodelineIndex
\RecordChanges
\makeatletter
\let\@latex@warning@no@line\@gobble
\makeatother
\def\darg#1{\texttt{\char123\relax#1\char125\relax}}
\def\CMD#1{\textbackslash#1}
\let\pkg\textsf
\let\opt\texttt
\let\env\texttt
\let\app\textsf
\let\uif\textsf
\def\STRUT{\rule{0pt}{14pt}}
\def\negSTRUT{\rule[-8pt]{0pt}{0pt}}
\def\nmpsep#1{\hskip-\marginparsep\texttt{#1}}
\def\visispace{\symbol{32}}
\def\ameta#1{\ensuremath{\langle\textit{\texttt{#1}}\rangle}}
\def\meta#1{\textsl{\texttt{#1}}}
\def\SUB#1{\ensuremath{{}_{\mbox{\scriptsize\ttfamily#1}}}}
\InputIfFileExists{aebdocfmt.def}{\PackageInfo{dljslib}{Inputting aebdocfmt.def}}
    {\def\IndexOpt{\DescribeMacro}\def\IndexKey{\DescribeMacro}\let\setupFullwidth\relax
     \PackageInfo{dljslib}{aebdocfmt.def cannot be found}}
\begin{document}
  \GetFileInfo{dljslib.sty}
  \title{The \texttt{dljsLib} Package}
  \author{D. P. Story\\
    Email: \texttt{dpstory@uakron.edu}}
  \date{processed \today}
  \maketitle
  \tableofcontents
  \let\Email\texttt
  \DocInput{dljslib.dtx}
\IfFileExists{\jobname.ind}{\newpage\setupFullwidth\PrintIndex}{\paragraph*{Index} The index goes here.\\Execute
    \texttt{makeindex -s gind.ist -o dljslib.ind dljslib.idx} on the command line and recompile
    \texttt{dljslib.dtx}.}
\IfFileExists{\jobname.gls}{\PrintChanges}{\paragraph*{Change History} The list of changes goes here.\\Execute
    \texttt{makeindex -s gglo.ist -o dljslib.gls dljslib.glo} on the command line and recompile
    \texttt{dljslib.dtx}.}
\end{document}
%</driver>
% \fi
%
% \InputIfFileExists{aebdonotindex.def}{\PackageInfo{dljslib}{Inputting aebdonotindex.def}}
%    {\PackageInfo{dljslib}{aebdonotindex.def cannot be found}}
%
% \changes{v2.1}{2017/08/11}{Corresponding to exerquiz v8.0, dljslib is modified to
%   conform to multi-letter variables.}
% \changes{v1.3}{2005/08/27}{Added new user contributed routines for unordered,
%        interval, point and factored responses. Added a feature whereby you
%        can create a file called libcusopt.opt to declare your own options
%        for this package, but these should be a combination of existing
%        options.}
% \changes{v2.0}{2014/10/05}{replaced app.alert with eqAppAlert}
%
%\section{Introduction}
% This is a companion package to the \texttt{insdljs} package. \texttt{Insdljs} gives the
% document author the ability to write document level JavaScripts to the PDF docuement, when
% it is finally built.  I personally will be writing a number of general routines to
% handle situations that arise, and I would hope that other enthusiasts of \texttt{insdljs} will
% do the same. Therefore, it is desirable to gather together some general purpose routines into
% a single library, and have a way of selecting the desired function or functions to be used.
%
% This package is meant for document authors, not for package developers. This package can only be used
% once per document, perhaps called from the preamble of a document.
%
%\section{The Library Procedures}
%    \begin{macrocode}
%<*package>
%    \end{macrocode}
% Define some convenience commands, \cs{dljsRegister} and \cs{DeclareAndRegister}, see comments that follow.
%    \begin{macrocode}
\newcommand\dljsRegister[2][n]
    {\expandafter\let\csname checkout@#2\endcsname=#1}
\def\@ifcheckedout#1{\expandafter\if\csname checkout@#1\endcsname y}
\newcommand\DeclareAndRegister[1]
    {\DeclareOption{#1}{\dljsRegister[y]{#1}}\dljsRegister{#1}}
%    \end{macrocode}
% Here we ``register'' the functions contained in the library. \cs{dljsRegister} defines a
% control sequence that records the name of the function (actually, the option name). This
% control is set to `n'. When a package user chooses a particular function for inclusion, the
% control is set to `y'.
%    \begin{macrocode}
\dljsRegister[y]{dljslib}
%    \end{macrocode}
% \subsection{Library Card Catalog}\leavevmode
% \IndexOpt{equations}^^A%
% \IndexOpt{vectors}^^A%
% \IndexOpt{indefIntegral}^^A%
% \IndexOpt{ImplMulti}^^A%
% \IndexOpt{nodec}^^A%
% \IndexOpt{noBinFac}^^A%
% \IndexOpt{limitArith}^^A%
% \IndexOpt{combinatorics}^^A%
% \IndexOpt{setSupport}^^A%
% \noindent
% The arguments of the \cs{DeclareAndRegister} command are the options of this package, and
% their names represent JavaScript functions in the library.
%    \begin{macrocode}
\DeclareAndRegister{equations}
\DeclareAndRegister{vectors}
\DeclareAndRegister{indefIntegral}
\DeclareAndRegister{ImplMulti}
\DeclareAndRegister{nodec}
\DeclareAndRegister{noBinFac}
\DeclareAndRegister{limitArith}
\DeclareAndRegister{combinatorics}
\DeclareAndRegister{setSupport}
%    \end{macrocode}
% \leavevmode
% Additional registered names.
% \IndexOpt{unordered}^^A%
% \IndexOpt{complex}^^A%
% \IndexOpt{satisfyEq}^^A%
% \IndexOpt{useGermanNums}^^A%
% \IndexOpt{useDeNums}^^A%
% \IndexOpt{useEnNums}^^A
% \IndexOpt{factors}^^A%
% \IndexOpt{point}^^A%
% \IndexOpt{intervals}^^A%
%    \begin{macrocode}
\DeclareOption{unordered}{\PackageWarning{dljslib}
  {The `unordered' option is now combined with the\MessageBreak
  `setSupport' option, will use the `setSupport' option\MessageBreak
  instead}\ExecuteOptions{setSupport}}
%\DeclareAndRegister{unordered}
\DeclareAndRegister{complex}
\DeclareAndRegister{satisfyEq}
\DeclareAndRegister{useGermanNums}
\DeclareOption{useDeNums}{\ExecuteOptions{useGermanNums}}
\DeclareAndRegister{useEnNums}
\DeclareAndRegister{factors}
\DeclareAndRegister{point}
\DeclareAndRegister{intervals}
%    \end{macrocode}
%    \begin{macrocode}
\def\includeOptions#1{\@for\@option:=#1\do{\dljsRegister[y]{\@option}}}
\InputIfFileExists{libcusopt.opt}{}{}
%    \end{macrocode}
%    \begin{macrocode}
\ProcessOptions
%    \end{macrocode}
% \subsection{Requirements for a Library Card}
%
% In order to check a function out of this library, you must have
% the \texttt{insdljs} Package. The \texttt{insdljs} package itself
% has software requirements: (1) the \texttt{verbatim} and
% \texttt{hyperref} packages; (2) One of the following,
% \textsf{Distiller~5.0} or greater, \textsf{pdftex}, or
% \textsf{dvipdfm}.
%
%    \begin{macrocode}
\RequirePackage{exerquiz}[2017/08/04]
\RequirePackage{insdljs}
%    \end{macrocode}
% After inputting \textsf{insdljs}, we define |\setdecimalpoint|, which populates
% the text command |\aebdecimalpoint|. The text command |\aebdecimalpoint| is used in the \texttt{nodec}
% option.
%    \begin{macrocode}
\def\setdecimalpoint#1{\def\aebdecimalpoint{\eqbs#1}}
\setdecimalpoint{.}
%    \end{macrocode}
%
% \subsection{Checkout Procedure}
%
% Functions can be checkout of the library by using the \texttt{dljslib} package
% in the usual way. For example:
%\begin{verbatim}
%\documentclass{article}
%\usepackage{amsmath}
%\usepackage[pdftex,designi]{web}
%\usepackage{exerquiz}
%\usepackage[indefIntegral]{dljslib}  % <- check out `indefIntegral'
%\end{verbatim}
% Here, we first use \texttt{exerquiz}, which has \texttt{insdljs} as a required package.
% The use of this package is not limited to users of \texttt{exerquiz}, for example, we can
% say
%\begin{verbatim}
%\documentclass{article}
%\def\mydriver{dvipdfm}
%\usepackage[\mydriver]{color}
%\usepackage[\mydriver,colorlinks,pdfpagemode=None]{hyperref}
%\usepackage[\mydriver]{insdljs}
%\usepackage[indefIntegral]{dljslib}  % <- check out `indefIntegral'
%\end{verbatim}
% However, at the time of the release of v1.0 of this package, the only functions in this
% library are ones used by \texttt{exerquiz}.
%
% \subsection{Exiting the Library with your Checkouts}
%
% This package has an output stream, \cs{dljslib@verbatim@out},
% that is used to write all the functions that are to be included.
% We use a control sequence \cs{js@verbatim@out} defined in
% \texttt{insdljs}. We also use a verbatim write from
% \texttt{insdljs} as well, the \cs{js@verbatimwrite} environment.
% \cs{js@verbatimwrite} writes to the output stream pointed to
% \cs{js@verbatim@out}.
%    \begin{macrocode}
\newwrite\dljslib@verbatim@out
%    \end{macrocode}
% This package generates only one auxiliary file,
% \texttt{dljslib.ljs}, which can be deleted after the document is
% latexed. The file \texttt{dljslib.ljs} (\texttt{ljs} means
% ``library javascripts'') and contains the functions that are
% specified in the package options.  At the end of this package,
% the file \texttt{dljslib.ljs} is input back into the calling
% document where the package \texttt{insdljs} takes over.
%    \begin{macrocode}
\immediate\openout\dljslib@verbatim@out=dljslib.ljs
%    \end{macrocode}
% \subsection{The Catalog and Checkout Mechanism}
%    \begin{macro}{library@holding}
% This is a simple environment, it reads its parameter, and if that option was specified by the
% user, it writes the function verbatim to the \texttt{dljslib.ljs}, otherwise, it comments out
% that function using the \texttt{comment} environment from the \texttt{verbatim} package.
% This environment uses, \texttt{js@verbatimwrite}, an environment
% defined in the \texttt{insdljs} package.
%    \begin{macrocode}
\newenvironment{library@holding}[1]
{%
    \expandafter\ifx\csname checkout@#1\endcsname y%
    \let\js@verbatim@out\dljslib@verbatim@out
    \let\dljs@verbatim\js@verbatimwrite
    \let\enddljs@verbatim\endjs@verbatimwrite\else
    \let\dljs@verbatim\comment
    \let\enddljs@verbatim\endcomment\fi\dljs@verbatim
}{\enddljs@verbatim}
%    \end{macrocode}
%    \end{macro}
%\section{The DLJS Library}
% We finally reach the ``stacks'', the location of the actual library holdings.
%
%   \medskip\noindent This item must always accompany the collection of functions that are to be
% checked out. This is the beginning of the \texttt{insDLJS} environment. To continue this library analogy,
% this of this as the ``front wrapper'' or ``front cover'' of your library selections. It contains the
% ``name'' of the library from which you checked out your selections.
%    \begin{macrocode}
\newcommand{\SyntaxErrorAuthor}{"Syntax error in author's answer!
  Check console."}
\begin{library@holding}{dljslib}
\begin{insDLJS*}[dljslib]{dljslib}
\begin{newsegment}{dljslib: AcroTeX DLJS Library}
/*
        The Document Level JavaScript Library
        D. P. Story copyright 2001-\the\year
*/
var dljslib = true;
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
%\subsection{The Stacks}
% Now we reach of the beginning of the stacks. There are several sections of the library, currently,
% \nameref{s:respfunctions} and \nameref{s:compfunctions}.
%
% \subsection{Response Functions}\label{s:respfunctions}
%
% \textbf{Used by Exerquiz.} In this section we catalog response functions. A response function is the one that
% \cs{RespBoxMath} calls to process the user's response to a math fill-in question. See the sample file
% \texttt{jqzspec.tex} for a detailed explanation of this type of function.
%
% \subsubsection{\texttt{equations}}\label{equations}
%    \IndexOpt{equations}
% These routines process questions for which an equation is the expected answer.
%    \begin{macrocode}
\@ifcheckedout{equations}
\newcommand\equationsAlertMsg{"An equation is expected"}
\fi
\begin{library@holding}{equations}
\begin{newsegment}{dljslib: Equation Handling}
function ProcRespEq(flag,CorrAns,n,epsilon,domain,indepVars,oComp)
{
    if (!ProcessIt) return null;
    ok2Continue = true;
    var success;
    var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
%    var UserAns = event.value;
    var bSubstVars=(arguments.length>7); // dps17
    var UserAns=(bSubstVars)?arguments[7]:event.value;
    var CorrExpressions = CorrAns.split("=");
    var zCorrAns = "("+CorrExpressions[0]+")-("+CorrExpressions[1] +")";
    UserAns = stripWhiteSpace (UserAns);
    if(!ok2Continue ) return null;
    if (!/[=]/.test(UserAns)) {
            eqAppAlert(\equationsAlertMsg, 3);
            return null;
    }
%    \end{macrocode}
% Check for commas, not permitted here. (2012/05/25)
%    \begin{macrocode}
    var reComma=/,/;
    if ( reComma.test(UserAns) ) {
        eqAppAlert(\eqSyntaxErrorComma,3);
        return null;
    }
%    \end{macrocode}
%    \begin{macrocode}
    var UserExpressions = UserAns.split("=");
    var zUserAns = "("+UserExpressions[0]+")-("+UserExpressions[1] +")";

%    \end{macrocode}
% If \texttt{oComp} is an object, then see if it has a \texttt{comp} property
%    \begin{macrocode}
    var comp = ( typeof oComp == "object" ) ?
       (typeof oComp.comp == "undefined" ) ?
            diffCompare : oComp.comp : oComp;
%    \end{macrocode}
% The \texttt{comp} parameter, which has been changed to \texttt{oComp} can now be
% an object. One property of this object is \texttt{comp}, handled above. Another
% property is \texttt{priorParse}, this is a function that returns \texttt{null}
% or \texttt{true}. This \texttt{priorParse} function allows for additional
% filtering of the \texttt{zUserAns} before parsing. If it returns \texttt{true},
% we are ok to continue, if \texttt{null}, we don't like something the user has entered,
% and ask him/her to change it.
%    \begin{macrocode}
    if ( typeof oComp == "object"
        && typeof oComp.priorParse != "undefined" ) {
%    \end{macrocode}
% Let's go ahead and allow \texttt{oComp.priorParse} be an array of functions.
%    \begin{macrocode}
        if ( typeof oComp.priorParse == "object" ) {
            for ( var i=0; i < oComp.priorParse.length; i++) {
                var retn = oComp.priorParse[i](zUserAns);
                if ( retn == null ) return null;
            }
        } else {
            var retn = oComp.priorParse(zUserAns);
            if ( retn == null ) return null;
        }
    }
    zCorrAns = ParseInput(zCorrAns);
    if (!ok2Continue) {
        eqAppAlert(\SyntaxErrorAuthor,3);
        console.println("Syntax Error: " + CorrAns);
        return null;
    }
    zUserAns = ParseInput(zUserAns);
    if (!ok2Continue) return null;
%   convert vars to  new format, if needed
    indepVars = TypeParameters(indepVars);
    var lambda = getNonZeroRatio(domain,indepVars,zCorrAns,zUserAns);
    if ( lambda == null ) {
        eqAppAlert(\eqSyntaxErrorUndefVar,3); return null; };
    if ( !ok2Continue ) return notifyField(false,flag,fieldname);
    zCorrAns  = lambda + "*(" + zCorrAns + ")";
    success=randomPointCompare (n,domain,indepVars,epsilon,
        zCorrAns,zUserAns,comp)
    if ( success == null ) { eqAppAlert(\eqSyntaxErrorUndefVar,3);
        return null; }
    return notifyField(success, flag, fieldname);
}
function getNonZeroRatio (_a, _v, _F, _G)
{
    var _i, _j;
    var aXY = new Array();
    _a = _a.replace(/[\[\]\s]/g, "");
    var _V = _v.split(",");  // e.g. _V[0] = "i:x"
    var _n = _V.length;
    var aIntervals = _a.split("&");
    var aInterval = aIntervals[0].split("x");
    var endpoints = aInterval[0].split(",");
        for (_j=0; _j < 4; _j++) {
            for (_i = 0; _i < _n; _i++) {
                var endpoints = aInterval[_i].split(",");
                aXY[_i] = endpoints[0]-0
                    +(endpoints[1]-endpoints[0])*Math.random();
\db             console.println("aXY["+_i+"] = " + aXY[_i]);\db%
            }
            for (var _i = 0; _i< _n; _i++) {
                if (_V[_i].charAt(0) == "r" )
                    eval ( "var "+ _V[_i].charAt(2)
                        + " = " + aXY[_i] + ";");
                else // assume type "i"
                    eval ( "var "+ _V[_i].charAt(2)
                        + " = " + Math.ceil(aXY[_i]) + ";");
            }
            _F = eval(_F);
            if ( app.viewerVersion >= 5)
            {
                var rtnCode = 0;
                eval("try { if(isNaN(_G = eval(_G))) rtnCode=-1; }"
                    +"catch (e) { rtnCode=1; }");
                switch(rtnCode) {
                    case  0: break;
                    case  1: return null;
                    case -1: ok2Continue=false;
                             return -1;
                }
            }
            else
                if(isNaN(_G=eval(_G))) {ok2Continue=false;return -1;}
            if ( _F != 0 && _G != 0 ) return _G/_F;
        }
    console.println( "Can't find a non zero scalar");
    return null;
}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
%
% \subsubsection{\texttt{vectors}}\label{vectors}
%
%    \IndexOpt{vectors}
% This function attempts to process questions that have vectors
% as answers. Note the name of the function is \texttt{ProcVec}, this is the name used to call it.
%\begin{verbatim}
%$\vec a + \vec b = \RespBoxMath{<4, 4, 4>}{1}{.0001}{[2,4]}*{ProcVec}$
%\end{verbatim}
%See also the file \texttt{jqzspec.tex} for more details.
%    \begin{macrocode}
\@ifcheckedout{vectors}
\newcommand\vectorsErrorMsgi{"I'm looking for a vector.
    You need to use proper vector notation, try using
    angle brackets <....>."}
\newcommand\vectorsErrorMsgii{"Angle brackets are not balanced.
    Check the expression you typed in."}
\newcommand\vectorsErrorMsgiii{"Incorrect number of components.
    The answer requires " + aCorrAns.length+" components."}
\def\vectorEmptyCompMsgiv(#1){"You entered nothing for the
        component " +(#1+1) +" of your answer. Please enter
        a component for the vector."}
\fi
\begin{library@holding}{vectors}
\begin{newsegment}{dljslib: Vector Handling}
function ProcVec (flag,CorrAns,n,epsilon,domain,indepVars,oComp)
{
%    \end{macrocode}
% This function attempts to process questions that have vectors
% as answers.
%    \begin{macrocode}
    if (!ProcessIt) return null;
    ok2Continue = true;
    var i, success, truthCnt=1;
    var aScalar, scalar = 1;
    var fieldname = event.target.name;
    var UserAns = event.value;
    UserAns = stripWhiteSpace(UserAns); // sets ok2Continue
    CorrAns = stripWhiteSpace(CorrAns);
    if ( !ok2Continue ) return null;
    var isSpecResp=false;
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (CorrAns == aDlLibSpecResp[i]) {
            isSpecResp=true; break;
        }
    }
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (UserAns == aDlLibSpecResp[i]) {
            success = (CorrAns == UserAns);
            return notifyField(success, flag, fieldname);
        }
    }
    if (isSpecResp) return notifyField(false, flag, fieldname);
    if (!/[<>]/.test(UserAns)) {
        eqAppAlert(\vectorsErrorMsgi, 3);
        return null;
    }
    if (!CkBalP(UserAns,"<",">")) {
        eqAppAlert(\vectorsErrorMsgii, 3);
        return null;
    }
    // see if there is a scalar multiple to the left of '<'
    aScalar = UserAns.match(/(.*)(\*)(\s*<)/);
    if (aScalar != null) {
        scalar = aScalar[1];
        UserAns = UserAns.slice(aScalar.index + aScalar[0].length-1)
    }
%    \end{macrocode}
% If \texttt{oComp} is an object, then see if it has a \texttt{comp} property
%    \begin{macrocode}
    var comp = ( typeof oComp == "object" ) ?
       (typeof oComp.comp == "undefined" ) ?
            diffCompare : oComp.comp : oComp;
%    \end{macrocode}
%    \begin{macrocode}
    CorrAns = CorrAns.replace(/[<>]/g, ""); // strip of < and >
    UserAns = UserAns.replace(/[<>]/g, "");
%    \end{macrocode}
% The \texttt{comp} parameter, which has been changed to \texttt{oComp} can now be
% an object. One property of this object is \texttt{comp}, handled above. Another
% property is \texttt{priorParse}, this is a function that returns \texttt{null}
% or \texttt{true}. This \texttt{priorParse} function allows for additional
% filtering of the \texttt{UserAns} before parsing. If it returns \texttt{true},
% we are ok to continue, if \texttt{null}, we don't like something the user has entered,
% and ask him/her to change it.
%    \begin{macrocode}
    if ( typeof oComp == "object" && %
typeof oComp.priorParse != "undefined" ) {
        var retn=processSpecialParse(oComp.priorParse,UserAns);
        if (retn==null) return null;
    }
%    \end{macrocode}
% Not convert each to an array
%    \begin{macrocode}
    aUserAns = UserAns.split(",");
    aCorrAns = CorrAns.split(",");
    if (scalar != 1)
        for (i=0; i<aUserAns.length; i++)
            aUserAns[i]=""+scalar+"*"+aUserAns[i];
    if (aCorrAns.length != aUserAns.length) {
        eqAppAlert(\vectorsErrorMsgiii,3);
        return null;
    }
    // convert to new format, if needed
    indepVars = TypeParameters(indepVars);
    for (i=0; i<aCorrAns.length; i++) {
        aCorrAns[i] = ParseInput(aCorrAns[i]);
        if (!ok2Continue) {
            eqAppAlert(\SyntaxErrorAuthor, 3);
            return null;
        }
        aUserAns[i] = ParseInput(aUserAns[i]);
        if (aUserAns[i]==null) {
            eqAppAlert(\vectorEmptyCompMsgiv(i), 3);
            return null;
        }
        if (!ok2Continue) return null;
        success=randomPointCompare (n,domain,indepVars,epsilon,
            aCorrAns[i],aUserAns[i],comp)
        if ( success == null ) {
            eqAppAlert(\eqSyntaxErrorUndefVar,3); return null; }
        truthCnt *= (success) ? 1 : 0;
    }
    return notifyField(!!truthCnt, flag, fieldname);
}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
% \subsubsection{\texttt{setSupport}}
%
%    \IndexOpt{setSupport}
% We introduce two JavaScript functions \texttt{ProcRespSetNum} and
% \texttt{ProcRespSetSym}, for handling a set of answers or a comma
% delimited list of answers. The first function is for
% numerical answers, the second for simple symbolic answers.  The
% demo file for these two response functions is
% \texttt{set\_test.tex}; the examples below were taken from that file.
%\changes{v1.9h}{2014/01/21}{Combined unordered option with setSupport option}
%    \begin{macrocode}
\@ifcheckedout{setSupport}
\newcommand{\noBracesInAnsMsg}{"Do not insert braces in your answer.
    Please remove the braces (\{\})."}
\newcommand{\noBracketsInAnsMsg}{"Do not insert braces in your answer.
    Please remove the angle brackets (<>)."}
\fi
\begin{library@holding}{setSupport}
\begin{newsegment}{dljslib: Support for Sets}
%    \end{macrocode}
% This function can handle (math fill-in) questions whose answers are a set of numbers or a
% comma delimited list of numbers.
%\begin{flushleft}
% Sample usage:
%\begin{verbatim}
% $(x+1)(2x-1)(x-2)^3 = 0$, $x = \RespBoxMath[\rectW{.75in}\textSize{0}]
%    {-1, 1/2, 2, 2, 2}{1}{.0001}{[0,1]}*{ProcRespSetNum}$
%\end{verbatim}
%\end{flushleft}
%    \begin{macrocode}
function ProcRespSetNum(flag,CorrAns,n,epsilon,domain,indepVars,oComp)
{
    ok2Continue = true;
    if (!ProcessIt) return null;
    var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
%    var UserAns = event.value;
    var bSubstVars=(arguments.length>7); // dps17
    var UserAns=(bSubstVars)?arguments[7]:event.value;
    UserAns = stripWhiteSpace(UserAns);
    CorrAns = stripWhiteSpace(CorrAns);
    if (!ok2Continue) return null;
    var isSpecResp=false;
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (CorrAns == aDlLibSpecResp[i]) {
            isSpecResp=true; break;
        }
    }
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (UserAns == aDlLibSpecResp[i]) {
            success = (CorrAns == UserAns);
            return notifyField(success, flag, fieldname);
        }
    }
    if (isSpecResp) return notifyField(false, flag, fieldname);
    var retn=ck4Braces(UserAns);
    if (retn==null) return null;
    var aUserAns = UserAns.split(",");
%    \end{macrocode}
% Make sure all of UserAns are numbers
%    \begin{macrocode}
    for ( var i=0; i < aUserAns.length; i++) {
        try {
            if (isNaN(eval(aUserAns[i]))) return syntaxError(), null;
        } catch(e) { return syntaxError(), null; }
    }
    var aUserAns = aUserAns.sort(
        function(a,b) { return eval(a) - eval(b);} );
    var aCorrAns = CorrAns.split(",").sort(
        function(a,b) { return  eval(a) - eval(b);} );
    var numCorrect = 0;
    if ( aUserAns.length != aCorrAns.length )
        return notifyField(false, flag, fieldname);
    for ( var i=0; i< aCorrAns.length; i++) {
        var retn = _ProcResp(%
flag,aCorrAns[i],aUserAns[i],n,epsilon,domain,indepVars,oComp);
        if ( retn == -1 ) return null;
        if ( retn == null ) return syntaxError(), null;
        numCorrect += (retn) ? 1 : 0;
    }
    var success = (numCorrect == aCorrAns.length);
    return notifyField(success, flag, fieldname);
}
var ok2format=true;
function formatAsSet() {
    if (ok2format&&event.value.replace(/\\s/g,"") != "")
        event.value =  "{ " + event.value + " }";
}
function ck4Braces (UserAns) {
    ok2format=true;
    if (/^\{/.test(UserAns) || /\}$/.test(UserAns) ) {
        ok2format=false;
        return eqAppAlert(\noBracesInAnsMsg,3), null;
    }
    else return true;
}
function ck4AngleBrackets (UserAns) {
    ok2format=true;
    if (/^</.test(UserAns) || />$/.test(UserAns) ) {
        ok2format=false;
        return eqAppAlert(\noBracketsInAnsMsg,3), null;
    }
    else return true;
}
function formatAsVector() {
    if (ok2format&&event.value.replace(/\\s/g,"") != "") {
        event.value =  "< " + event.value + " >";
    }
}
%    \end{macrocode}
% Input an order pair of numbers, determine if it satisfies an equation. This problem
% type is new as there are ``infinitely many answers.''  If we pose the question
% ``Enter a point that lies on the line $2x+3y=6$.'' The user enters an ordered pair
% of numbers. The CorrAns that is passed is $2x+3y-6$, and we test the user's input
% to see if the expression evaluates to zero.
%
%    \begin{macrocode}
%    \end{macrocode}
% This function can handle simple symbolic answers. The variable list, \texttt{inderVar}, should
% be the ``universal set'' of the problem.
% \begin{flushleft}
% Sample usage:
%\begin{verbatim}
% \def\U{a,b,c,d,e,f,g} % define a universal set
% $A \cap B = \RespBoxMath[\AddAAFormat{\formatAsSet}
%           \rectW{.75in}\textSize{0}
%       ]{c,d}(\U){1}{.0001}{[0,1]}*{ProcRespSetSym}$
%\end{verbatim}
% \end{flushleft}
%    \begin{macrocode}
function ProcRespSetSym(flag,CorrAns,n,epsilon,domain,indepVars,oComp)
{
    ok2Continue = true;
    if (!ProcessIt) return null;
    var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
%    var UserAns = event.value;
    var bSubstVars=(arguments.length>7); // dps17
    var UserAns=(bSubstVars)?arguments[7]:event.value;
    UserAns = stripWhiteSpace(UserAns);
    CorrAns = stripWhiteSpace(CorrAns);
    if (!ok2Continue) return null;
    var isSpecResp=false;
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (CorrAns == aDlLibSpecResp[i]) {
            isSpecResp=true; break;
        }
    }
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (UserAns == aDlLibSpecResp[i]) {
            success = (CorrAns == UserAns);
            return notifyField(success, flag, fieldname);
        }
    }
    if (isSpecResp) return notifyField(false, flag, fieldname);
    var retn=ck4Braces(UserAns);
    if (retn==null) return null;
    var aUserAns = UserAns.split(",");
    var _V = indepVars.split(",");
    for ( var _i=0; _i < _V.length; _i++) {
         eval ( "var "+ _V[_i] + " = \"" + _i + "\";");
    }
%    \end{macrocode}
% Make sure all of UserAns are numbers
%    \begin{macrocode}
    for ( var _i=0; _i < aUserAns.length; _i++) {
        try {
            if (isNaN(eval(aUserAns[_i]))) return syntaxError(), null;
            aUserAns[_i] = eval(aUserAns[_i]);
        } catch(e) { return syntaxError(), null; }
    }
    var aCorrAns = CorrAns.split(",");
    for ( var _i=0; _i < aCorrAns.length; _i++) {
        try {
            if (isNaN(eval(aCorrAns[_i])))
                return eqAppAlert(%
"Author error, recheck your code",3), null;
            aCorrAns[_i] = eval(aCorrAns[_i]);
        } catch(e) { return eqAppAlert(
            "Author error, recheck your code",3), null; }
    }
    var aUserAns = aUserAns.sort(
        function(a,b) { return eval(a) - eval(b);} );
    var aCorrAns = aCorrAns.sort(
        function(a,b) { return  eval(a) - eval(b);} );
    var numCorrect = 0;
    if ( aUserAns.length != aCorrAns.length )
        return notifyField(false, flag, fieldname);
    for ( var _i=0; _i< aCorrAns.length; _i++) {
        var retn = _ProcResp(%
flag,aCorrAns[_i],aUserAns[_i],n,epsilon,"[0,1]","i:_x",oComp);
        if ( retn == -1 ) return null;
        if ( retn == null ) return syntaxError(), null;
        numCorrect += (retn) ? 1 : 0;
    }
%    console.println( aUserAns.toSource() );
    var success = (numCorrect == aCorrAns.length);
%    var success = (numCorrect == aCorrAns.length) ? true : false;
%    if ( success == null ) return syntaxError(), null;
    return notifyField(success, flag, fieldname);
}
%    \end{macrocode}
% The function \texttt{ProcRespListFormula} can be used to process a comma-delimited
% \emph{ordered} list of expressions.
%    \begin{macrocode}
function ProcRespListFormula(flag,CorrAns,n,epsilon,domain,%
indepVars,oComp) {
    ok2Continue = true;
    if (!ProcessIt) return null;
    var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
%    var UserAns = event.value;
    var bSubstVars=(arguments.length>7); // dps17
    var UserAns=(bSubstVars)?arguments[7]:event.value;
    UserAns = stripWhiteSpace(UserAns);
    CorrAns = stripWhiteSpace(CorrAns);
    if (!ok2Continue) return null;
    var isSpecResp=false;
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (CorrAns == aDlLibSpecResp[i]) {
            isSpecResp=true; break;
        }
    }
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (UserAns == aDlLibSpecResp[i]) {
            success = (CorrAns == UserAns);
            return notifyField(success, flag, fieldname);
        }
    }
    if (isSpecResp) return notifyField(false, flag, fieldname);
    var retn=ck4AngleBrackets(UserAns);
    if (retn==null) return null;
    UserAns = UserAns.replace(/,+/g, ",");
    UserAns = UserAns.replace(/,$/, "");
    UserAns = UserAns.replace(/^,/, "");
%    event.value = UserAns; % dps17
    CorrAns = stripWhiteSpace(CorrAns);
    if (!ok2Continue) return null;
    var aUserAns = UserAns.split(",");
    var aCorrAns = CorrAns.split(",");
    var numCorrect = 0;
    if ( aUserAns.length != aCorrAns.length )
        return notifyField(false, flag, fieldname);
    for ( var i=0; i< aCorrAns.length; i++) {
        var retn =_ProcResp(flag,aCorrAns[i],aUserAns[i],%
n,epsilon,domain,indepVars,oComp);
        if ( retn == -1 ) return null;
        if ( retn == null ) return syntaxError(), null;
        numCorrect += (retn) ? 1 : 0;
     }
     var success = (numCorrect == aCorrAns.length);
     return notifyField(success, flag, fieldname);
}
%    \end{macrocode}
%  The JS function \texttt{ProcRespSetFormula} will grade an
%  unordered list of formulas, such as
%  \texttt{x}, \verb!x^2!, \verb!x^3!. The code is a modification of
%  \texttt{ProcRespListFormula}. The idea is to split the user and correct
%  answers and then compare the first correct answer with each of the
%  user answers in turn. If there is a match, swap that user answer
%  with the first user answer. Then compare the second correct answer
%  with the rest of the user answers, and continue in that way.
%\begin{flushleft}
% Usage:
%\begin{verbatim}
%\def\formulasetbox#1#2#3{\RespBoxMath{#1}(#2)[\thequestionno]{10}
%    {1.0E-15}{#3}*{ProcRespSetFormula}}
%\formulasetbox{x,x^2,x^3}{x}{[1,2]}
%\end{verbatim}
%\end{flushleft}
%    \begin{macrocode}
function ProcRespSetFormula(flag,CorrAns,n,epsilon,%
domain,indepVars,oComp) {
    ok2Continue = true;
    if (!ProcessIt) return null;
    var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
%    var UserAns = event.value;
    var bSubstVars=(arguments.length>7); // dps17
    var UserAns=(bSubstVars)?arguments[7]:event.value;
    UserAns = stripWhiteSpace(UserAns);
    CorrAns = stripWhiteSpace(CorrAns);
    if (!ok2Continue) return null;
    var isSpecResp=false;
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (CorrAns == aDlLibSpecResp[i]) {
            isSpecResp=true; break;
        }
    }
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (UserAns == aDlLibSpecResp[i]) {
            success = (CorrAns == UserAns);
            return notifyField(success, flag, fieldname);
        }
    }
    if (isSpecResp) return notifyField(false, flag, fieldname);
    var retn=ck4Braces(UserAns);
    if (retn==null) return null;
    UserAns = UserAns.replace(/,+/g, ",");
    UserAns = UserAns.replace(/,$/, "");
    UserAns = UserAns.replace(/^,/, "");
%    event.value = UserAns; % dps17
    CorrAns = stripWhiteSpace(CorrAns);
    if (!ok2Continue) return null;
    var aUserAns = UserAns.split(",");
    var aCorrAns = CorrAns.split(",");
    var numCorrect = 0, match = 0;
    if ( aUserAns.length != aCorrAns.length )
    return notifyField(false, flag, fieldname);
    for ( var i=0; i<aCorrAns.length; i++) {
        match = 0;
        for ( var j=i; j< aUserAns.length; j++) {
            var retn = _ProcResp(%
flag,aCorrAns[i],aUserAns[j],n,epsilon,domain,indepVars,oComp);
            if ( retn == -1 ) return null;
            if ( retn == null ) return syntaxError(), null;
            if (retn==1) {
                var temp=aUserAns[j];
                aUserAns[j]=aUserAns[i];
                aUserAns[i]=temp;
                match = match + 1;
            }
        }
        numCorrect += (match) ? 1 : 0;
    }
    var success = (numCorrect == aCorrAns.length);
    return notifyField(success, flag, fieldname);}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
% \subsubsection{\texttt{complex}}
% \IndexOpt{complex}The function \texttt{ProcRespComplex} supplies support for answers that are
% complex numbers. The function test whether there is exactly one \texttt{i}
% in the expression, if not, a message appears reminding the user that the form
% of a complex number is \texttt{a + bi}. The function adds \texttt{i} as one of the
% variables, and appends \texttt{x[0,1]} to the domain specification. This might be a
% problem if the document author uses the old style of specifying the domain; use
% \texttt{[a,b]} to specify the domain, we change this to \texttt{[a,b]x[0,1]}.
%
% The rest of the function is like a multiv-ariable problem. Seems to work ok.
% Here is a sample syntax:
%\begin{verbatim}
% $(3+3i)(4+5i) = \RespBoxMath{-3+27i}{3}{0.0001}{[0,1]}*{ProcRespComplex}$
%\end{verbatim}
%The correct answer must be supplied with the \cs{RespBoxMath}, and is used to compare
% with what the student enters.
% \changes{v1.7}{2007/10/12}
%{%
%   Added support for answer that are complex numbers.
%}
%    \begin{macrocode}
\@ifcheckedout{complex}
\newcommand{\complexPowerAlertMsg}{%
    "Powers of i (for example, i^2, i^3) are not supported,
    replace powers of i with their complex equivalents."}
\newcommand{\complexCisAlertMsg}{%
    "The cis function does not support exponents. Write,
    for example, cis^3(x) as cis(3*x), instead."}
\newcommand{\alertNotComplexMsg}{%
    "The expression is not in the form of a complex
    number, a+bi"}
\def\emptyCompComplexMsg(#1){%
    "You entered nothing for the component "
     +(#1+1)+" of your answer. Please enter a complex number."}
\fi
\begin{library@holding}{complex}
\begin{newsegment}{dljslib: Support for Complex Numbers}
%    \end{macrocode}
% Defined (11/11/08). The \texttt{cis} function is undefined unless the \texttt{complex} option is used.
%    \begin{macrocode}
function cis(x,i) { return Math.cos(x) + i*Math.sin(x); }
JSfCustom.push("cis");
JSf = JSf.concat(JSfBuiltIn, JSfCustom);
function ProcRespComplex(flag,CorrAns,n,epsilon,domain,indepVars,oComp)
{
    if (!ProcessIt) return null;
    ok2Continue = true;
    var i, success;
    var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
%    var UserAns = event.value;
    var bSubstVars=(arguments.length>7); // dps17
    var UserAns=(bSubstVars)?arguments[7]:event.value;
    CorrAns = stripWhiteSpace (CorrAns);
    UserAns = stripWhiteSpace (UserAns); // sets ok2Continue
    if ( !ok2Continue ) return null;
    indepVars+="i";
    domain+="x[0,1]";
%    \end{macrocode}
% We don't support powers of i
%    \begin{macrocode}
    if (/(\b|[^a-zA-Z])i\^/.test(UserAns)) {
        eqAppAlert(\complexPowerAlertMsg,3);
        return null;
    }
%    \end{macrocode}
% Powers of \texttt{cis} function are not supported at this time.
%    \begin{macrocode}
%    var re=/cis\^/
    if ( /cis\^/.test(UserAns) ) {
        eqAppAlert(\complexCisAlertMsg,3);
        return null;
    }
%    \end{macrocode}
% (2012/05/25) Check for commas, not permitted here.
% \changes{v1.9f}{2012/11/17}{Moved this block higher, before testing for comma.}
%    \begin{macrocode}
    var reComma=/,/;
    if ( reComma.test(UserAns) ) {
        eqAppAlert(\eqSyntaxErrorComma,3);
        return null;
    }
%    \end{macrocode}
% To make the \texttt{cis} function work, we've defined it to be a function of two variables,
% \texttt{cis(x,i)}, but the user does not need to know that. We search for \texttt{cis(<arg>)} and
% replace with \texttt{cis(<arg>,i)}. I hope this works.
%    \begin{macrocode}
    UserAns=changeArgs4Cis(UserAns);
%    \end{macrocode}
% ...and do the same thing for the correct answer.
%    \begin{macrocode}
    CorrAns=changeArgs4Cis(CorrAns);
%    \end{macrocode}
% The complex option is not meant to be an option to do complex arithmetic, but only
% to accept a complex number as an answer. So, we do not accept an answer with two
% or more i's in it.
%    \begin{macrocode}
    var aMatch = UserAns.match(/(\b|[^a-zA-Z])i/g);
    if ( aMatch != null && aMatch.length > 1) {
        eqAppAlert(\alertNotComplexMsg, 3);
        return null;
    }
    var comp = ( typeof oComp == "object" ) ?
       (typeof oComp.comp == "undefined" ) ?
            diffCompare : oComp.comp : oComp;
    if ( typeof oComp == "object" &&
        typeof oComp.priorParse != "undefined" ) {
        if ( typeof oComp.priorParse == "object" ) {
            for ( var i=0; i < oComp.priorParse.length; i++) {
                var retn = oComp.priorParse[i](UserAns);
                if ( retn == null ) return null;
            }
        } else {
            var retn = oComp.priorParse(UserAns);
            if ( retn == null ) return null;
        }
    }
%    \begin{macrocode}
    UserAns = ParseInput(UserAns);
    CorrAns = ParseInput(CorrAns);
    indepVars = TypeParameters(indepVars);
    if (!ok2Continue) return null;
    success=randomPointCompare(
        n,domain,indepVars,epsilon,CorrAns,UserAns,comp);
    if ( success == null ) { eqAppAlert(%
\eqSyntaxErrorUndefVar,3); return null; }
    return notifyField(success, flag, fieldname);
}
%    \end{macrocode}
% \texttt{ProcRespListComplex}, contributed by Bruce Wagner, extends
% \texttt{ProcRespComplex} to lists; an ordered listing of complex responses.
% Sample syntax:
%\begin{verbatim}
%If $z=4(\cos x+i\sin x)$, compute $z^2$ and $z^3$, in that order.
%\RespBoxMath{16*cis(2x),64*cis(3x)}{4}{0.0001}{[0,1]}*{ProcRespListComplex}
%\end{verbatim}
%    \begin{macrocode}
function ProcRespListComplex(flag,CorrAns,n,epsilon,%
domain,indepVars,oComp) {
    ok2Continue = true;
    if (!ProcessIt) return null;
    var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
%    var UserAns = event.value;
    var bSubstVars=(arguments.length>7); // dps17
    var UserAns=(bSubstVars)?arguments[7]:event.value;
    UserAns = stripWhiteSpace(UserAns);
    CorrAns = stripWhiteSpace(CorrAns); // sets ok2Continue
    if ( !ok2Continue ) return null;
    var isSpecResp=false;
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (CorrAns == aDlLibSpecResp[i]) {
            isSpecResp=true; break;
        }
    }
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (UserAns == aDlLibSpecResp[i]) {
            success = (CorrAns == UserAns);
            return notifyField(success, flag, fieldname);
        }
    }
    if (isSpecResp) return notifyField(false, flag, fieldname);
    UserAns = UserAns.replace(/,+/g, ",");
    UserAns = UserAns.replace(/,$/, "");
    UserAns = UserAns.replace(/^,/, "");
%    event.value = UserAns; % dps17
    var aUserAns = UserAns.split(",");
    var aCorrAns = CorrAns.split(",");
    if ( aUserAns.length != aCorrAns.length )
        return notifyField(false, flag, fieldname);
    var numCorrect = 0;
    var match = 0;
    for ( var i=0; i< aCorrAns.length; i++) {
        match = 0;
%          event.value = aUserAns[i]; % dps17
          var retn = ProcRespComplex(%
flag,aCorrAns[i],n,epsilon,domain,indepVars,oComp,aUserAns[i]);
%        event.value = UserAns; dps17
        if ( retn == null ) return null;
        numCorrect += (retn) ? 1 : 0;
    }
    var success = (numCorrect == aCorrAns.length);
    return notifyField(success, flag, fieldname);
}
%    \end{macrocode}
% \texttt{ProcRespSetComplex}, contributed by Bruce Wagner, extends
% \texttt{ProcRespComplex} to sets; an un-ordered listing of complex responses.
%\begin{verbatim}
% Find all real and complex solutions of the equation $x^2=-9$. \\
% Express your answer(s) in rectangular form $a+bi$.
% \RespBoxMath{3i,-3i}{4}{0.0001}{[0,1]}*{ProcRespSetComplex}
%\end{verbatim}
%    \begin{macrocode}
function ProcRespSetComplex(flag,CorrAns,n,epsilon,%
domain,indepVars,oComp) {
    ok2Continue = true;
    if (!ProcessIt) return null;
    var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
%    var UserAns = event.value;
    var bSubstVars=(arguments.length>7); // dps17
    var UserAns=(bSubstVars)?arguments[7]:event.value;
    UserAns = stripWhiteSpace(UserAns);
    CorrAns = stripWhiteSpace(CorrAns); // sets ok2Continue
    if ( !ok2Continue ) return null;
    var isSpecResp=false;
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (CorrAns == aDlLibSpecResp[i]) {
            isSpecResp=true; break;
        }
    }
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (UserAns == aDlLibSpecResp[i]) {
            success = (CorrAns == UserAns);
            return notifyField(success, flag, fieldname);
        }
    }
    if (isSpecResp) return notifyField(false, flag, fieldname);
    UserAns = UserAns.replace(/,+/g, ",");
    UserAns = UserAns.replace(/,$/, "");
    UserAns = UserAns.replace(/^,/, "");
    event.value = UserAns;
    CorrAns = stripWhiteSpace(CorrAns);
    if (!ok2Continue) return null;
    var aUserAns = UserAns.split(",");
    var aCorrAns = CorrAns.split(",");
    if ( aUserAns.length != aCorrAns.length )
        return notifyField(false, flag, fieldname);
    var numCorrect = 0;
    var match = 0;
    for ( var i=0; i< aCorrAns.length; i++) {
        match = 0;
        for ( var j=i; j< aUserAns.length; j++) {
%            event.value = aUserAns[j]; dps17
            var retn = ProcRespComplex(%
flag,aCorrAns[i],n,epsilon,domain,indepVars,oComp,aUserAns[j]);
%            event.value = UserAns; dps17
            if ( retn == null ) return null;
            if (retn==1) {
                var temp=aUserAns[j];
                aUserAns[j]=aUserAns[i];
                aUserAns[i]=temp;
                match = match + 1;
            }
        }
        numCorrect += (match) ? 1 : 0;
    }
    var success = (numCorrect == aCorrAns.length);
    return notifyField(success, flag, fieldname);
}
function changeArgs4Cis(str) {
    var re =/cis\(/g;
    while ( (aP=re.exec(str) ) != null ) {
        var LeftP=re.lastIndex;
        var RightP=FindBalP(str,re.lastIndex,1);
        str = str.substring(0,RightP)
            +",i"+str.substring(RightP);
    }
    return str;
}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
% \subsubsection{\texttt{satisfyEq}}
%
% \IndexOpt{satisfyEq} These functions are used for questions where the student is asked to enter one or more
% points that satisfy a given equation $ F = G $. For these types of problems, there
% are infinity many correct answers.
%
%    \begin{macrocode}
\@ifcheckedout{satisfyEq}
\newcommand{\notifyWrongNumEntries}{\def\satisfyEqNotify{true}}
\def\satisfyEqNotify{false}
\newcommand{\wrongNumEntriesMsg}{"You don't have the correct number
    of entries in your coordinate points. Expecting "+_n
    +" entries per point." }
\newcommand{\eqSyntaxErrorNoParens}{"Syntax Error: Enter the point
    using parentheses, for example (1,2) or (1,2,3), as applicable."}
\newcommand{\eqNonzeroEntries}{"Syntax Error: All entries are required
    to be nonzero, try again."}
\newcommand{\eqTooManyEntries}{"You've entered more points than
    requested, enter only "+l+" points."}
\newcommand{\eqTooFewEntries}{"You've entered fewer points than
    requested, enter only "+l+" points."}
\newcommand{\eqDuplEntries}{"One or more points are the same,
    provide "+l+" distinct points."}
\fi
\begin{library@holding}{satisfyEq}
\begin{newsegment}
    {dljslib: Support for n-tuple input to Satisfy an Equation}
%    \end{macrocode}
%\DescribeMacro{ProcRespEvalEq} is not based on random point generation, as
%all the other \textsf{exerquiz} functions are. Here, the user enters
%numerical data, the function then verifies the data entered satisfies the
%given equation. The role of \texttt{CorrAns} has changed. If the equation
%is $ F = G $, then $ F - G $ should be passed as the
%\texttt{CorrAns} variable. This function obeys the value of
%\texttt{epsilon} but ignores the number of iterations (\verb!{1}! below),
%and the domain of the variables (\cs{ixdna} below) \cs{ixdna} is a special
%command that can be used for this parameter, in this context only.  The \texttt{oComp}
%parameter is also ignored.
%\medskip\noindent\textbf{Sample Use.}
%\begin{verbatim}
%\item Enter a point that lies on the line $2x+3y=6$,\\[3pt]
%    $\text{A point is }\RespBoxMath[\rectW{.75in}
%    \textSize{0}]{2x+3y-6}(xy){1}{.0001}{[0,1]x[0,1]}*{ProcRespEvalEq}
%    \CorrAnsButton{various, such as (0,2)}$
%\end{verbatim}
% The demo document is \texttt{satisfy\_eq.tex}.
%\changes{v1.9}{2011/06/24}{Added \texttt{ProcRespEvalEq} in response to
% a problem posed by David Arnold.}
%    \begin{macrocode}
var bNotifyWrngNumEntries=\satisfyEqNotify;
function ProcRespEvalEq(flag,CorrAns,n,epsilon,domain,indepVars,oComp){
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
% dps17
    var UserAns=(arguments.length>7)?arguments[7]:event.value;
    var retn=_ProcRespEvalEq(true,flag,CorrAns,n,epsilon,%
indepVars,UserAns);
    return retn;
}
%    \end{macrocode}
% \DescribeMacro{ProcRespEvalEqNonZero} is the same as \texttt{ProcRespEvalEq}, but requires
% all entries to be nonzero.
%    \begin{macrocode}
function ProcRespEvalEqNonZero(flag,CorrAns,n,epsilon,%
domain,indepVars,oComp) {
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
    var UserAns=(arguments.length>7)?arguments[7]:event.value;
    var retn=_ProcRespEvalEq(false,flag,CorrAns,n,epsilon,
indepVars,UserAns);
    return retn;
}
%    \end{macrocode}
%    \begin{macrocode}
function _ProcRespEvalEq(allowzero,flag,CorrAns,n,epsilon,indepVars)
{
    ok2Continue = true;
    if (!ProcessIt) return null;
    var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
%    var UserAns = event.value;
    var bSubstVars=(arguments.length>6); // dps17
    var UserAns=(bSubstVars)?arguments[6]:event.value;
    UserAns = stripWhiteSpace(UserAns);
    if (!ok2Continue) return null;
    if ( (UserAns.charAt(0) != "\(") || %
(UserAns.charAt(UserAns.length-1) != "\)"))
        return eqAppAlert(\eqSyntaxErrorNoParens,3), null;
    UserAns=UserAns.substring(1,UserAns.length-1);
    var aUserAns = UserAns.split(",");
%    \end{macrocode}
% Make sure all of UserAns are numbers
%    \begin{macrocode}
    for ( var i=0; i < aUserAns.length; i++) {
        try {
            if (isNaN(eval(aUserAns[i]))) return syntaxError(), null;
            if (!allowzero && (eval(aUserAns[i])==0))
                return eqAppAlert(\eqNonzeroEntries,3), null;
        } catch(e) { return syntaxError(), null; }
    }
    var _v = TypeParameters(indepVars);
    var _V = _v.split(",");  // e.g. _V[0] = "i:x"
    var _n = _V.length;
    if ( aUserAns.length != _n) {
        if (bNotifyWrngNumEntries)
            return eqAppAlert(\wrongNumEntriesMsg,3), null;
        else
            return notifyField(false, flag, fieldname);
    }
%    \end{macrocode}
% The following code is taken from \texttt{diffCompare}, it uses a "safe" technique
% for evaluating an expression.
%    \begin{macrocode}
    for (var _i=0; _i < _n; _i++) {
        if (_V[_i].charAt(0) == "r" )
          eval("var "+_V[_i].charAt(2)+"="+aUserAns[_i]+";");
        else // assume type "i"
          eval("var "+_V[_i].charAt(2)+"="+Math.ceil(aUserAns[_i])+";");
    }
    var UserInput=ParseInput(CorrAns);
    var UserAns=eval(UserInput);
    success=(Math.abs(UserAns) < epsilon)?true:false;
    return notifyField(success, flag, fieldname);
}
%    \end{macrocode}
% This function takes a semi-colon delimited list of ordered n-tuples.
% The \texttt{CorrAns} parameter is of the form \texttt{n\_pairs; F-G}
%    \begin{macrocode}
function ProcRespEvalEqList(flag,CorrAns,n,epsilon,domain,%
indepVars,oComp) {
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
    var UserAns=(arguments.length>7)?arguments[7]:event.value;
    var retn=_ProcRespEvalEqList(true,flag,CorrAns,n,epsilon,%
indepVars,UserAns);
    return retn;
}
function ProcRespEvalEqListNonZero(flag,CorrAns,n,epsilon,domain,%
indepVars,oComp){
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
% dps17
    var UserAns=(arguments.length>7)?arguments[7]:event.value;
    var retn=_ProcRespEvalEqList(false,flag,CorrAns,n,epsilon,%
indepVars,UserAns);
    return retn;
}
function _ProcRespEvalEqList(allowzero,flag,CorrAns,n,epsilon,indepVars)
{
    ok2Continue = true;
    if (!ProcessIt) return null;
    var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
%    var UserAns = event.value;
    var bSubstVars=(arguments.length>6); // dps17
    var UserAns=(bSubstVars)?arguments[6]:event.value;
    UserAns = stripWhiteSpace(UserAns);
    if (!ok2Continue) return null;
    var success;
%    \end{macrocode}
% Remove any semicolons at end of line, then remove any duplicated semicolons.
% This is done to prevent simple errors by user input.
%    \begin{macrocode}
    UserAns=UserAns.replace(/;+$/,"");
    UserAns=UserAns.replace(/;+/g,";");
    var aUsersArray = new Array();
%    \end{macrocode}
% Split the user's answer up by the delimiting semi-colon.
%    \begin{macrocode}
    var aUserAns = UserAns.split(";");
%    \end{macrocode}
% First component is the number of points expected, second component is \texttt{F(x)-G(x)}
%    \begin{macrocode}
    var aCorrAns = CorrAns.split(";");
    var l = aCorrAns[0];
%    \end{macrocode}
% If the user gave too many answers, broadcast alert.
%    \begin{macrocode}
    if (l < aUserAns.length )
        return eqAppAlert(\eqTooManyEntries,3), null;
%    \end{macrocode}
% If the user gave too few answers, broadcast alert.
%    \begin{macrocode}
    if (l > aUserAns.length )
        return eqAppAlert(\eqTooFewEntries,3), null;
    var _v = TypeParameters(indepVars);
    var _V = _v.split(",");  // e.g. _V[0] = "i:x"
%    \end{macrocode}
% \texttt{\_n} is the number of variables
%    \begin{macrocode}
    var _n = _V.length;
%    \end{macrocode}
% \texttt{testFunc} is a random linear function of the form
% \texttt{ax+by+...}, where \texttt{a} and \texttt{b} are selected at random.
%    \begin{macrocode}
    var testFunc="";
    for (var _i=0; _i < _n; _i++)
        testFunc += ("+"+(Math.random()*9)+"*"+_V[_i].charAt(2));
%    \end{macrocode}
%\changes{v1.9d}{2012/05/13}{Introduced \texttt{iCorrect} variable}
% Introduced \texttt{iCorrect} variable to correct check each of the
% user's pairs of responses.
%    \begin{macrocode}
    var isCorrect=1;
    for (var pair=0; pair< l; pair++) {
%    \end{macrocode}
% We require each ordered pair to be enclosed in parentheses
%    \begin{macrocode}
        if ( (aUserAns[pair].charAt(0) != "\(") || %
(aUserAns[pair].charAt(aUserAns[pair].length-1) != "\)"))
                return eqAppAlert(\eqSyntaxErrorNoParens,3), null;
%    \end{macrocode}
% Strip away the parentheses, so for example, \texttt{UserAnsPair="3,5"}
%    \begin{macrocode}
        UserAnsPair=aUserAns[pair].substring(1,aUserAns[pair].length-1);
%    \end{macrocode}
% \texttt{aUserAnsPair} an the array that contains the components of
% \texttt{aUserAns[pair]}
%    \begin{macrocode}
        var aUserAnsPair = UserAnsPair.split(",");
%    \end{macrocode}
% See if each component is a number
%    \begin{macrocode}
        for ( var i=0; i < aUserAnsPair.length; i++) {
            try { if (isNaN(eval(aUserAnsPair[i]))) %
return syntaxError(), null;
%    \end{macrocode}
%\changes{v1.9d}{2012/05/13}{Corrected reference, changed
%\texttt{aUserAns} to \texttt{aUserAnsPair}}
% \texttt{(2012/05/13)} Corrected reference, changed \texttt{aUserAns} to \texttt{aUserAnsPair}
%    \begin{macrocode}
            if (!allowzero && (eval(aUserAnsPair[i])==0))
                return eqAppAlert(\eqNonzeroEntries,3), null;
            } catch(e) { return syntaxError(), null; }
        }
%    \end{macrocode}
% If the number of components does not match the number of variables, this is an
% error. Give the user a chance to correct it.
%    \begin{macrocode}
        if ( aUserAnsPair.length != _n) {
            if (bNotifyWrngNumEntries)
                return eqAppAlert(\wrongNumEntriesMsg,3), null;
            else
                return notifyField(false, flag, fieldname);
        }
%    \end{macrocode}
% Evaluate each component of the user's answer.
%    \begin{macrocode}
        for (var _i=0; _i < _n; _i++) {
            if (_V[_i].charAt(0) == "r" )
              eval ("var "+_V[_i].charAt(2)+"="+aUserAnsPair[_i]+";");
            else // assume type "i"
              eval ("var "+_V[_i].charAt(2)+"="%
+Math.ceil(aUserAnsPair[_i])+";");
        }
%    \end{macrocode}
% \texttt{UserInput} is misnamed, this is the answer the author provides,
% for example, \texttt{2x+3y-6}. We parse it, then evaluate it (using the values
% of the variables computed above.
%    \begin{macrocode}
        var UserInput=ParseInput(aCorrAns[1]);
        var UserAns=eval(UserInput);
%    \end{macrocode}
% We also evaluate the test function \texttt{testFunc} for the values of the
% variables computed above. We store the result in \texttt{aUsersArray}.
%    \begin{macrocode}
        aUsersArray[pair]=eval(testFunc);
%    \end{macrocode}
% If less than \texttt{epsilon}, we set \texttt{success} to \texttt{true},
% or we return \texttt{false}
%    \begin{macrocode}
        success=(Math.abs(UserAns) < epsilon)?true:false;
%    \end{macrocode}
% If \texttt{success} is true, we multiply by 1, else we multiply by 0
%    \begin{macrocode}
		isCorrect *=Number(success);
    }
%    \end{macrocode}
% If \texttt{isCorrect} is \texttt{1}, all comparisons were successful.
%    \begin{macrocode}
    success=(isCorrect==1);
%    \end{macrocode}
% Sort \texttt{aUsersArray} from least to greatest
%    \begin{macrocode}
    var aOrderArray = aUsersArray.sort(function(a,b){return a-b});
    var m = aUsersArray.length - 1;
%    \end{macrocode}
% See if any two consecutive entries differ by a little, if not, we'll
% say the two answers are the same and ask the user for distinct entries.
%    \begin{macrocode}
    for (i=0; i<m; i++)
        if (Math.abs(aUsersArray[i]-aUsersArray[i+1])<.0001)
            return eqAppAlert(\eqDuplEntries,3), null;
%    \end{macrocode}
% If we have not exited earlier, we exit now with \texttt{success} as \texttt{true} or \texttt{false}.
%    \begin{macrocode}
    return notifyField(success, flag, fieldname);
}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
% \subsubsection{\texttt{useGermanNums} (\texttt{useDeNums})}
% \leavevmode
% \IndexOpt{useGermanNums}A simple \texttt{ProcResp()} for processing numbers entered in a German format: 1234,56.
% The Germans have a block delimiter of period or space (1.234,56 or 1 234,56).
% The period is not supported and causes an alert box.
%\changes{v1.9g}{2014/01/14}{Added a proc to accept the comma for the decimal mark}
%\changes{v2.2}{2021/04/04}{Modified useGermanNums, created alias useDeNums}
%\changes{v2.2}{2021/04/04}{Modified proc to warn about English decimal point only}
%    \begin{macrocode}
\@ifcheckedout{useGermanNums}
%    \end{macrocode}
%\leavevmode\DescribeMacro{\noDecPtDeMsg} A general alert message for responses that
% contain a point (.).
%    \begin{macrocode}
  \dlJSStr[noquotes]{\noDecPtDeMsg}{%
    "German Notation Syntax Error: A point (.) was found
     in your response \"" + UserAns + "\".
     Please remove the point, or this answer will be marked as wrong."}
%    \end{macrocode}
%    \DescribeMacro{\MsgDei} An alert message when German decimal notation
%    is expected.
%    \begin{macrocode}
  \flJSStr*[noquotes]{\MsgDei}{"German decimal notation is expected,
for example: 12,3456."}
  \flJSStr*[noquotes]{\MsgDeiAlt}{"German decimal notation is expected,
for example: 12,3456." +((warnDecDeOnly)?"\n\n
The English decimal notation (12.2345) is also accepted,
however.":"")}
%    \end{macrocode}
%    \DescribeMacro{\MsgDeii} An alert message when two decimal places are expected.
%    \begin{macrocode}
  \flJSStr*[noquotes]{\MsgDeii}{"A decimal number is required,
rounded to two decimal places, for example: 12,34"}
%    \end{macrocode}
%    When \DescribeMacro{\warnDecDeOnlyOn}\cs{warnDefDeOnlyOn} is declared in the preamble, the use of
%    the decimal point (.) is accepted but a warning message appears. On the downside,
%    the student can enter \texttt{1.00,10}, which will, no doubt, lead to an
%    incorrect answer.
%    \begin{macrocode}
  \def\warnDecDeOnlyOn{\def\warnDecDeOnly{true}}
  \def\warnDefDeOnlyOff{\def\warnDecDeOnly{false}}
  \warnDefDeOnlyOff
%    \end{macrocode}
%    \DescribeMacro{\numDe}\nmpsep{\darg{\ameta{Msg}}} is a command that supports
%    the German decimal notation point (,). For this command, the decimal point (,)
%    is optional; that is, an integer response is accepted. \ameta{Msg} is a message
%    that appears on error of syntax.
%    \begin{macrocode}
  \def\numDe#1{{priorParse:\Array(%
    \preReqForm(/\rebstr\rechrclass{+-}?\redigit*,?%
    \redigit*\reestr/,(#1)))}}
%    \end{macrocode}
%    \DescribeMacro{\rndNumDeReq}\nmpsep{\darg{\ameta{nDec-pl}}\darg{\ameta{Msg}}}
%   For numbers that are required to be rounded to \emph{exactly} \ameta{nDec-pl} decimal places.
%   \ameta{Msg} is an error message. Decimal point (,) is required.
%    \begin{macrocode}
  \def\rndNumDeReq#1#2{{priorParse:\Array(%
    \preReqForm(/\rebstr\rechrclass{+-}?\redigit*,%
    \redigit{#1}\reestr/,(#2)))}}
%    \end{macrocode}
%    \DescribeMacro{\rndNumDeOpt}\nmpsep{\darg{\ameta{nDec-pl}}\darg{\ameta{Msg}}}
%   For numbers that are required to be rounded to \emph{at most} \ameta{nDec-pl} decimal places.
%   \ameta{Msg} is an error message. Decimal point (,) optional (integer respose
%   accepted).
%    \begin{macrocode}
  \def\rndNumDeOpt#1#2{{priorParse:\Array(% at most two decimal places
    \preReqForm(/\rebstr\rechrclass{+-}?%
    \redigit*,?\redigit{0,#1}\reestr/,(#2)))}}
\fi
\begin{library@holding}{useGermanNums}
\begin{newsegment}
    {dljslib: Support for process numbers in the German format}
%    \end{macrocode}
% \DescribeMacro{ProcRespNumsDe} This segment only has one ProcResp function in it,
% this is named \texttt{ProcRespNumsDe}.
%    \begin{macrocode}
var warnDecDeOnly=\warnDecDeOnly;
function ProcRespNumsDe (flag,CorrAns,n,epsilon,%
domain,indepVars,oComp) {
    if (!ProcessIt) return null;
    ok2Continue = true;
    var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
    var bSubstVars=(arguments.length>7);
    var UserAns=(bSubstVars)?arguments[7]:event.value;
%    \end{macrocode}
% This is the only change over the \texttt{ProcResp}, we call
% \texttt{\_ProcRespNumsDe}.
%    \begin{macrocode}
    var success = _ProcRespNumsDe(flag,CorrAns,UserAns,n,%
epsilon,domain,indepVars,oComp);
    if ( success == -1 || !ok2Continue ) return null;
    if ( success == null ) { return syntaxError(), null; }
    return notifyField(success, flag, fieldname);
}
function _ProcRespNumsDe(flag,CorrAns,UserAns,n,epsilon,%
domain,indepVars,oComp) {
    ok2Continue = true;
    CorrAns = ParseInput(CorrAns);
    if (!ok2Continue) {
        eqAppAlert(\SyntaxErrorAuthor,3);
        return null;
    }
%    \end{macrocode}
% Save \texttt{UserAns} as \texttt{UserAnsSave} and pass \texttt{UserAnsSave} to
% \texttt{processSpecialParse} instead of \texttt{UserAns}.
%    \begin{macrocode}
    var UserAnsSave=UserAns;
    var reDe=/,/g;
    var reDec=/\./g;
%    \end{macrocode}
% Deny use of the traditional decimal point (.)
%    \begin{macrocode}
    if ( (!warnDecDeOnly) && (reDec.test(UserAns)) ) {
        eqAppAlert(\noDecPtDeMsg,3);
        return -1;
    }
%    \end{macrocode}
% Replace all occurrences of \texttt{","} with \texttt{"."}, for internal use
%    \begin{macrocode}
    UserAns=UserAns.replace(reDe,".");
    var comp = ( typeof oComp == "object" ) ?
        (typeof oComp.comp == "undefined" ) ?
            diffCompare : oComp.comp : oComp;
    if ( (typeof(oComp)=="object") %
&& (typeof(oComp.priorParse)!="undefined") ) {
%    \end{macrocode}
% We pass \texttt{UserAnsSave} in case author uses \texttt{priorParse} etc.
%    \begin{macrocode}
        var retn=processSpecialParse(oComp.priorParse,UserAnsSave);
        if ( (!warnDecDeOnly) && (retn==null) ) return -1;
    }
%    var reComma=/,/;
%    if ( reComma.test(UserAns) ) {
%        eqAppAlert(\eqSyntaxErrorComma,3);
%        return -1;
%    }
    UserAns = ParseInput(UserAns);
    indepVars = TypeParameters(indepVars);
    if (!ok2Continue) return null;
    var success=randomPointCompare(n,domain,indepVars,%
epsilon,CorrAns,UserAns,comp);
        if ( success && (typeof(oComp)=="object") %
&& (typeof(oComp.postParse)!="undefined") )
        success=processSpecialParse(oComp.postParse,UserAns);
    return success;
}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
% The following functions, which are \texttt{ProcResp}-types, were written for an online
% grading system being developed by Drs.\ Bruce Wagner and David Arnold, and Mr.
% Jacob Miles-Prystowsky.  The descriptions given below were provided by the authors.
%
% \subsubsection{\texttt{useEnNums}}
% \leavevmode
% \IndexOpt{useEnNums}A simple \texttt{ProcResp()} for processing numbers entered in a EN-U format: 1234.56.
%    \begin{macrocode}
\@ifcheckedout{useEnNums}
%    \end{macrocode}
%\leavevmode\DescribeMacro{\noDecPtEnMsg} A general alert message for responses that
% contain a comma (,).
%    \begin{macrocode}
  \dlJSStr[noquotes]{\noDecPtEnMsg}{%
    "Syntax Error: A comma (,) was found
     in your response \"" + UserAns + "\".
     Please remove the comma, or this answer will be marked as wrong."}
%    \end{macrocode}
%    \DescribeMacro{\MsgEni} An alert message when German decimal notation
%    is expected.
%    \begin{macrocode}
  \flJSStr*[noquotes]{\MsgEni}{"English decimal notation is expected,
for example: 12.3456."}
%    \end{macrocode}
%    \DescribeMacro{\MsgEnii} An alert message when two decimal places are expected.
%    \begin{macrocode}
  \flJSStr*[noquotes]{\MsgEnii}{"A decimal number is required,
rounded to two decimal places, for example: 12.34"}
%    \end{macrocode}
%    \DescribeMacro{\numEn}\nmpsep{\darg{\ameta{Msg}}} is a command that supports
%    the En decimal notation point (.). For this command, the decimal point (.)
%    is optional; that is, an integer response is accepted. \ameta{Msg} is a message
%    that appears on error of syntax.
%    \begin{macrocode}
  \def\numEn#1{{priorParse:\Array(%
    \preReqForm(/\rebstr\rechrclass{+-}?\redigit*\\.?%
    \redigit*\reestr/,(#1)))}}
%    \end{macrocode}
%    \DescribeMacro{\rndNumEnReq}\nmpsep{\darg{\ameta{nDec-pl}}\darg{\ameta{Msg}}}
%   For numbers that are required to be rounded to \emph{exactly} \ameta{nDec-pl} decimal places.
%   \ameta{Msg} is an error message. Decimal point (.) is required.
%    \begin{macrocode}
  \def\rndNumEnReq#1#2{{priorParse:\Array(%
    \preReqForm(/\rebstr\rechrclass{+-}?\redigit*\\.%
    \redigit{#1}\reestr/,(#2)))}}
%    \end{macrocode}
%    \DescribeMacro{\rndNumEnOpt}\nmpsep{\darg{\ameta{nDec-pl}}\darg{\ameta{Msg}}}
%   For numbers that are required to be rounded to \emph{at most} \ameta{nDec-pl} decimal places.
%   \ameta{Msg} is an error message. Decimal point (.) optional (integer response
%   accepted).
%    \begin{macrocode}
  \def\rndNumEnOpt#1#2{{priorParse:\Array(% at most two decimal places
    \preReqForm(/\rebstr\rechrclass{+-}?%
    \redigit*\\.?\redigit{0,#1}\reestr/,(#2)))}}
\fi
%    \end{macrocode}
%    \begin{macrocode}
\begin{library@holding}{unordered}
%    \end{macrocode}
% \subsubsection{\texttt{unordered}}
% \IndexOpt{unordered}The \texttt{unordered} option is deprecated.
%    \begin{macrocode}
\begin{newsegment}{dljslib: Contrib - Processing Unordered Responses}
/*
** The ProcRespSetFormula function is now listed  under the
** setSupport option, titled 'dljslib: Support for Sets'
*/
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
%    \begin{macrocode}
\@ifcheckedout{factors}
\newcommand{\facNoPropForm}{"Factorization is not in the proper form,
    try placing the constant, if any, at the beginning of the
    factorization"}
\newcommand{\noNotEncloseMonos}{"Do not enclose constants or
    monomials in parentheses"}
\fi
\begin{library@holding}{factors}
%    \end{macrocode}
% \subsubsection{\texttt{factors}}
%  \IndexOpt{factors}\texttt{ProcRespFactors} is for grading polynomial factoring
%  questions. For example, if a polynomial factors as
%  \verb!-5x^2(x-4)(x+2)!, then the answer is only unique up to the order of
%  factors and a change of sign on an even number of factors. For
%  example, it could also be written as \verb!-5x^2(x+2)(x-4)! or
%  \verb!5x^2(-x+4)(x+2)! or \verb!-5(x-4)(x+2)x^2!, etc. This script
%  should grade all of these correctly. (However, it will not allow
%  something like \verb!-(x-4)(x+2)5x^2!. The leading coefficient, if
%  there is one, must be placed at the beginning, which conforms to
%  our usual conventions.)
%\begin{flushleft}
% Usage:
%\begin{verbatim}
%\def\factorsbox#1#2#3{%
%       \RespBoxMath{#1}(#2){4}{1.0E-15}{#3}*{ProcRespFactors}}
%Some question requiring a factored response
%\factorsbox{3x(x^2+1)(2x-1)^3}{x}{[0,1]}
%\end{verbatim}
%\end{flushleft}
% (2014/08/08) Rewrote portions of Bruce's code,
% introduce the \texttt{getFactorArray} function, giving better
% parsing and error feedback.
%\changes{v1.9j}{2014/08/08}{Rewrote portions of Bruce's code,
% introduce the function \texttt{getFactorArray}, giving better
% parsing and error feedback.}
%    \begin{macrocode}
\begin{newsegment}{dljslib: Contrib - Processing Factors as Responses}
function ProcRespFactors(flag,CorrAns,n,epsilon,domain,indepVars,oComp)
{
    ok2Continue = true;
    if (!ProcessIt) return null;
    var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
%    var UserAns = event.value;
    var bSubstVars=(arguments.length>7); // dps17
    var UserAns=(bSubstVars)?arguments[7]:event.value;
    UserAns = stripWhiteSpace(UserAns);
    if (!ok2Continue) return null;
    var retn = _ProcResp(flag,CorrAns,UserAns,n,epsilon,%
domain,indepVars,oComp);
    if ( retn == -1 ) return null;
    if ( retn == null ) return syntaxError(), null;
    if ( retn == 0 ) {
        var initialsuccess = false;
        return notifyField(initialsuccess, flag, fieldname);
    }
    var aUserAns=new Array();
    var aCorrAns=new Array();
    var aNegCorrAns=new Array();
    aUserAns=getFactorArray(UserAns);
    if (aUserAns==null) {
        eqAppAlert(\facNoPropForm, 3);
        return null;
    }
    if (aUserAns==-1) return null;
    aCorrAns=getFactorArray(CorrAns);
    if ( aCorrAns==null) {
        app.beep(); console.show();
        console.println("Author error in factorization, its not in %
the proper form");
        return null;
    }
    for ( var i=0; i< aCorrAns.length; i++) {
        aNegCorrAns[i] = "-" + "(" + aCorrAns[i] + ")"}
    var numCorrect = 0, match=0,signflag=0;
    if ( aUserAns.length != aCorrAns.length )
        return notifyField(false, flag, fieldname);
    for ( var i=0; i< aCorrAns.length; i++) {
        match = 0;
        for ( var j=i; j< aUserAns.length; j++) {
            var retn = _ProcResp(flag,aCorrAns[i],aUserAns[j],%
n,epsilon,domain,indepVars,oComp);
            if ( retn == -1 ) return null;
            if ( retn == null ) return syntaxError(), null;
            if (retn==1) {
                var temp=aUserAns[j];
                aUserAns[j]=aUserAns[i];
                aUserAns[i]=temp;
                match = match + 1;
            }
            else {
                var retn = _ProcResp(flag,aNegCorrAns[i],aUserAns[j],%
n,epsilon,domain,indepVars,oComp);
                if ( retn == -1 ) return null;
                if ( retn == null ) return syntaxError(), null;
                if (retn==1) {
                    var temp=aUserAns[j];
                    aUserAns[j]=aUserAns[i];
                    aUserAns[i]=temp;
                    match = match + 1;
                    signflag = signflag + 1;
                }
            }
        }
        numCorrect += (match) ? 1 : 0;
    }
    var success = ((numCorrect==aCorrAns.length)&&(signflag\%2==0));
    if ( success == null ) return syntaxError(), null;
    return notifyField(success, flag, fieldname);
}
%    \end{macrocode}
% This function identifies the factors of a factored polynomial, does some
% rearrangement, and returns an array of the factors.
%    \begin{macrocode}
function getFactorArray(str) {
    var aFactors=new Array();
    var i,j,front,factor,back,bInitGrped=true;
%    \end{macrocode}
% First, see of the first factor is grouped.
%    \begin{macrocode}
    if (str.charAt(0) != "\(" ) {
%    \end{macrocode}
% Not grouped, we'll scan forward for the next left paren and
% push the whole thing onto aFactors.
%    \begin{macrocode}
        bInitGrped=false;
        i=str.indexOf("\(");
        if ( i != -1 ) {
            aFactors.push(str.substring(0,i));
%console.println("Initial factor: "+ str.substring(0,i));
%    \end{macrocode}
% Reset the string, removing what we've pushed onto aFactos
%    \begin{macrocode}
            str=str.substring(i);
%console.println("new str="+str);
        }
    }
%var scan=0
%    \end{macrocode}
% We now identify grouped factors, push them onto the aFactors array
% and reset the string.
%    \begin{macrocode}
    while ( (i=str.indexOf("\(")) != -1 ) {
%console.println("scan "+(++scan));
        j=FindBalP(str,i,true);
        front=str.substring(0,i);
        factor=str.substring(i,j+1);
        back = str.substring(j+1);
%    \end{macrocode}
% See if this factor has multiplicities, if so, combine it with the factor
% and push onto aFactors
%    \begin{macrocode}
        if ( back.charAt(0) == "\^" ) {
            getExp=back.match(/\^\d+/);
            theExp=back.substring(0,getExp[0].length);
            factor+=(theExp);
            aFactors.push(factor);
%console.println("Adding factor: " + factor);
            back=back.substring(getExp[0].length);
        } else {
            aFactors.push(factor);
%console.println("Adding factor: " + factor);
        }
        str=front + back;
%console.println("new str="+str);
%    \end{macrocode}
% Before we finish with this factor, we'll check whether this is an
% enclosed monomial eg \verb!(-2x^2)!, the sign may not be present, but
% we need to test for it. We test for a sign, and beyond that, we search
% \texttt{+/-}. If we find \texttt{+/-}, we emit an warning box and we
% return a \texttt{-1}, same as null, but indicates an alert has been given.
%    \begin{macrocode}
        if ( factor.charAt(1)=="-" || factor.charAt(1)=="+" )
            factor=factor.substring(2);
        if (!/[+-]/.test(factor)) {
            eqAppAlert(\noNotEncloseMonos, 3);
            return -1;
        }
    }
%console.println("finished with scan step");
%    \end{macrocode}
% Added the initial un-grouped factor and exhausted all grouped factors
% what's left over is out of place
%    \begin{macrocode}
    if (/[A-Za-z]/.test(str)) {
%    \end{macrocode}
% want to pluck off the variable with optional power only, any constant
% is misplaced
%    \begin{macrocode}
        var aExp = str.match(/[A-Za-z](\^\d+)*/);
        factor=aExp[0];
        i=aExp.index;
        front=str.substring(0,i);
        back=str.substring(i+factor.length);
        str=front+back;
        if (!bInitGrped) {
            if (aFactors[0]=="-" || aFactors[0]=="+")
                aFactors[0]=aFactors[0]+factor;
            else
                aFactors[0]="\("+aFactors[0]+"\)"+"\("+factor+"\)";
%console.println("Modified first factor: " + aFactors[0]);
        } else {
            aFactors.push(str);
%console.println("adding factor: " +str);
            str="";
        }
    }
%    \end{macrocode}
% finally be sure this factor is not just a \texttt{"+"} or \texttt{"-"}
%    \begin{macrocode}
    if (aFactors[0]=="-"||aFactors[0]=="+"||isFinite(aFactors[0])){
        factor=aFactors.shift();
        aFactors[0]=factor+aFactors[0];
    }
%console.println("aFactors: " + aFactors.toSource());
%console.println("Final str="+str);	
%    \end{macrocode}
% If \texttt{str} is non-empty, that usually means there is a constant left over
% that was misplaced in the middle or end of the factorization. Otherwise, we return
% the aFactors array.
%    \begin{macrocode}
    return (str!="") ? null : aFactors
}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
%    \begin{macrocode}
\@ifcheckedout{point}
\newcommand{\pointErrorMsgi}{%
    "I'm looking for a point. You need to use proper point notation."}
\newcommand{\pointErrorMsgii}{"Parentheses are not balanced."}
\newcommand{\pointErrorMsgiii}{"Incorrect number of components.
    The answer requires "+ aCorrAns.length+" components."}
\def\pointEmptyCompMsgiv(#1){
    "You entered nothing for the component " +(#1+1)
        +" of your answer. Please enter a component for the point."}
\fi
\begin{library@holding}{point}
%    \end{macrocode}
% \subsubsection{\texttt{point}}
%  \IndexOpt{point}The JS function \texttt{ProcPoint} is an almost exact copy of your
%  \texttt{ProcVec}, but uses parentheses instead of angle brackets as
%  delimiters. This is for questions that have a point $(x,y)$ as the
%  answer.
%\begin{flushleft}
% Usage:
%\begin{verbatim}
%\def\formulapointbox#1#2#3{%
%       \RespBoxMath{#1}(#2){4}{1.0E-15}{#3}*{ProcPoint}}
%Some question requiring a point (ordered pair) response
%\formulapointbox{(e^t,te^t)}{t}{[0,1]}
%\end{verbatim}
%\end{flushleft}
%    \begin{macrocode}
\begin{newsegment}{dljslib: Contrib - Processing a Point Response}
function ProcPoint(flag,CorrAns,n,epsilon,domain,indepVars,oComp)
{
    if (!ProcessIt) return null;
    ok2Continue = true;
    var i, success, truthCnt=1;
    var aScalar, scalar = 1;
    var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
%    var UserAns = event.value;
    var bSubstVars=(arguments.length>7); // dps17
    var UserAns=(bSubstVars)?arguments[7]:event.value;
    UserAns = stripWhiteSpace (UserAns); // sets ok2Continue
    CorrAns = stripWhiteSpace(CorrAns);
    if ( !ok2Continue ) return null;
    var isSpecResp=false;
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (CorrAns == aDlLibSpecResp[i]) {
            isSpecResp=true; break;
        }
    }
    for ( var i=0; i<aDlLibSpecResp.length; i++) {
        if (UserAns == aDlLibSpecResp[i]) {
            success = (CorrAns == UserAns);
            return notifyField(success, flag, fieldname);
        }
    }
    if (isSpecResp) return notifyField(false, flag, fieldname);
    if (!/[()]/.test(UserAns)) {
        return eqAppAlert(\pointErrorMsgi, 3), null;
    }
    if (!CkBalP(UserAns,"(",")")) {
        return eqAppAlert(\pointErrorMsgii, 3), null;
    }
%    \end{macrocode}
% If \texttt{oComp} is an object, then see if it has a \texttt{comp} property
%    \begin{macrocode}
    var comp = ( typeof oComp == "object" ) ?
       (typeof oComp.comp == "undefined" ) ?
            diffCompare : oComp.comp : oComp;
    CorrAns = CorrAns.replace(/[()]/g, ""); // strip off ( and )
    UserAns = UserAns.replace(/[()]/g, "");
%    \end{macrocode}
% The \texttt{comp} parameter, which has been changed to \texttt{oComp} can now be
% an object. One property of this object is \texttt{comp}, handled above. Another
% property is \texttt{priorParse}, this is a function that returns \texttt{null}
% or \texttt{true}. This \texttt{priorParse} function allows for additional
% filtering of the \texttt{UserAns} before parsing. If it returns \texttt{true},
% we are ok to continue, if \texttt{null}, we don't like something the user has entered,
% and ask him/her to change it.
%    \begin{macrocode}
    if ( typeof oComp == "object" &&
        typeof oComp.priorParse != "undefined" ) {
%    \end{macrocode}
% Let's go ahead and allow \texttt{oComp.priorParse} be an array of functions.
%    \begin{macrocode}
        if ( typeof oComp.priorParse == "object" ) {
            for ( var i=0; i < oComp.priorParse.length; i++) {
                var retn = oComp.priorParse[i](UserAns);
                if ( retn == null ) return null;
            }
        } else {
            var retn = oComp.priorParse(UserAns);
            if ( retn == null ) return null;
        }
    }
% Not convert each to an array
    aUserAns = UserAns.split(",");
    aCorrAns = CorrAns.split(",");
    if (scalar != 1)
        for (i=0; i<aUserAns.length; i++)
            aUserAns[i]=""+scalar+"*"+aUserAns[i];
    if (aCorrAns.length != aUserAns.length) {
        eqAppAlert(\pointErrorMsgiii,3);
        return null;
    }
    indepVars = TypeParameters(indepVars);
    for (i=0; i<aCorrAns.length; i++) {
        aCorrAns[i] = ParseInput(aCorrAns[i]);
        if (!ok2Continue) {
            eqAppAlert(\SyntaxErrorAuthor, 3);
            return null;
        }
        aUserAns[i] = ParseInput(aUserAns[i]);
        if (aUserAns[i]==null) {
            eqAppAlert(\pointEmptyCompMsgiv(i), 3);
            return null;
        }
        if (!ok2Continue) return null;
        success=randomPointCompare (
            n,domain,indepVars,epsilon,aCorrAns[i],aUserAns[i],comp)
        if ( success == null ) {
            eqAppAlert(\eqSyntaxErrorUndefVar,3); return null; }
        truthCnt *= (success) ? 1 : 0;
%-        if (success) truthCnt +=1;
    }
%    return notifyField((truthCnt == 3), flag, fieldname);
    return notifyField(!!truthCnt, flag, fieldname);
}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
%    \begin{macrocode}
\begin{library@holding}{intervals}
%    \end{macrocode}
% \subsubsection{\texttt{intervals}}
%  \IndexOpt{intervals}\texttt{ProcRespIntervals} is for grading questions that have an
%  interval or union of intervals as the answer. Example answers
%  include:
%\begin{verbatim}
%(2,3)
%[2,3]
%(-inf,4)
%(-inf,4]
%(6,inf)
%[6,inf)
%(2,3)U[8,9)
%(-inf,6)U(9,inf)
%(-inf,6]U[7,8)U(9,inf)
%\end{verbatim}
%  Here I've used "inf" for infinity and the capital letter "U" for
%  the union symbol. Note also that intervals in a union can appear
%  in any order.
%\begin{flushleft}
%The \texttt{ProcRespIntervals} function has been modified by Robert Marik
%to allow intervals with end points \texttt{ln(2)}, \texttt{exp(4)} or \texttt{sqrt(3)}.
%Thus, intervals of the form
%\verb!(ln(2),ln(3)]U(exp(10),inf)! are recognized by this procedure.
%\medskip\noindent
% Usage:
%\begin{verbatim}
%\def\intervalbox#1{\RespBoxMath{#1}(infU){10}
%    {1.0E-4}{\viidna}*{ProcRespIntervals}}
%Some question requiring an interval or union of intervals
%\intervalbox{(-inf,4]U[5,inf)}
%\end{verbatim}
% To avoid problems with unbalanced parentheses, as in this example,
%\verb!\intervalbox{(-inf,4)U[5,inf)}!.
% Here there is only one right parenthesis and two left parentheses. As a
% workaround, escape the odd
% parenthesis, like so
%\verb!\intervalbox{(-inf,4)U[5,inf\eqbs)}!,
% where \cs{eqbs} is defined in the \textsf{insdljs} package.
%\end{flushleft}
%    \begin{macrocode}
\begin{newsegment}{dljslib: Contrib - Processing Interval Responses}
function ProcRespIntervals(flag,CorrAns,n,epsilon,domain,%
indepVars,oComp)
{
     ok2Continue = true;
     if (!ProcessIt) return null;
     var fieldname = event.target.name;
%    \end{macrocode}
%     Modified for multi-letter variables: remove one line, insert two. (2017/08/09)
%    \begin{macrocode}
%    var UserAns = event.value;
    var bSubstVars=(arguments.length>7); // dps17
    var UserAns=(bSubstVars)?arguments[7]:event.value;
     UserAns = stripWhiteSpace(UserAns);
     CorrAns = stripWhiteSpace(CorrAns);
     if (!ok2Continue) return null;
     UserAns = UserAns.replace(/inf/g, "x");
     CorrAns = CorrAns.replace(/inf/g, "x");
     indepVars = "x";
     domain="[0,1]";
     var aUserAns = UserAns.split("U");
     var aCorrAns = CorrAns.split("U");
     var numCorrect = 0;
     var match = 0;
     var matchparts = 0;
     if ( aUserAns.length != aCorrAns.length )
        return notifyField(false,flag, fieldname);
     for ( var i=0; i< aCorrAns.length; i++) {
         match = 0;
         for ( var j=i; j< aUserAns.length; j++) {
             CorrInt=aCorrAns[i];
             UserInt=aUserAns[j];
             var levaUser = UserInt.charAt(0);
             var pravaUser = UserInt.charAt(UserInt.length-1);
             var stredUser = UserInt.substring(1,UserInt.length-1);
             UserInt = levaUser+","+stredUser+","+pravaUser;
             var levaCorr = CorrInt.charAt(0);
             var pravaCorr = CorrInt.charAt(CorrInt.length-1);
             var stredCorr = CorrInt.substring(1,CorrInt.length-1);
             CorrInt = levaCorr+","+stredCorr+","+pravaCorr;
             var aCorrInt = CorrInt.split(",");
             var aUserInt = UserInt.split(",");
             if ( aUserInt.length != 4 )
                return notifyField(false, flag, fieldname);
             matchparts = 0;
             if (aCorrInt[0] == aUserInt[0]) matchparts+=1;
             if (aCorrInt[3] == aUserInt[3]) matchparts+=1;
             var retn1 = _ProcResp(flag,aCorrInt[1],aUserInt[1],%
n,epsilon,domain,indepVars,oComp);
             if (retn1 == -1 ) return null;
             if (retn1 == null) return syntaxError(), null;
             if (retn1 == 1) matchparts+=1;
             var retn2 = _ProcResp(flag,aCorrInt[2],aUserInt[2],%
n,epsilon,domain,indepVars,oComp);
             if (retn2 == -1 ) return null;
             if (retn2 == null) return syntaxError(), null;
             if (retn2 == 1) matchparts+=1;
             if (matchparts == 4) {
                 var temp=aUserAns[j];
                 aUserAns[j]=aUserAns[i];
                 aUserAns[i]=temp;
                 match = match + 1;
             }
         }
         numCorrect += (match) ? 1 : 0;
     }
     var success = (numCorrect == aCorrAns.length);
     return notifyField(success, flag, fieldname);
}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
%
% \subsection{Compare Functions}\label{s:compfunctions}
%
% \textbf{Used by Exerquiz.}   A compare function is a JavaScript that compares the author's answer
% with the user's answer. There may be a need for compare functions other than the default one provided
% by \texttt{exerquiz}.
%
% \subsubsection{\texttt{indefIntegral}}\label{indefIntegral}
% \IndexOpt{indefIntegral}The answer to an indefinite integral is non-unique; however all answers differ by a constant.
% This compare function is used with indefinite integrals. See \texttt{jqzspec.tex} for an
% example of the use of this function. Note the name of the function is \texttt{indefCompare}, this
% is the name you use to call the function. An example of usage of this function can be found in
% the sample file \texttt{jslib\_ex.tex} that comes with the Acro\TeX{} Bundle; from that file we
% have:
%\begin{verbatim}
%$\displaystyle\int\sin(x)\,dx =
%    \RespBoxMath{-cos(x)}[intSin]{4}{.0001}{[0,1]}[indefCompare]$
%\end{verbatim}
% See also the file \texttt{jqzspec.tex} for more details.
%    \begin{macrocode}
\begin{library@holding}{indefIntegral}
\begin{newsegment}{dljslib: Indefinite Integral Handling}
function indefCompare(_a,_c,_v,_F,_G) {
    var eqC;
    var aAB = _a.split(",");
    var aXY = _c.split(",");
    var _V = _v.split(",");  // e.g. _V[0] = "i:x"
    var _n = aXY.length
        for (var _i=0; _i< _n; _i++) {
            if (_V[_i].charAt(0) == "r" )
                eval ( "var "+ _V[_i].charAt(2)
                    + " = " + aAB[2*_i] + ";");
            else // assume type "i"
                eval ( "var "+ _V[_i].charAt(2)
                    + " = " + Math.ceil(aAB[2*_i]) + ";");
        }
% var C = 0 is used to designate an arbitrary constant
        var C = 0;
        if ( app.viewerVersion >= 5)
        {
            var rtnCode = 0;
            eval("try {if (isNaN(eqC = eval(_F)-eval(_G))) rtnCode=-1;}"
                +" catch (e) { rtnCode=1; }");
            switch(rtnCode)
            {
                case  0: break;
                case  1: return null;
                case -1: return -1;
            }
        }
        else
            if (isNaN(eqC = eval(_F)-eval(_G))) return -1;
        for (var _i=0; _i< _n; _i++)
        {
            if (_V[_i].charAt(0) == "r" )
                eval ( "var "+ _V[_i].charAt(2)
                    + " = " + aXY[_i] + ";");
            else // assume type "i"
                eval ( "var "+ _V[_i].charAt(2)
                    + " = " + Math.ceil(aXY[_i]) + ";");
        }
        _F = eval(_F);
        if ( app.viewerVersion >= 5)
        {
            var rtnCode = 0;
            eval("try { if(isNaN(_G = eval(_G))) rtnCode=-1; }"
                +" catch (e) { rtnCode=1; }");
            switch(rtnCode)
            {
                case  0: break;
                case  1: return null;
                case -1: return -1;
            }
        }
        else
            if(isNaN(_G = eval(_G))) return -1;
        return Math.abs( _F - _G - eqC );
}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
%
% \subsection{Filter User's Responses}
% The following two function were contributed by Ross Moore and Frances
% Griffin, and were taken from their
% \href{http://rutherglen.ics.mq.edu.au/~macqtex/}{MacQ\TeX} online testing
% system. See the sample file \texttt{integer\_tst.tex} for sample usage.
% These two functions take \texttt{UserAns} as a parameter and return
% \texttt{null} or \texttt{true} to signal the user expression is not an
% acceptable response, or that it's ok for processing, respectively.
%    \begin{macrocode}
\@ifcheckedout{nodec}
\newcommand\nodecAlertMsg{%
    "A decimal answer is not acceptable here.
     Please express your answer using fractions, square roots,
     e, log, etc."}
\fi
\begin{library@holding}{nodec}
%    \end{macrocode}
% \subsubsection{\texttt{nodec}}
% \IndexOpt{nodec}Do not allow the use of decimal numbers. (Just searches of ``.''.)
%    \begin{macrocode}
\begin{newsegment}{dljslib: Contrib - No Decimals}
function nodec(UserAns)
{
    var dot = /[\.\aebdecimalpoint]/;
    if (dot.test(UserAns)) {
        eqAppAlert(\nodecAlertMsg,3);
        return null;
    } else return true;
}
\end{newsegment}
%    \end{macrocode}
%    \begin{macrocode}
\end{library@holding}
\@ifcheckedout{noBinFac}
\newcommand\noBinFactBinCoeffAlertMsg{%
    "You may not use this notation here.
     Please evaluate the binomial coefficient.
     You may present your answer as a product rather
     than calculating a very large number."}
\newcommand\noBinFactPermAlertMsg{%
    "You may not use this notation here.
     Please evaluate the permutation.
     You may present your answer as a product rather
     than calculating a very large number."}
\newcommand\noBinFactFactAlertMsg{%
    "You may not use this notation here.
     Please evaluate the factorial.
     You may present your answer as a product rather
     than calculating a very large number."}
\fi
\begin{library@holding}{noBinFac}
%    \end{macrocode}
% \subsubsection{\texttt{noBinFac}}
% \IndexOpt{noBinFac}Disallow binomial coefficients and factorials in math fill-ins.
%    \begin{macrocode}
\begin{newsegment}{dljslib: Contrib - No Binomial Coefficients Allowed}
aReFact = new Array(
    /(?=\()?(\d+)(?=\))?!/,
    /(?=\[)?(\d+)(?=\])?!/,
    /(?=\{)?(\d+)(?=\})?!/
);
function noBinFac(UserAns)
{
    var bad = /(C\()/;
    if (bad.test(UserAns)) {
        eqAppAlert(\noBinFactBinCoeffAlertMsg,3);
        return null;
    }
    bad = /(P\()/;
    if (bad.test(UserAns)) {
        eqAppAlert(\noBinFactPermAlertMsg,3);
        return null;
    }
    for ( var i=0; i<aReFact.length; i++) {
        if (aReFact[i].test(UserAns)) {
            eqAppAlert(\noBinFactFactAlertMsg,3);
            return null;
        }
    }
    bad = /(fact)/;
    if (bad.test(UserAns)) {
        eqAppAlert(\noBinFactFactAlertMsg,3);
        return null;
    }
    return true
}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
%    \begin{macrocode}
\@ifcheckedout{limitArith}
\newcommand{\allowWrngNormSciNotn}{\def\allowWrngNSN{true}}
\def\allowWrngNSN{false}
\newcommand{\DecimalsOnlyErrorMsg}{%
    "Enter only an integer, e.g., 17, or a decimal number, e.g. 12.4.
    Using arithmetic operations or built in function is not acceptable
    for this problem."}
\newcommand{\NoProductsErrorMsg}{%
    "Multiplication is not allowed for this problem."}
\newcommand{\NoDivisionErrorMsg}{%
    "Division is not allowed for this problem."}
\newcommand{\NoAddOrSubErrorMsg}{%
    "Neither addition nor subtraction is allowed for this problem."}
\newcommand{\NoExpAllowedErrorMsg}{%
    "The use of exponents is not allowed for this problem."}
\newcommand{\NoTrigAllowedErrorMsg}{%
    "The use of trig functions in this problem is not allowed."}
\newcommand{\NoPiAllowedErrorMsg}{%
    "The use of PI or pi is not allowed in this problem."}
\newcommand{\NoTrigLogAllowedErrorMsg}{%
    "The use of trig and log functions is not allowed
        in this problem."}
\newcommand{\sciNotSyntaxError}{"Enter the answer in
    scientific notation."}
\newcommand{\sciNotNormalForm}{"The scientific notation entered
    is not in normalized form."}
\newcommand{\NoNegExpMsg}{"No negative exponents permitted,
    keep working!"}
\fi
\begin{library@holding}{limitArith}
%    \end{macrocode}
% \subsubsection{\texttt{limitArith}}
% \IndexOpt{limitArith}A collection of functions to limit the use of the arithmetic operations and to limit
% the use of the trig functions. These functions are called through an optional parameter
% of \cs{RespBoxMath}, as illustrated below and in the demo document \texttt{limarith.tex}.
%    \begin{macrocode}
\begin{newsegment}{dljslib: Limit Arithmetic and Built in Functions}
%    \end{macrocode}
% The \texttt{DecimalsOnly} is a function that takes only numbers, either integer or decimal.
% Usage
%\begin{verbatim}
% $ 2.3 + 4.5=\RespBoxMath[\rectW{.75in}\textSize{0}]{6.8}{1}{.0001}{[0,1]}
%    [{priorParse: DecimalsOnly }]\CorrAnsButton{6.8}$
%\end{verbatim}
%    \begin{macrocode}
function DecimalsOnly(UserAns) {
    UserAns  = stripWhiteSpace(UserAns);
    if ( !ok2Continue ) return null;
    if( !isFinite( UserAns ) ) {
        eqAppAlert(\DecimalsOnlyErrorMsg,3);
        return null;
    }
    return true;
}
%    \end{macrocode}
% The function \texttt{NoProducts} requires that \texttt{ImplMulti} be taken.
% An example of usage is
%\begin{verbatim}
%$ 3/4 = \RespBoxMath[\rectW{.75in}\textSize{0}]{.75}{1}{.0001}{[0,1]}
%    [{priorParse: new Array(NoDivision, NoProducts) }]\CorrAnsButton{.75}$
%\end{verbatim}
% In the above example, we first call \texttt{NoDivision} then \texttt{NoProducts}. This is
% the way you can chain these filtering functions together.
%    \begin{macrocode}
function NoProducts (UserAns) {
    // Requires the ImplMulti option of dljslib
    UserAns  = stripWhiteSpace(UserAns);
    if ( !ok2Continue ) return null;
    UserAns = Ck4Products(UserAns);
    if ( /\*/.test( UserAns ) )
        return eqAppAlert(\NoProductsErrorMsg,3), null;
    return true;
}
function NoDivision (UserAns) {
    if ( /\//.test( UserAns) )
        return eqAppAlert(\NoDivisionErrorMsg,3), null;
    return true;
}
%    \end{macrocode}
% This function, as the name implies, denies the use of both addition and subtraction.
% The algorithm I use here is that if a plus or minus follows anything but a left parenthesis,
% we assume it is a binary operation of addition or subtraction, respectively.
%\begin{verbatim}
%$ 5.1 - 3.2 = \RespBoxMath[\rectW{.75in}\textSize{0}]{1.9}{1}{.0001}{[0,1]}
%       [{priorParse: NoAddOrSub }]\CorrAnsButton{1.9}$
%\end{verbatim}
%    \begin{macrocode}
function NoAddOrSub (UserAns) {
    UserAns  = stripWhiteSpace(UserAns);
    if ( !ok2Continue ) return null;
    UserAns=ChngAllGrpsToParens(UserAns);
    var result;
    var re = /.[+-]/g;
    re.lastIndex = 0;
    while ( (result = re.exec( UserAns )) != null ) {
        if ( result[0].charAt(0) != "\(" )
            return eqAppAlert(\NoAddOrSubErrorMsg,3), null;
    }
    return true;
}
%    \end{macrocode}
% Deny user the use of all arithmetic functions, including exponents.
%    \begin{macrocode}
function NoArithAllowed (UserAns) {
    var aNoArithmetic = new Array ( NoAddOrSub, NoProducts,
        NoDivision, NoExpAllowed );
    for ( var i = 0; i < aNoArithmetic.length; i++ )
        if ( (retn = aNoArithmetic[i](UserAns)) == null ) return null;
    return true;
}
%    \end{macrocode}
% Deny user the use of exponents.
%    \begin{macrocode}
function NoExpAllowed (UserAns) {
    // Requires the ImplMulti option of dljslib
    UserAns  = stripWhiteSpace(UserAns);
    if ( !ok2Continue ) return null;
    if ( /\^/.test( UserAns ) || /pow/.test( UserAns ) )
        return eqAppAlert(\NoExpAllowedErrorMsg,3), null;
    return true;
}
%    \end{macrocode}
% Deny user the use all trig functions, as well as the constants \texttt{PI} and \texttt{pi},
% which are aliases for $\pi$. Example:
%\begin{verbatim}
%$ \sin(\pi/4) = \RespBoxMath[\rectW{.75in}\textSize{0}]
%    {sqrt(2)/2}{1}{.0001}{[0,1]}[{priorParse: NoTrigAllowed }]
%    \CorrAnsButton{sqrt(2)/2}$
%\end{verbatim}
%You can obviously build similar function to deny the use of logs or square roots, for example.
%\changes{v1.5}{2007/02/05}
%{
% Removed \texttt{"pi"} and \texttt{"PI}" from the \texttt{aTrigFuncs array}, and added
% \texttt{"arcsin"}, \texttt{"arccos"}, "\texttt{arctan"}.
%}
%    \begin{macrocode}
function NoTrigAllowed (UserAns)
{
  UserAns  = stripWhiteSpace(UserAns);
  if ( !ok2Continue ) return null;
  var aTrigfuncs = new Array
  ( "acos","asin","atan","cos", "sin", "tan","sec","csc","cot",
    "arcsin", "arccos", "arctan"
  );
  var re, regexp;
  re = /[a-zA-Z]{2,}/g;
  aF = UserAns.match(re);
  if (  aF != null ) {
    for (var i=0; i < aF.length; i++) {
      for(var j=0; j < aTrigfuncs.length; j++) {
        if ( aF[i].indexOf(aTrigfuncs[j]) != -1 )
          return eqAppAlert(\NoTrigAllowedErrorMsg,3), null;
      }
    }
  }
  return true;
}
function NoPiAllowed(UserAns)
{
  UserAns  = stripWhiteSpace(UserAns);
  if ( !ok2Continue ) return null;
  var re=/PI|pi/;
  if ( re.test(UserAns) )
    return eqAppAlert(\NoPiAllowedErrorMsg,3), null;
  return true;
}
function NoTrigLogAllowed (UserAns)
{
  UserAns  = stripWhiteSpace(UserAns);
  if ( !ok2Continue ) return null;
  var aTrigfuncs = new Array
  ( "acos","asin","atan","cos", "sin",
    "tan","sec","csc","cot", "arcsin", "arccos", "arctan",
    "logc","log", "ln"
  );
  var re, regexp;
  re = /[a-zA-Z]{2,}/g;
  aF = UserAns.match(re);
  if (  aF != null ) {
    for (var i=0; i < aF.length; i++)
    {
      for(var j=0; j < aTrigfuncs.length; j++) {
        if ( aF[i].indexOf(aTrigfuncs[j]) != -1 )
          return eqAppAlert(\NoTrigLogAllowedErrorMsg,3), null;
      }
    }
  }
  return true;
}
%    \end{macrocode}
%\changes{v1.9a}{2011/07/15}{Added \texttt{sciNotResp} and \texttt{SciNotResp}}
% This filter function checks to see if the user's input is in the form of (normalized)
% scientific notation: \verb![+-]*d[.d*]*[ ]*E[+-]*d+!, written in pseudo-reg expr.
%    \begin{macrocode}
var bAllowWrngNormSciNotn=false;
var bItsNormSciNot=false;
function SciNotNoNotify(UserAns) {
    bAllowWrngNormSciNotn=true;
    var rtn=SciNotResp(UserAns);
    return rtn;
}
function SciNotResp(UserAns) {
    bItsNormSciNot=false;
    var _sciNotation, _a, _b;
    _sciNotation = /^[+-]*(\d*)*(\.\d*)*E[+-]*\d+$/;
    UserAns=stripWhiteSpace(UserAns);
    if ( (_a=_sciNotation.exec(UserAns)) !=null) {
        if (isNaN(_a[1])) {
            if (bAllowWrngNormSciNotn)
                return true;
            else
                return eqAppAlert(\sciNotNormalForm,3), null;
        }
        if (isNaN(_a[2])) _a[2]=0;
        _b = Math.abs(Number(_a[1])+Number(_a[2]));
        if ( _b < 1 || _b >= 10 ) {
            if (bAllowWrngNormSciNotn)
                return true;
            else
                return eqAppAlert(\sciNotNormalForm,3), null;
        }
        else {
            bItsNormSciNot=true;
            return true
        }
    } else
        return eqAppAlert(\sciNotSyntaxError,3), null;
}
function sciNotResp(UserAns) {return SciNotResp(UserAns);}
function postSciNotResp(UserAns) {
    bAllowWrngNormSciNotn=false;
    return bItsNormSciNot;
}
%    \end{macrocode}
%\changes{v1.9a}{2011/07/15}{Added \texttt{noNegExp}}
% \texttt{noNegExp} does not allow negative exponents in the answer
%    \begin{macrocode}
function NoNegExp (UserAns) {
    var re=/(\^|\^\()+-/g;
    UserAns=ChngAllGrpsToParens(UserAns);
    if (re.test(UserAns))
        return eqAppAlert(\NoNegExpMsg,3), null;
    return true;
}
function noNegExp(UserAns){return NoNegExp(UserAns)}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
% \subsection{Additional mathematical functions}
% The following are contributions by Ross Moore and Frances Griffin, from their work
% on \href{http://rutherglen.ics.mq.edu.au/~macqtex/}{MacQ\TeX}.
% These define function of an integer variable: combinations, permutations and factorials.
% These can be used for math fill-ins.
%    \begin{macrocode}
\begin{library@holding}{combinatorics}
%    \end{macrocode}
% \subsubsection{\texttt{combinatorics}}
% Combinatorial function\IndexOpt{combinatorics}
%    \begin{macrocode}
\begin{newsegment}{dljslib: Contrib - Combinatorial Functions}
function ch(n,r)
{
    if ((n==r)||(r==0)) return(1);
    if ((n==(r+1))||(r==1)) return(n);
    if (r > (n-r))
        var coeff = factorialCancel(
            expandFactorial(r+1,n),expandFactorial(1,n-r));
    else
        var coeff = factorialCancel(
            expandFactorial(n-r+1,n),expandFactorial(1,r));
    return (eval(coeff));
}
function perm(n,r)
{
    if (r==0) return(1);
    else
        var coeff = factorialCancel(
            expandFactorial(n-r+1,n),expandFactorial(1,n-r));
    return (eval(coeff));
}
%    \end{macrocode}
% \texttt{factorialCancel} and \texttt{expandFactorial} are needed by \texttt{binomialCoeff}
%    \begin{macrocode}
function expandFactorial(lo,hi)
{
    var f = lo;
    for (var i=lo+1;i<=hi;i++) f = i+"*"+f;
    return f;
}
%    \end{macrocode}
% \texttt{factorialCancel} cancels common factors in \texttt{num} and \texttt{denom} using strings produced
% by \texttt{expandFactorial}. It expects tails of factorials to have already been cancelled.
%    \begin{macrocode}
function factorialCancel(top,bot)
{
    var num = top.split("*");
    var denom = bot.split("*");
    var len = denom.length;
    var temp = 0;
    var i, j;
    for (i=0;i<=len-1;i++) {
        for (j=0;j<=len-1;j++) {
            temp = num[i]/denom[j];
            if ((temp - Math.round(temp)) == 0) {
                num[i] = temp;
                denom[j] = 1;
            }
        }
    }
    var t = denom.join("");
    var reg = /[^1]/;
    if (reg.test(t)) {
        temp = factorialCancel(denom.join("*"),num.join("*"));
    } else {
        temp = num.join("*");
    }
    return (temp);
}
function fact(num)
{
    var tot = 1;
    for (var r=1; r <= num; r++) tot *= r;
    return(tot);
}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
% \subsection{\texttt{ParseInput} Extensions}\label{s:parseinput}
% The default behavior for processing a math fill-in question is to
% require the student to insert `\texttt*' for multiplication and to
% enclose any function being raised to a power in parentheses, e.g.
% \verb+x*(sin(x))^2+. This becomes quite tiresome if the expression to be entered
% is complicated. The following two functions enable the student to use
% `implied multiplication' and simplified exponentiation.
%
%    \IndexOpt{ImplMulti}
% The \texttt{ImplMulti} option loads two JavaScript functions, \texttt{Ck4Products()}
% and \texttt{Ck4Exponents()}.  The latter implements the notation, \verb+sin^2(x)+
% for $\sin^2(x)$, equivalent to $(\sin(x))^2$. The exponent can be complex and enclosed
% in parentheses, for example \verb-ln^(x+1)(x)-. The former function, \texttt{Ck4Products()},
% inserts the multiplication symbol, `\texttt{*}', wherever implied. For example,
% \verb+xysin(xy)+ becomes \verb+x*y*sin(x*y)+.
% \begin{flushleft}
% \textcolor{red}{Important:} If loaded, \texttt{Exerquiz} will automatically use these two functions.
% \end{flushleft}
%    \begin{macrocode}
\begin{library@holding}{ImplMulti}
%    \end{macrocode}
% \subsubsection{\texttt{ImplMulti}}
%    \begin{macrocode}
\begin{newsegment}{dljslib: Implied Multiplication}
%    \end{macrocode}
% The JavaScript function \texttt{Ck4Products()} takes the user input and tries to
% insert the multiplication symbol, `\texttt*', wherever implied.
%    \begin{macrocode}
function Ck4Products(UserInput)
{
    var re, aR;
%    \end{macrocode}
% Search through for matches with known functions
%    \begin{macrocode}
    for (var i=0; i<JSf.length; i++)
    {
%    \end{macrocode}
% Here we mark the beginning of the left parenthesis for a
% that follows one of the  known functions. This way we can
% distinguish between the built in JavaScript functions and
% other sequences of letters that may represent products.
% \begin{flushleft}
% \textbf{Note:} In the regular
% expression below, and elsewhere, when our search includes unbalanced parentheses
% we need to triple escape them, i.e., instead of `\verb+\\(+' we write
% `\verb+\\\(+'. See comments in \texttt{insdlis.dtx}.
% \end{flushleft}
%    \begin{macrocode}
        re = new RegExp("("+JSf[i]+")(\\\()","g");
        UserInput = UserInput.replace(re, "\\$1@$2");
%    \end{macrocode}
% If a known function has a letter or a right parenthesis to the left of it,
% the user must want multiplication, make it so!
%    \begin{macrocode}
        re = new RegExp("([\\w\\\)])(\\"+JSf[i]+")(@\\\()","g");
        UserInput = UserInput.replace(re, "$1*$2$3");
    }
%    \end{macrocode}
% Now do the same type thing for known constants.
%    \begin{macrocode}
    for (var i=0; i<JSc.length; i++)
    {
%    \end{macrocode}
% We mark the beginning and end of a known predefined constant
% \changes{v1.6}{2007/02/23}
%{
%    If we match up with "E", we do nothing. This is support of
%    using "E" for scientific notation.
%}
%    \begin{macrocode}
        re = new RegExp("("+JSc[i]+")","g");
        if ( JSc[i] != "E" ) {
            UserInput = UserInput.replace(re, "\\$1@");
%    \end{macrocode}
% If a known constant has a letter or an right parenthesis to the left of it,
% the user must want multiplication, make it so!
%    \begin{macrocode}
            re = new RegExp("([\\w\\\)])(\\"+JSc[i]+")(@)","g");
        }
    }
%    \end{macrocode}
% Search for a number or right paren followed by a letter or right paren
% and insert *.
%\changes{v1.6}{2007/02/23}
%{
%    dps/change 02/23/07. In the search below, we exclude the search
%   for the letter "E", because it is used for scientific notation (called exponential)
%}
% notation in JavaScript).
%    \begin{macrocode}
    UserInput = UserInput.replace(
        /([\d\)])([A-DF-Za-z\(\\])/g, "$1*$2");
%    \end{macrocode}
% Search for a right paren followed by a number.
%    \begin{macrocode}
    UserInput = UserInput.replace(/(\))(\d)/g, "$1*$2");
%    \end{macrocode}
% Search for a letter followed by a number of right paren, and insert *
%    \begin{macrocode}
    UserInput = UserInput.replace(/([A-Za-z])([\d\(\\])/g, "$1*$2");
%    \end{macrocode}
% If a predefined constant, such as \texttt{PI}, is multiplied on the
% right by a factor, there will be a \texttt{@} followed by a letter or decimal.
%    \begin{macrocode}
%    re = /(@)([A-Za-z\d])/g;
    UserInput = UserInput.replace(/(@)([A-Za-z\d])/g, "$1*$2");
%    \end{macrocode}
% Now strip off the markers
%    \begin{macrocode}
    UserInput = UserInput.replace(/(\\)([A-Za-z]{1,})(@)/g, "$2");
%    \end{macrocode}
%  Search through list of known functions for a match.
%    \begin{macrocode}
% MacQTeX change   dps/change 02/23/07
    re = /[A-Za-z]{1,}/g;
    while ( (aR = re.exec(UserInput)) != null)
    {
        for (var i=0; i<JSf.length; i++) if ( aR[0] == JSf[i]) break;
        if ( i < JSf.length ) continue;
        for (var i=0; i<JSc.length; i++) if ( aR[0] == JSc[i]) break;
        if ( i < JSc.length ) continue;
%    \end{macrocode}
% If there is no match with known functions or constants, then we need to assume
% this word is a series of products, and separate them on their non-word
% boundaries by a multiplication operator *. We will not be able to identify
% mistyped functions, for example, if the user enters \texttt{cis(x)} instead of
% \texttt{cos(x)}, this will end up as \texttt{c*i*s*(x)}. Ultimately,
% the user will get a message that there is an error in the expression, but not
% hints as to what the error is will not be given.
%    \begin{macrocode}
        aR[0] = aR[0].replace(/([A-Za-z])\B/g,"$1*");
        UserInput = UserInput.substring(0,aR.index)
            +aR[0]+UserInput.substring(re.lastIndex);
    }
    return UserInput;
}
%    \end{macrocode}
% The function \texttt{Ck4Exponents()} attempts to convert the notation \verb+sin^2(x)+
% into standard JavaScript format of \texttt{pow(sin(x),2)}.
%    \begin{macrocode}
function Ck4Exponents(UserInput)
{
    var re, regexp, aP, RightP;
    for (var i=0; (i<JSf.length) && (ok2Continue); i++)
    {
        re = new RegExp(JSf[i]+"\\^");
        while ( re.test(UserInput) && (ok2Continue) )
        {
%    \end{macrocode}
% Here we seek to match an expression of the form: \verb+cos^(exp)(arg)+
%    \begin{macrocode}
            regexp = new RegExp(JSf[i]+"\\^\\\(", "g");
            if ( (aP = regexp.exec(UserInput)) != null ) {
                // forward search
                RightP=FindBalP(UserInput,regexp.lastIndex-1,1);
                var offsetExp = RightP-regexp.lastIndex;
                regexp = new RegExp(
                    JSf[i]+"\\^\\(.{"+offsetExp+"}\\)\\\(", "g");
                regexp.lastIndex=0;
                if ( (aP = regexp.exec(UserInput)) != null ) {
                    // forward search
                    RightP=FindBalP(UserInput,regexp.lastIndex-1,1);
                    var offsetArg = RightP - regexp.lastIndex;
                    regexp = new RegExp("("+JSf[i]
                        +")\\^\\((.{"+offsetExp+"})\\)\\((.{"
                        +offsetArg+"})\\)");
                    regexp.lastIndex=0;
                    if (regexp.test(UserInput))
                        UserInput=UserInput.replace(
                            regexp,"(pow($1($3),$2))");
                    else ok2Continue=false;
                    continue;
                }
            }
%    \end{macrocode}
% Here we seek to match an expression of the form: \verb+cos^\pmNum.Num(arg)+
%    \begin{macrocode}
            regexp = new RegExp(JSf[i]
                +"\\^([a-zA-Z]|[+-]?\\d+\\.?\\d*|[+-]?\\d*\\.?\\d+)"
                +"\\\(","g");
            if ( (aP = regexp.exec(UserInput)) != null ) {
                // forward search
                RightP=FindBalP(UserInput,regexp.lastIndex-1,1);
                regexp = new RegExp("("
                    +JSf[i]+")\\^([a-zA-Z]|[+-]?\\d+"
                    +"\\.?\\d*|[+-]?\\d*\\.?\\d+)\\((.{"
                    +eval(RightP-regexp.lastIndex)+"})\\)");
                regexp.lastIndex=0;
                if (regexp.test(UserInput))
                    UserInput=UserInput.replace(
                        regexp,"(pow($1($3),$2))");
                else ok2Continue=false;
            }
            else ok2Continue=false;
        }
    }
%    \end{macrocode}
% Now we do the same thing for declared constants.
%    \begin{macrocode}
    for (var i=0; (i < JSc.length) && (ok2Continue); i++)
    {
        re = new RegExp(JSc[i]+"\\^", "g");
        while ( re.test(UserInput) && (ok2Continue) )
        {
            re.lastIndex = 0;
            aR = re.exec(UserInput);
            if (UserInput.charAt(re.lastIndex)=='\(') {
                // forward search
                RightP=FindBalP(UserInput,re.lastIndex,1);
                var offsetExp = RightP - re.lastIndex - 1;
                re.lastIndex=0;
                regexp = new RegExp("("+JSc[i]
                    +")\\^\\((.{"+offsetExp+"})\\)");
                if ( regexp.test(UserInput) )
                    UserInput = UserInput.replace(
                        regexp, "(pow($1,$2))");
                else ok2Continue = false;
            }
            else
            {
                re.lastIndex=0;
                regexp = new RegExp("("+JSc[i]
                +")\\^([a-zA-Z]|[+-]?\\d+\\.?\\d*|[+-]?\\d*\\.?\\d+)");
                if (regexp.test(UserInput))
                    UserInput = UserInput.replace(
                        regexp, "(pow($1,$2))");
                else ok2Continue = false;
            }
        }
    }
    return UserInput;
}
\end{newsegment}
\end{library@holding}
%    \end{macrocode}
% Finally, we have the ``back wrapper'' or ``back cover'' of the selected materials. We close the
% \texttt{insDLJS} environment
%    \begin{macrocode}
\begin{library@holding}{dljslib}
\end{insDLJS*}
\end{library@holding}
%    \end{macrocode}
% \section{Out the Door and Close it behind you}
% \dots and free up this write register.
%    \begin{macrocode}
\immediate\closeout\dljslib@verbatim@out
\advance\count17 by -1
%    \end{macrocode}
% \section{Back Home with your Selections}
%    \begin{macrocode}
\input{dljslib.ljs}
%</package>
%    \end{macrocode}
\endinput