Copy disabled (too large)
Download .txt
Showing preview only (11,167K chars total). Download the full file to get everything.
Repository: grzegorzmazur/yacas
Branch: master
Commit: 7df0c6751901
Files: 602
Total size: 10.5 MB
Directory structure:
gitextract_ep2z9l5r/
├── .clang-format
├── .gitignore
├── .vscode/
│ ├── launch.json
│ └── settings.json
├── AUTHORS
├── CMakeLists.txt
├── CODE_OF_CONDUCT.md
├── COPYING
├── ChangeLog
├── README.rst
├── TODO
├── appveyor.yml
├── build.xml
├── cyacas/
│ ├── CMakeLists.txt
│ ├── libyacas/
│ │ ├── CMakeLists.txt
│ │ ├── config/
│ │ │ └── yacas/
│ │ │ └── yacas_version.h.in
│ │ ├── include/
│ │ │ └── yacas/
│ │ │ ├── GPL_stuff.h
│ │ │ ├── anumber.h
│ │ │ ├── anumber.inl
│ │ │ ├── arggetter.h
│ │ │ ├── arrayclass.h
│ │ │ ├── associationclass.h
│ │ │ ├── corefunctions.h
│ │ │ ├── deffile.h
│ │ │ ├── errors.h
│ │ │ ├── evalfunc.h
│ │ │ ├── genericobject.h
│ │ │ ├── infixparser.h
│ │ │ ├── lispatom.h
│ │ │ ├── lispenvironment.h
│ │ │ ├── lisperror.h
│ │ │ ├── lispeval.h
│ │ │ ├── lispevalhash.h
│ │ │ ├── lispglobals.h
│ │ │ ├── lisphash.h
│ │ │ ├── lispio.h
│ │ │ ├── lispobject.h
│ │ │ ├── lispoperator.h
│ │ │ ├── lispparser.h
│ │ │ ├── lispstring.h
│ │ │ ├── lispuserfunc.h
│ │ │ ├── mathcommands.h
│ │ │ ├── mathuserfunc.h
│ │ │ ├── mempool.h
│ │ │ ├── noncopyable.h
│ │ │ ├── numbers.h
│ │ │ ├── patcher.h
│ │ │ ├── patternclass.h
│ │ │ ├── patterns.h
│ │ │ ├── platfileio.h
│ │ │ ├── platmath.h
│ │ │ ├── refcount.h
│ │ │ ├── standard.h
│ │ │ ├── standard.inl
│ │ │ ├── string_utils.h
│ │ │ ├── stringio.h
│ │ │ ├── substitute.h
│ │ │ ├── tokenizer.h
│ │ │ ├── utf8/
│ │ │ │ ├── checked.h
│ │ │ │ ├── core.h
│ │ │ │ ├── cpp11.h
│ │ │ │ ├── cpp17.h
│ │ │ │ ├── cpp20.h
│ │ │ │ └── unchecked.h
│ │ │ ├── utf8.h
│ │ │ ├── xmltokenizer.h
│ │ │ └── yacas.h
│ │ └── src/
│ │ ├── anumber.cpp
│ │ ├── arggetter.cpp
│ │ ├── associationclass.cpp
│ │ ├── deffile.cpp
│ │ ├── errors.cpp
│ │ ├── infixparser.cpp
│ │ ├── lispatom.cpp
│ │ ├── lispenvironment.cpp
│ │ ├── lisperror.cpp
│ │ ├── lispeval.cpp
│ │ ├── lispevalhash.cpp
│ │ ├── lisphash.cpp
│ │ ├── lispio.cpp
│ │ ├── lispobject.cpp
│ │ ├── lispparser.cpp
│ │ ├── lispuserfunc.cpp
│ │ ├── mathcommands.cpp
│ │ ├── mathcommands2.cpp
│ │ ├── mathcommands3.cpp
│ │ ├── mathuserfunc.cpp
│ │ ├── mempool.cpp
│ │ ├── numbers.cpp
│ │ ├── patcher.cpp
│ │ ├── patternclass.cpp
│ │ ├── patterns.cpp
│ │ ├── platmath.cpp
│ │ ├── standard.cpp
│ │ ├── stdfileio.cpp
│ │ ├── stringio.cpp
│ │ ├── substitute.cpp
│ │ ├── tokenizer.cpp
│ │ ├── xmltokenizer.cpp
│ │ ├── yacasapi.cpp
│ │ └── yacasnumbers.cpp
│ ├── libyacas_mp/
│ │ ├── CMakeLists.txt
│ │ ├── benchmark/
│ │ │ ├── CMakeLists.txt
│ │ │ └── src/
│ │ │ └── nn_benchmark.cpp
│ │ ├── include/
│ │ │ └── yacas/
│ │ │ └── mp/
│ │ │ ├── limbs_vector.hpp
│ │ │ ├── nn.hpp
│ │ │ ├── rr.hpp
│ │ │ └── zz.hpp
│ │ ├── src/
│ │ │ ├── limbs_vector.cpp
│ │ │ ├── nn.cpp
│ │ │ ├── rr.cpp
│ │ │ └── zz.cpp
│ │ └── test/
│ │ ├── CMakeLists.txt
│ │ └── src/
│ │ ├── nn_test.cpp
│ │ └── zz_test.cpp
│ ├── packaging/
│ │ ├── deb/
│ │ │ ├── changelog
│ │ │ ├── compat
│ │ │ ├── control
│ │ │ ├── copyright
│ │ │ ├── missing-sources/
│ │ │ │ ├── jquery-ui.js
│ │ │ │ ├── jquery.autosize.js
│ │ │ │ ├── jquery.js
│ │ │ │ ├── jquery.ui-contextmenu.js
│ │ │ │ └── plotly-1.49.0.js
│ │ │ ├── rules
│ │ │ ├── source/
│ │ │ │ ├── format
│ │ │ │ └── include-binaries
│ │ │ └── yacas.1
│ │ ├── ebuild/
│ │ │ └── yacas.ebuild
│ │ ├── flatpak/
│ │ │ ├── org.yacas.yacas-gui.appdata.xml
│ │ │ ├── org.yacas.yacas-gui.json
│ │ │ └── org.yacas.yacas.json
│ │ ├── nsis/
│ │ │ ├── COPYING
│ │ │ └── yacas-win64.nsi
│ │ ├── pkg/
│ │ │ ├── distribution.xml
│ │ │ ├── license.txt
│ │ │ └── readme.html
│ │ ├── rpm/
│ │ │ └── yacas.spec
│ │ └── snap/
│ │ ├── snap/
│ │ │ └── gui/
│ │ │ └── yacas.gui.desktop
│ │ └── snapcraft.yaml
│ ├── xeus-yacas/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── xeus-yacas/
│ │ │ └── xeus-yacas.hpp
│ │ └── src/
│ │ ├── interpreter.cpp
│ │ └── main.cpp
│ ├── yacas/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ ├── commandline.h
│ │ │ ├── core_yacasmain.h
│ │ │ ├── stdcommandline.h
│ │ │ ├── unixcommandline.h
│ │ │ └── win32commandline.h
│ │ ├── res/
│ │ │ └── yacas.rc
│ │ └── src/
│ │ ├── commandline.cpp
│ │ ├── js_interface.cpp
│ │ ├── stdcommandline.cpp
│ │ ├── unixcommandline.cpp
│ │ ├── win32commandline.cpp
│ │ └── yacasmain.cpp
│ ├── yacas-gui/
│ │ ├── CMakeLists.txt
│ │ ├── img.qrc
│ │ ├── include/
│ │ │ ├── cellproxy.h
│ │ │ ├── mainwindow.h
│ │ │ ├── preferences.h
│ │ │ ├── preferences_dialog.h
│ │ │ ├── yacasengine.h
│ │ │ ├── yacasrequest.h
│ │ │ └── yacasserver.h
│ │ ├── resources/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── jquery/
│ │ │ │ ├── jquery.jeditable.autogrow.js
│ │ │ │ └── jquery.jeditable.js
│ │ │ ├── mathbar/
│ │ │ │ ├── functions.json
│ │ │ │ ├── functions_parser.js
│ │ │ │ ├── mathBar.js
│ │ │ │ └── mathbar.css
│ │ │ ├── webchannel/
│ │ │ │ └── qwebchannel.js
│ │ │ ├── yacas-online.html
│ │ │ ├── yacas_gui/
│ │ │ │ ├── attic/
│ │ │ │ │ └── intput.editable.js
│ │ │ │ ├── yacas_gui.css
│ │ │ │ └── yacas_gui.js
│ │ │ └── yacas_gui.html
│ │ ├── src/
│ │ │ ├── cellproxy.cpp
│ │ │ ├── main.cpp
│ │ │ ├── mainwindow.cpp
│ │ │ ├── preferences.cpp
│ │ │ ├── preferences_dialog.cpp
│ │ │ ├── yacasengine.cpp
│ │ │ ├── yacasrequest.cpp
│ │ │ └── yacasserver.cpp
│ │ ├── ui/
│ │ │ ├── mainwindow.ui
│ │ │ └── preferences_dialog.ui
│ │ ├── winres/
│ │ │ └── yacas_gui.rc
│ │ ├── yacas-gui.desktop
│ │ └── yacas.icns
│ └── yacas-kernel/
│ ├── CMakeLists.txt
│ ├── include/
│ │ ├── base64.hpp
│ │ ├── hmac_sha256.hpp
│ │ ├── yacas_engine.hpp
│ │ └── yacas_kernel.hpp
│ └── src/
│ ├── base64.cpp
│ ├── hmac_sha256.cpp
│ ├── main.cpp
│ ├── yacas_engine.cpp
│ └── yacas_kernel.cpp
├── docs/
│ ├── CMakeLists.txt
│ ├── Makefile
│ ├── book_of_algorithms/
│ │ ├── basic.rst
│ │ ├── index.rst
│ │ ├── integration.rst
│ │ ├── multivar.rst
│ │ ├── numtheory.rst
│ │ ├── references.bib
│ │ ├── references.rst
│ │ ├── sturm-sequences.rst
│ │ └── transforms.rst
│ ├── conf.py
│ ├── credits.rst
│ ├── getting_started/
│ │ └── index.rst
│ ├── glossary.rst
│ ├── index.rst
│ ├── license.rst
│ ├── make.bat
│ ├── programming_in_yacas/
│ │ └── index.rst
│ ├── reference_manual/
│ │ ├── arithmetic.rst
│ │ ├── calc.rst
│ │ ├── consts.rst
│ │ ├── controlflow.rst
│ │ ├── debugging.rst
│ │ ├── elementary.rst
│ │ ├── functional.rst
│ │ ├── graphs.rst
│ │ ├── index.rst
│ │ ├── io.rst
│ │ ├── linear-algebra.rst
│ │ ├── lists.rst
│ │ ├── logic.rst
│ │ ├── misc.rst
│ │ ├── number-theory.rst
│ │ ├── numerical-methods.rst
│ │ ├── ode.rst
│ │ ├── physics.rst
│ │ ├── plot.rst
│ │ ├── predicates.rst
│ │ ├── probability-and-statistics.rst
│ │ ├── programming.rst
│ │ ├── random.rst
│ │ ├── simplify.rst
│ │ ├── solvers.rst
│ │ ├── special.rst
│ │ ├── strings.rst
│ │ ├── univariate-polynomials.rst
│ │ └── vars.rst
│ ├── requirements.txt
│ ├── tutorial/
│ │ └── index.rst
│ └── util/
│ └── yacasdomain.py
├── jyacas/
│ ├── CMakeLists.txt
│ ├── CVersion.java.in
│ ├── JavaYacas.1
│ ├── MANIFEST.MF
│ ├── lib/
│ │ ├── hamcrest-core-1.3.jar
│ │ └── junit-4.11.jar
│ └── net/
│ └── sf/
│ └── yacas/
│ ├── ArrayClass.java
│ ├── AssociationClass.java
│ ├── BackQuoteBehaviour.java
│ ├── BasicEvaluator.java
│ ├── BigNumber.java
│ ├── BranchingUserFunction.java
│ ├── CYacas.java
│ ├── CachedStdFileInput.java
│ ├── EvalFuncBase.java
│ ├── GenericClass.java
│ ├── InfixParser.java
│ ├── InfixPrinter.java
│ ├── InputDirectories.java
│ ├── InputStatus.java
│ ├── JarInputFile.java
│ ├── LispArgList.java
│ ├── LispArityUserFunction.java
│ ├── LispAtom.java
│ ├── LispDefFile.java
│ ├── LispDefFiles.java
│ ├── LispEnvironment.java
│ ├── LispError.java
│ ├── LispEvaluatorBase.java
│ ├── LispGenericClass.java
│ ├── LispGlobalVariable.java
│ ├── LispHashTable.java
│ ├── LispInFixOperator.java
│ ├── LispInput.java
│ ├── LispIterator.java
│ ├── LispLocalFrame.java
│ ├── LispMultiUserFunction.java
│ ├── LispNumber.java
│ ├── LispObject.java
│ ├── LispOperators.java
│ ├── LispParser.java
│ ├── LispPrinter.java
│ ├── LispPtr.java
│ ├── LispPtrArray.java
│ ├── LispStandard.java
│ ├── LispSubList.java
│ ├── LispTokenizer.java
│ ├── LispUserFunction.java
│ ├── ListedBranchingUserFunction.java
│ ├── ListedMacroUserFunction.java
│ ├── LocalSymbolBehaviour.java
│ ├── MacroUserFunction.java
│ ├── MatchAtom.java
│ ├── MatchNumber.java
│ ├── MatchSubList.java
│ ├── MatchVariable.java
│ ├── MathCommands.java
│ ├── ParsedObject.java
│ ├── PatternClass.java
│ ├── StdFileInput.java
│ ├── StreamGobbler.java
│ ├── StringInput.java
│ ├── SubstBehaviour.java
│ ├── SubstBehaviourBase.java
│ ├── UserStackInformation.java
│ ├── XmlTokenizer.java
│ ├── YacasConsole.java
│ ├── YacasEvalCaller.java
│ ├── YacasEvaluator.java
│ ├── YacasException.java
│ ├── YacasInterpreter.java
│ ├── YacasParamMatcherBase.java
│ ├── YacasPatternPredicateBase.java
│ └── YacasTest.java
├── man/
│ ├── CMakeLists.txt
│ └── yacas.1.rst
├── papers/
│ ├── llncs.cls
│ ├── paper1.tex
│ └── paper2.tex
├── scripts/
│ ├── array.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── assoc.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── base.rep/
│ │ ├── math.ys
│ │ └── math.ys.def
│ ├── c_form.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── calendar.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── complex.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ └── om.ys
│ ├── constants.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ └── om.ys
│ ├── controlflow.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── cse.rep/
│ │ ├── cse.ys
│ │ └── cse.ys.def
│ ├── debug.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── deffunc.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── deriv.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── example.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── examples/
│ │ ├── ABIN.ys
│ │ ├── MinimumSpanningTree.ys
│ │ ├── benchbuild.ys
│ │ ├── benchmark.ys
│ │ ├── benchmark2.ys
│ │ ├── findsum.ys
│ │ ├── goldbach.ys
│ │ ├── pi.ys
│ │ ├── queens.ys
│ │ ├── series.ys
│ │ └── wordproblems.ys
│ ├── factors.rep/
│ │ ├── binaryfactors.ys
│ │ ├── binaryfactors.ys.def
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── functional.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ └── om.ys
│ ├── graph.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── html.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── integrate.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ └── om.ys
│ ├── io.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ ├── defaultprint.ys
│ │ ├── defaultprint.ys.def
│ │ ├── errors.ys
│ │ ├── formula.ys
│ │ └── print.ys
│ ├── limit.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ └── om.ys
│ ├── linalg.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── lists.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ ├── scopestack.ys
│ │ └── scopestack.ys.def
│ ├── localrules.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── logic.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ └── om.ys
│ ├── multivar.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ ├── makemulti.ys
│ │ ├── sparsenomial.ys
│ │ ├── sparsetree.ys
│ │ └── sparsetree.ys.def
│ ├── newly.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── nintegrate.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── numbers.rep/
│ │ ├── GaussianIntegers.ys
│ │ ├── GaussianIntegers.ys.def
│ │ ├── NumberTheory.ys
│ │ ├── NumberTheory.ys.def
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ ├── nthroot.ys
│ │ ├── nthroot.ys.def
│ │ └── om.ys
│ ├── odesolver.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── openmath.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── orthopoly.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── packages.ys
│ ├── padic.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── patterns.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── physics.rep/
│ │ └── quantum/
│ │ ├── clebsch-gordan.ys
│ │ └── clebsch-gordan.ys.def
│ ├── plots.rep/
│ │ ├── backends-2d.ys
│ │ ├── backends-3d.ys
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ ├── plot2d.ys
│ │ ├── plot2d.ys.def
│ │ ├── plot3d.ys
│ │ └── plot3d.ys.def
│ ├── predicates.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── probability.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── products.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── pslq.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── r_form.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── rabinmiller.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── radsimp.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── random.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── rational.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── simplify.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ ├── factorial.ys
│ │ └── factorial.ys.def
│ ├── solve.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ └── om.ys
│ ├── specfunc.rep/
│ │ ├── bernou.ys
│ │ ├── bernou.ys.def
│ │ ├── bessel.ys
│ │ ├── bessel.ys.def
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ ├── gamma.ys
│ │ ├── gamma.ys.def
│ │ ├── gammaconst.ys
│ │ ├── gammaconst.ys.def
│ │ ├── om.ys
│ │ ├── zeta.ys
│ │ └── zeta.ys.def
│ ├── standard.ys
│ ├── standard.ys.def
│ ├── statistics.rep/
│ │ ├── distributions.ys
│ │ ├── distributions.ys.def
│ │ ├── hypothesystest.ys
│ │ ├── hypothesystest.ys.def
│ │ ├── incompletegamma.ys
│ │ ├── incompletegamma.ys.def
│ │ ├── randomtest.ys
│ │ ├── regression.ys
│ │ ├── regression.ys.def
│ │ ├── statistics.ys
│ │ └── statistics.ys.def
│ ├── stats.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── stdarith.ys
│ ├── stdarith.ys.def
│ ├── stdfuncs.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ ├── elemfuncs.ys
│ │ ├── elemfuncs.ys.def
│ │ ├── numerical.ys
│ │ ├── numerical.ys.def
│ │ ├── nummethods.ys
│ │ ├── nummethods.ys.def
│ │ └── om.ys
│ ├── stdopers.ys
│ ├── stubs.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ └── om.ys
│ ├── substitute.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── sums.rep/
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ ├── om.ys
│ │ ├── taylor.ys
│ │ ├── taylor.ys.def
│ │ ├── taylor3.ys
│ │ └── taylor3.ys.def
│ ├── tensor.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── testers.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── texform.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── transforms.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── trigsimp.rep/
│ │ ├── code.ys
│ │ └── code.ys.def
│ ├── univar.rep/
│ │ ├── Cyclotomic.ys
│ │ ├── Cyclotomic.ys.def
│ │ ├── code.ys
│ │ ├── code.ys.def
│ │ ├── sparse.ys
│ │ ├── sparse.ys.def
│ │ ├── sturm.ys
│ │ └── sturm.ys.def
│ └── yacasinit.ys
├── tests/
│ ├── CMakeLists.txt
│ ├── GaussianIntegers.yts
│ ├── arithmetic.yts
│ ├── association.yts
│ ├── binaryfactors.yts
│ ├── bitops.yts
│ ├── c_tex_form.yts
│ ├── calculus.yts
│ ├── calendar.yts
│ ├── canprove.yts
│ ├── comments.yts
│ ├── complex.yts
│ ├── cyclotomic.yts
│ ├── deriv.yts
│ ├── dimensions.yts
│ ├── dot.yts
│ ├── graphs.yts
│ ├── includetestfiles
│ ├── integrate.yts
│ ├── io.yts
│ ├── journal.yts
│ ├── linalg.yts
│ ├── lists.yts
│ ├── logic_simplify_test.yts
│ ├── macro.yts
│ ├── matrixpower.yts
│ ├── multivar.yts
│ ├── newly.yts
│ ├── nthroot.yts
│ ├── numbers.yts
│ ├── numerics.yts
│ ├── nummethods.yts
│ ├── ode.yts
│ ├── openmath.yts
│ ├── orthopoly.yts
│ ├── outer.yts
│ ├── padic.yts
│ ├── physics.yts
│ ├── plots.yts
│ ├── poly.yts
│ ├── predicates.yts
│ ├── products.yts
│ ├── programming.yts
│ ├── radsimp.yts
│ ├── rational.yts
│ ├── regress.yts
│ ├── scopestack.yts
│ ├── simplify.yts
│ ├── solve.yts
│ ├── sturm.yts
│ ├── sums.yts
│ ├── tensors.yts
│ ├── test-yacas
│ ├── test-yacas.bat
│ ├── tr.yts
│ ├── trace.yts
│ └── transforms.yts
├── third_party/
│ └── README.rst
├── utils/
│ └── pre-commit
└── yacas_UNINSTALL.sh
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
---
Language: Cpp
# BasedOnStyle: LLVM
AccessModifierOffset: -4
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Right
AlignOperands: true
AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Inline
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: false
BinPackArguments: false
BinPackParameters: false
BraceWrapping:
AfterClass: false
AfterControlStatement: false
AfterEnum: false
AfterFunction: true
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Custom
BreakBeforeInheritanceComma: false
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: AfterColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: false
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Preserve
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
Priority: 3
- Regex: '.*'
Priority: 1
IncludeIsMainRegex: '(Test)?$'
IndentCaseLabels: false
IndentPPDirectives: AfterHash
IndentWidth: 4
IndentWrappedFunctionNames: false
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: true
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: All
ObjCBlockIndentWidth: 4
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Left
RawStringFormats:
- Delimiters: [pb]
Language: TextProto
BasedOnStyle: google
ReflowComments: true
SortIncludes: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeParens: ControlStatements
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Cpp11
TabWidth: 8
UseTab: Never
...
================================================
FILE: .gitignore
================================================
/nbproject/
/build/
/install/
*.cmake
/CMakeFiles/
/CMakeScripts/
CMakeCache.txt
/Release/
/Debug/
/Yacas.build/
/Yacas.xcodeproj/
/JavaYacas/CVersion.java
/TEST-net.sf.yacas.YacasTest.xml
/yacas-logfile.txt
/jyacas/net/sf/yacas/CVersion.java
.DS_Store
.vscode/ipch/*
*.pyc
.vs/
out/
================================================
FILE: .vscode/launch.json
================================================
{
"version": "0.2.0",
"configurations": [
{
"name": "(gdb) Launch yacas",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceRoot}/build/cyacas/yacas/yacas",
"args": ["--rootdir", "${workspaceRoot}/scripts/"],
"stopAtEntry": false,
"cwd": "${workspaceRoot}",
"environment": [],
"externalConsole": true,
"MIMode": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
]
},
{
"name": "(gdb) Launch yacas arithmetic.yts",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceRoot}/build/cyacas/yacas/yacas",
"args": ["--rootdir", "${workspaceRoot}/scripts/", "${workspaceRoot}/tests/arithmetic.yts"],
"stopAtEntry": false,
"cwd": "${workspaceRoot}",
"environment": [],
"externalConsole": true,
"MIMode": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
]
},
{
"name": "(gdb) Launch yacas numerics.yts",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceRoot}/build/cyacas/yacas/yacas",
"args": ["--rootdir", "${workspaceRoot}/scripts/", "${workspaceRoot}/tests/numerics.yts"],
"stopAtEntry": false,
"cwd": "${workspaceRoot}",
"environment": [],
"externalConsole": true,
"MIMode": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
]
},
{
"name": "(gdb) Launch yacas orthopoly.yts",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceRoot}/build/cyacas/yacas/yacas",
"args": ["--rootdir", "${workspaceRoot}/scripts/", "${workspaceRoot}/tests/orthoppoly.yts"],
"stopAtEntry": false,
"cwd": "${workspaceRoot}",
"environment": [],
"externalConsole": true,
"MIMode": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
]
}
],
"compounds": []
}
================================================
FILE: .vscode/settings.json
================================================
{
"C_Cpp.intelliSenseEngine": "Default",
"editor.insertSpaces": true,
"editor.tabSize": 4,
"editor.detectIndentation": true,
"files.associations": {
"*.ltx": "latex",
"cctype": "cpp",
"cmath": "cpp",
"csignal": "cpp",
"cstdarg": "cpp",
"cstddef": "cpp",
"cstdio": "cpp",
"cstdlib": "cpp",
"cstring": "cpp",
"ctime": "cpp",
"cwchar": "cpp",
"cwctype": "cpp",
"array": "cpp",
"atomic": "cpp",
"*.tcc": "cpp",
"chrono": "cpp",
"condition_variable": "cpp",
"cstdint": "cpp",
"exception": "cpp",
"functional": "cpp",
"future": "cpp",
"initializer_list": "cpp",
"iosfwd": "cpp",
"limits": "cpp",
"mutex": "cpp",
"new": "cpp",
"ratio": "cpp",
"stdexcept": "cpp",
"system_error": "cpp",
"thread": "cpp",
"tuple": "cpp",
"type_traits": "cpp",
"typeinfo": "cpp",
"utility": "cpp",
"codecvt": "cpp",
"bitset": "cpp",
"clocale": "cpp",
"fstream": "cpp",
"iomanip": "cpp",
"iostream": "cpp",
"istream": "cpp",
"memory": "cpp",
"ostream": "cpp",
"sstream": "cpp",
"streambuf": "cpp",
"algorithm": "cpp",
"*.ipp": "cpp",
"deque": "cpp",
"string": "cpp",
"unordered_map": "cpp",
"unordered_set": "cpp",
"vector": "cpp",
"numeric": "cpp",
"optional": "cpp",
"string_view": "cpp",
"variant": "cpp"
},
"python.pythonPath": "/usr/bin/python3",
"files.exclude": {
"**/.DS_Store": true,
"**/.git": true,
"**/.hg": true,
"**/.svn": true,
"**/*.pyc": true,
"**/build": true,
"**/CVS": true
},
"files.trimTrailingWhitespace": true,
"restructuredtext.builtDocumentationPath": "${workspaceRoot}/build/docs/html",
"cmake.configureOnOpen": true,
"workbench.colorCustomizations": {
"statusBar.background": "#E49427",
"statusBar.debuggingBackground": "#E49427",
"statusBar.noFolderBackground": "#E49427",
"statussBar.prominentBackground": "#E49427"
},
"files.watcherExclude": {
"**/build/**": true
},
"cmake.installPrefix": "${workspaceRoot}/build/install/${buildKit}/${buildType}",
"cmake.configureSettings": {
"Qt5Core_DIR": "/usr/lib/x86_64-linux-gnu/cmake/Qt5Core",
"Qt5Widgets_DIR": "/usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets",
"Qt5WebEngine_DIR": "/usr/lib/x86_64-linux-gnu/cmake/Qt5WebEngine",
"Qt5WebEngineWidgets_DIR": "/usr/lib/x86_64-linux-gnu/cmake/Qt5WebEngineWidgets",
"Qt5Svg_DIR": "/usr/lib/x86_64-linux-gnu/cmake/Qt5Svg"
},
"python.linting.pylintEnabled": true,
"python.linting.enabled": true,
"restructuredtext.confPath": ""
}
================================================
FILE: AUTHORS
================================================
************
Credits [*]_
************
Original/primary authors
========================
Ayal Pinkus *apinkus "AT" xs4all "DOT" nl*
This project was started by Ayal Pinkus who remains the main author and the primary maintainer.
Serge Winitzki *serge "AT" cosmos "DOT" phy "DOT" tufts "DOT" edu*
Added factorials over rationals, TeXForm, did a major overhaul of the introduction manual (actually, he wrote
large part of the manual as it is), and initiated numerous improvements and test code for Yacas, and
implemented yacas_client. Actually, Serge has been one of the larger contributors, and the main force behind
the improved documentation.
Jitse Niesen *jn221 "AT" damtp "DOT" cam "DOT" ac "DOT" uk*
Reported some bugs, helped improve various parts of Yacas, and greatly improved the manual for Yacas.
Maintainer
==========
Grzegorz Mazur *teoretyk "AT" gmail "DOT" com*
Contributors
============
Jim Apple *japple "AT" freeshell "DOT" org*
Reported bugs and supplied improved code for gcc 3.3.4
Mark Arrasmith *arrasmith "AT" math "DOT" twsu "DOT" edu*
Helped greatly in setting up the fltk-based graphicaluser interface, and fixed some bugs relating to limits
regarding infinity.
Fred Bacon *bacon "AT" aerodyne "DOT" com*
Fixed some compiler errors on the newer gcc compiles. Reported some important bugs.
Jay Belanger *belanger "AT" truman "DOT" edu*
Reported some bugs and improved some of the GnuPlot code. He also wrote the yacas.el file, which allows you
to run yacas from within emacs.
Roberto Colistete Junior
Is maintaining a version of `Yacas for SymbianOS <http://www.robertocolistete.net/Yacas/>`_.
Sebastian Ferraro *sferraro "AT" criba "DOT" edu "DOT" ar*
Reported bugs and supplied improved code (determinants).
John Fremlin
Added some code for fast calculation of roots of a cubic polynomial.
Peter Gilbert *peterdgilbert "AT" gmail "DOT" com*
Made many improvements to the C++ code to make it conform more to standard C++ coding conventions (class
interfaces looking more like stl), improved the regression test suite.
James Gilbertson *azurite "AT" telusplanet "DOT" net*
Win32 port, improved error reporting. Added initial version of Karatsuba multiplication, and added some matrix
functions to the math library.
Gabor Grothendieck
Gabor is the maintainer of `Ryacas <https://code.google.com/p/ryacas/>`_, and gave valuable feedback on the
new web site.
Rene Grothmann *2004 "AT" rene-grothmann "DOT" de*
Married Euler to Yacas.
Franz Hack *franz.hack "AT" web "DOT" de*
Supplied a Delphi interface to the Yacas DLL.
Ingrid Halters
Helped improve the ease of use of the Yacas web site.
Mark Hatsell *mark "AT" autograph-maths "DOT" com*
Made the server code work on Windows.
Joris van der Hoeven *TeXmacs "AT" math "DOT" u-psud "DOT" fr*
Helped with texmacs support.
Wolfgang Hšnig *pocket_software "AT" web "DOT" de*
Created a port of Yacas that runs on PocketPC, to be found `here <http://www.pocket-software.de.vu>`_.
Daniel Richard G. *straker "AT" MIT "DOT" EDU*
Added autoconf/automake scripts, made Sun/Sgi compilation possible, created a rpm spec file, many many many
changes to clean up the source distribution.
Igor Khavkine
Added 'Diverge' and 'Curl', and implemented threading for the derivative operator (the gradient). Fixed GMP
code.
John Lapeyre
Made some modifications to the make file, and improved some math code.
Jonathan Leto *jonathan "AT" leto "DOT" net*
Helped improve the integration algorithm, and helped extend the tests used for Yacas (finding numerous bugs).
Vladimir Livshits *livshits "AT" cs "DOT" stanford "DOT" edu*
Set up the initial sourceforge CVS repository, and updated the Windows version source code. He also greatly
improved the logic theorem prover code.
Eugenia Loli
Helped build the BeOS version of Yacas.
Adolf Mathias *adolf_mathias "AT" web "DOT" de*
Grzegorz Mazur *teoretyk "AT" gmail "DOT" com*
Pablo De Nápoli *pdenapo "AT" yahoo "DOT" com*
Fixed the configure script so Yacas compiles under cygwin.
Gopal Narayanan *gopal "AT" debian "DOT" org*
Debian package maintainer. Made a man page for Yacas.
Marta Noga *marta.noga "AT" gmail "DOT" com*
Christian Obrecht *christian "DOT" obrecht "AT" wanadoo "DOT" fr*
Made a much better Limit, and made Yacas behave better at infinity.
Alberto González Palomo
Implemented a console-mode version of Yacas for AgendaVR. Changed the directory structure for the script
files, and implemented initial support for OpenMath.
Doreen Pinkus *d "DOT" pinkus "AT" hccnet "DOT" nl*
Designed the second version of the Web site for Yacas.
Mike Pinna *mike "AT" autograph-maths "DOT" com*
Applied some bug fixes.
Savario Prinz *yacas "AT" mac "DOT" com*
Built a fantastic Mac version of Yacas.
Dirk Reusch
Added some linear algebra functions, and fixed some predicate functions.
Daniel Rigby
Brought a client-server structure to the EPOC32 version of Yacas.
Juan Pablo Romero *jpablo_romero "AT" hotmail "DOT" com*
Reported many bugs, made many suggestions for improvements, and supplied improved code (yacas scripts and
makefile code).
Robert V Schipper *rvs "AT" achilles "DOT" nfia "DOT" org*
Ironed out a few bugs in Yacas.
Schneelocke
Reported an important bug in numeric calculations.
HenSiong Tan *tan "AT" stat "DOT" psu "DOT" edu*
Yannick Versley *yannick "AT" versley "DOT" de*
Sent some patches regarding bugs relating integration and differentiation.
Adrian V. *qwert2003 "AT" users "DOT" sourceforge "DOT" net*
Yijun Yu *y.yu "AT" open "DOT" ac "DOT" uk*
Implemented LDU decomposition
Ladislav Zejda
Supplied patches to make Yacas work on Dec Alpha's.
Andrei Zorine
Started the body of statistics code.
.. [*] All with last-known email addresses mangled in an obvious way
================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required (VERSION 3.10)
foreach (p CMP0048 CMP0054 CMP0071 CMP0135)
if (POLICY ${p})
cmake_policy(SET ${p} NEW)
endif ()
endforeach ()
option (ENABLE_CYACAS_CONSOLE "build the C++ yacas text console" ON)
option (ENABLE_CYACAS_GUI "build the C++ yacas GUI application" ON)
option (ENABLE_CYACAS_GUI_PRIVATE_CODEMIRROR "use private copy of CodeMirror in yacas GUI application" ON)
option (ENABLE_CYACAS_GUI_PRIVATE_MATHJAX "use private copy of MathJAX in yacas GUI application" ON)
option (ENABLE_CYACAS_KERNEL "build the C++ yacas Jupyter kernel" OFF)
option (ENABLE_CYACAS_XEUS "build the C++ yacas Xeus kernel" OFF)
option (ENABLE_CYACAS_UNIT_TESTS "build the C++ yacas engine unit tests" OFF)
option (ENABLE_CYACAS_BENCHMARKS "build the C++ yacas engine benchmarks" OFF)
option (ENABLE_JYACAS "build the Java yacas engine" OFF)
option (ENABLE_DOCS "generate documentation" OFF)
option (ENABLE_CODE_COVERAGE "enable coverage reporting" OFF)
if (ENABLE_CYACAS_CONSOLE OR ENABLE_CYACAS_GUI OR ENABLE_CYACAS_KERNEL)
set (ENABLE_CYACAS ON)
else ()
set (ENABLE_CYACAS OFF)
endif()
set (CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
set (LANGUAGES CXX C)
if (ENABLE_JYACAS)
find_package (Java)
include (UseJava)
set (LANGUAGES ${LANGUAGES} Java)
endif ()
project (yacas VERSION 1.9.2 LANGUAGES ${LANGUAGES})
set (CMAKE_CXX_STANDARD 23)
set (CMAKE_CXX_STANDARD_REQUIRED ON)
set (CMAKE_CXX_EXTENSIONS OFF)
include (GNUInstallDirs)
include (CTest)
set (YACAS_SCRIPTS
scripts/array.rep/code.ys
scripts/array.rep/code.ys.def
scripts/assoc.rep/code.ys
scripts/assoc.rep/code.ys.def
scripts/base.rep/math.ys
scripts/base.rep/math.ys.def
scripts/c_form.rep/code.ys
scripts/c_form.rep/code.ys.def
scripts/calendar.rep/code.ys
scripts/calendar.rep/code.ys.def
scripts/complex.rep/code.ys
scripts/complex.rep/code.ys.def
scripts/complex.rep/om.ys
scripts/constants.rep/code.ys
scripts/constants.rep/code.ys.def
scripts/constants.rep/om.ys
scripts/controlflow.rep/code.ys
scripts/controlflow.rep/code.ys.def
scripts/cse.rep/cse.ys
scripts/cse.rep/cse.ys.def
scripts/debug.rep/code.ys
scripts/debug.rep/code.ys.def
scripts/deffunc.rep/code.ys
scripts/deffunc.rep/code.ys.def
scripts/deriv.rep/code.ys
scripts/deriv.rep/code.ys.def
scripts/example.rep/code.ys
scripts/example.rep/code.ys.def
scripts/factors.rep/binaryfactors.ys
scripts/factors.rep/binaryfactors.ys.def
scripts/factors.rep/code.ys
scripts/factors.rep/code.ys.def
scripts/functional.rep/code.ys
scripts/functional.rep/code.ys.def
scripts/functional.rep/om.ys
scripts/graph.rep/code.ys
scripts/graph.rep/code.ys.def
scripts/html.rep/code.ys
scripts/html.rep/code.ys.def
scripts/integrate.rep/code.ys
scripts/integrate.rep/code.ys.def
scripts/integrate.rep/om.ys
scripts/io.rep/code.ys
scripts/io.rep/code.ys.def
scripts/io.rep/defaultprint.ys
scripts/io.rep/defaultprint.ys.def
scripts/io.rep/errors.ys
scripts/io.rep/formula.ys
scripts/io.rep/print.ys
scripts/limit.rep/code.ys
scripts/limit.rep/code.ys.def
scripts/limit.rep/om.ys
scripts/linalg.rep/code.ys
scripts/linalg.rep/code.ys.def
scripts/lists.rep/code.ys
scripts/lists.rep/code.ys.def
scripts/lists.rep/scopestack.ys
scripts/lists.rep/scopestack.ys.def
scripts/localrules.rep/code.ys
scripts/localrules.rep/code.ys.def
scripts/logic.rep/code.ys
scripts/logic.rep/code.ys.def
scripts/logic.rep/om.ys
scripts/multivar.rep/code.ys
scripts/multivar.rep/code.ys.def
scripts/multivar.rep/makemulti.ys
scripts/multivar.rep/sparsenomial.ys
scripts/multivar.rep/sparsetree.ys
scripts/multivar.rep/sparsetree.ys.def
scripts/newly.rep/code.ys
scripts/newly.rep/code.ys.def
scripts/nintegrate.rep/code.ys
scripts/nintegrate.rep/code.ys.def
scripts/numbers.rep/GaussianIntegers.ys
scripts/numbers.rep/GaussianIntegers.ys.def
scripts/numbers.rep/NumberTheory.ys
scripts/numbers.rep/NumberTheory.ys.def
scripts/numbers.rep/code.ys
scripts/numbers.rep/code.ys.def
scripts/numbers.rep/nthroot.ys
scripts/numbers.rep/nthroot.ys.def
scripts/numbers.rep/om.ys
scripts/odesolver.rep/code.ys
scripts/odesolver.rep/code.ys.def
scripts/openmath.rep/code.ys
scripts/openmath.rep/code.ys.def
scripts/orthopoly.rep/code.ys
scripts/orthopoly.rep/code.ys.def
scripts/packages.ys
scripts/padic.rep/code.ys
scripts/padic.rep/code.ys.def
scripts/patterns.rep/code.ys
scripts/patterns.rep/code.ys.def
scripts/physics.rep/quantum/clebsch-gordan.ys
scripts/physics.rep/quantum/clebsch-gordan.ys.def
scripts/plots.rep/backends-2d.ys
scripts/plots.rep/backends-3d.ys
scripts/plots.rep/code.ys
scripts/plots.rep/code.ys.def
scripts/plots.rep/plot2d.ys
scripts/plots.rep/plot2d.ys.def
scripts/plots.rep/plot3d.ys
scripts/plots.rep/plot3d.ys.def
scripts/predicates.rep/code.ys
scripts/predicates.rep/code.ys.def
scripts/probability.rep/code.ys
scripts/probability.rep/code.ys.def
scripts/products.rep/code.ys
scripts/products.rep/code.ys.def
scripts/pslq.rep/code.ys
scripts/pslq.rep/code.ys.def
scripts/r_form.rep/code.ys
scripts/r_form.rep/code.ys.def
scripts/rabinmiller.rep/code.ys
scripts/rabinmiller.rep/code.ys.def
scripts/radsimp.rep/code.ys
scripts/radsimp.rep/code.ys.def
scripts/random.rep/code.ys
scripts/random.rep/code.ys.def
scripts/rational.rep/code.ys
scripts/rational.rep/code.ys.def
scripts/simplify.rep/code.ys
scripts/simplify.rep/code.ys.def
scripts/simplify.rep/factorial.ys
scripts/simplify.rep/factorial.ys.def
scripts/solve.rep/code.ys
scripts/solve.rep/code.ys.def
scripts/specfunc.rep/bernou.ys
scripts/specfunc.rep/bernou.ys.def
scripts/specfunc.rep/bessel.ys
scripts/specfunc.rep/bessel.ys.def
scripts/specfunc.rep/code.ys
scripts/specfunc.rep/code.ys.def
scripts/specfunc.rep/gamma.ys
scripts/specfunc.rep/gamma.ys.def
scripts/specfunc.rep/gammaconst.ys
scripts/specfunc.rep/gammaconst.ys.def
scripts/specfunc.rep/om.ys
scripts/specfunc.rep/zeta.ys
scripts/specfunc.rep/zeta.ys.def
scripts/standard.ys
scripts/standard.ys.def
scripts/statistics.rep/distributions.ys
scripts/statistics.rep/distributions.ys.def
scripts/statistics.rep/hypothesystest.ys
scripts/statistics.rep/hypothesystest.ys.def
scripts/statistics.rep/incompletegamma.ys
scripts/statistics.rep/incompletegamma.ys.def
scripts/statistics.rep/randomtest.ys
scripts/statistics.rep/regression.ys
scripts/statistics.rep/regression.ys.def
scripts/statistics.rep/statistics.ys
scripts/statistics.rep/statistics.ys.def
scripts/stats.rep/code.ys
scripts/stats.rep/code.ys.def
scripts/stdarith.ys
scripts/stdarith.ys.def
scripts/stdfuncs.rep/code.ys
scripts/stdfuncs.rep/code.ys.def
scripts/stdfuncs.rep/elemfuncs.ys
scripts/stdfuncs.rep/elemfuncs.ys.def
scripts/stdfuncs.rep/numerical.ys
scripts/stdfuncs.rep/numerical.ys.def
scripts/stdfuncs.rep/nummethods.ys
scripts/stdfuncs.rep/nummethods.ys.def
scripts/stdfuncs.rep/om.ys
scripts/stdopers.ys
scripts/stubs.rep/code.ys
scripts/stubs.rep/code.ys.def
scripts/stubs.rep/om.ys
scripts/substitute.rep/code.ys
scripts/substitute.rep/code.ys.def
scripts/sums.rep/code.ys
scripts/sums.rep/code.ys.def
scripts/sums.rep/om.ys
scripts/trigsimp.rep/code.ys.def
scripts/univar.rep/Cyclotomic.ys
scripts/univar.rep/Cyclotomic.ys.def
scripts/univar.rep/code.ys
scripts/trigsimp.rep/code.ys.def
scripts/univar.rep/Cyclotomic.ys
scripts/univar.rep/Cyclotomic.ys.def
scripts/univar.rep/code.ys
scripts/sums.rep/taylor.ys
scripts/sums.rep/taylor.ys.def
scripts/sums.rep/taylor3.ys
scripts/sums.rep/taylor3.ys.def
scripts/tensor.rep/code.ys
scripts/tensor.rep/code.ys.def
scripts/testers.rep/code.ys
scripts/testers.rep/code.ys.def
scripts/texform.rep/code.ys
scripts/texform.rep/code.ys.def
scripts/transforms.rep/code.ys
scripts/trigsimp.rep/code.ys.def
scripts/univar.rep/Cyclotomic.ys
scripts/univar.rep/Cyclotomic.ys.def
scripts/univar.rep/code.ys
scripts/transforms.rep/code.ys.def
scripts/trigsimp.rep/code.ys
scripts/trigsimp.rep/code.ys.def
scripts/univar.rep/Cyclotomic.ys
scripts/univar.rep/Cyclotomic.ys.def
scripts/univar.rep/code.ys
scripts/univar.rep/code.ys.def
scripts/univar.rep/sparse.ys
scripts/univar.rep/sparse.ys.def
scripts/univar.rep/sturm.ys
scripts/univar.rep/sturm.ys.def
scripts/yacasinit.ys)
if (ENABLE_CYACAS)
install (DIRECTORY scripts/ DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/yacas/scripts COMPONENT app)
endif ()
if (ENABLE_DOCS)
add_subdirectory (docs)
add_subdirectory (man)
endif()
if (ENABLE_JYACAS)
add_subdirectory (jyacas)
endif ()
if (ENABLE_CYACAS)
add_subdirectory (cyacas)
endif ()
if (ENABLE_CYACAS OR ENABLE_JYACAS)
add_subdirectory (tests)
endif ()
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Covenant Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
## Scope
This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at teoretyk@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
[homepage]: http://contributor-covenant.org
[version]: http://contributor-covenant.org/version/1/4/
================================================
FILE: COPYING
================================================
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!
================================================
FILE: ChangeLog
================================================
Changes are none, there is only the now.
================================================
FILE: README.rst
================================================
=====
yacas
=====
.. image:: https://img.shields.io/badge/license-LGPL--2.1%2B-blue.svg
:target: ./COPYING
.. image:: https://ci.appveyor.com/api/projects/status/r8gm1gdk61qe4rgd?svg=true
:target: https://ci.appveyor.com/project/grzegorzmazur/yacas
.. image:: http://readthedocs.org/projects/yacas/badge/?version=latest
:target: http://yacas.readthedocs.org/en/latest/?badge=latest
.. image:: https://api.codacy.com/project/badge/Grade/a66fdf5a0140492f9c6eee6c5ba18bd4
:target: https://www.codacy.com/manual/teoretyk/yacas?utm_source=github.com&utm_medium=referral&utm_content=grzegorzmazur/yacas&utm_campaign=Badge_Grade
.. image:: https://codecov.io/gh/grzegorzmazur/yacas/branch/master/graph/badge.svg
:target: https://codecov.io/gh/grzegorzmazur/yacas
Yacas (Yet Another Computer Algebra System) is a small and highly flexible
general-purpose Computer Algebra System (CAS). The syntax uses an
infix-operator grammar parser. The distribution contains a small library
of mathematical functions, but its real strength is in the language in which
you can easily write your own symbolic manipulation algorithms. The core engine
supports arbitrary precision arithmetic and is able to execute symbolic
manipulations on various mathematical objects by following user-defined rules.
For detailed information on yacas features and usage, see
`<http://www.yacas.org>`_.
=====
who is yacas for?
=====
This versatile Computer Algebra System (CAS) was developed to cater to a broad
audience, primarily consisting of mathematicians, engineers, and students. It
provides a user-friendly platform for performing symbolic mathematical computations,
solving intricate equations, all accessible via a command-line interface.
Furthermore, it serves as a free alternative to commercial CAS software.
For mathematics enthusiasts (probably less than 1% of the population),
this tool offers the capability to conduct advanced mathematical manipulations
and solve complex equations, making it valuable for research purposes and even
recreational mathematical exploration.
On the other hand, students can benefit from its educational potential,
using it as an open-source resource to learn and practice mathematics while
experiencing the advantages of an open-source product like Yacas.
=====
Getting Started
=====
Step by step guide to understand what yacas is about and start using it `<https://yacas.readthedocs.io/en/latest/getting_started/index.html>`_
=====
Downloads
=====
Yacas is available for a variety of platforms. See
`<http://www.yacas.org/getting_started/downloads/>`_
for binary packages and installation instructions.
=====
Screenshots
=====
For a preview on how yacas looks like
`<http://www.yacas.org/getting_started/screenshots/>`_
=====
Contact
=====
Report bugs or great enhancements ideas to our issue tracker `<https://github.com/grzegorzmazur/yacas/issues>`_
We have a forum to talk math! `<https://groups.google.com/g/yacas>`_
FAQ `<http://www.yacas.org/getting_started/faq/>`_
Yacas is distributed under the GNU LESSER GENERAL PUBLIC LICENSE v2.1 or, at
your discretion, any later version.
================================================
FILE: TODO
================================================
TODO:
- Manual titles do not correspond with the manual you go to.
- Ceil, Round and Floor, also try to force to a number.
- From Laurent Debacker:
In file scripts/integrate.rep/code.ys, shouldn't the
IntFunc(x,(_x)^(-1),Ln(x));
be
IntFunc(x,(_x)^(-1),Ln(Abs(x)));
My motivation is based on http://metric.ma.ic.ac.uk/integration/techniques/indefinite/standard-integrals/integral-of-one-over-x/index.html .
- Remove the examples directory from the scripts directory, placing them somewhere else to reduce jar file size.
- Use reflection to look up methods, will make the jar file smaller.
- make the default read-eval-print loop print to out on the go, at least for the off-line version.
- do a cleanup of the "ref" manual, first pass to throw away functions that should not have been there in the first place.
- second chapter in refprog titled "Programming" has way too many functions
- chapter "List operators" has way too many function entries.
- chapter "Control flow" has entries relating only to the off-line version
- chapter "predicates" has way too many function entries.
- chapter "Input/output and plotting" has way too many function entries.
- chapter "Number theory" needs to be cleaned up.
- do a cleanup of the other books also
- scripts/examples/ do somewhere else?
- examples should have their own tests
- Test suite fails on Java version. We *have* to make the test suite more lenient.
- Remove Fast* (does not seem to be used anywhere). FastArcSin, FastAssoc, FastIsPrime, FastLog, FastPower do seem to be used.
- get rid of the Ortho?Sum functions, replace with just one?
- (find other ...Num functions)
- NewtonNum
- Future, change name of builtin functions that are not directly accessible to outside to have prefix Builtin'...
- Skim through Math... functions, renaming them to Builtin'...
- manuals, provide as zip files? more people can use unzip than can use untar.
- cos(arccos(x)) -> x+k*2*pi etc
- try if I can't change the format of numbers from 0.xxx to x.xxxx, is more natural
- make plain site not too wide also
- Move brackets slightly down in tex form pretty renderer, especially when what they bracket is not too big.
- step-by-step solver possible?
- screenshots, explanation of how to use, demo, tipbox, or *something*, to persuade people to enter something in the search field
- carefully change things so that the scripts do not have things like "N(Eval(" any more (just grep on it).
1) Documentation improvements
- examples embedded in the manual
- document ":test" to run test code from article
- link to mark-up documentation from the editors.
- what is Yacas? How did it come into existence? Why did I write it? Who is it for?
- mention the use of lists for passing multiple arguments.
============================================================================================================
- document the algorithms used, and expand on all of the functions currently implemented.
- separate manual chapter on tensors. (Serge? Is it going to change?). TSimplify and TExplicitSum, TD, X
- document the source code.
- document HoldArg in combination with <-- (or actually remove HoldArg? I want to depreciate UnFence/HoldArg in favor of macros)
- document II, ReII, ImII, IsComplexII
- document ExpressionDepth, PAdicExpandInternal, GetPrimeFactors, Rem, Roots, Apart, Together
- document UnHoldable, GcdReduce, ApplyPure, DestructiveAppendList, Pattern'Matches, Pattern'Create, RuleBaseDefined, Lambda (in combination with Apply), Primes, MapArgs, Substitute,
- document %, |, &, ^, if, else (else binds to the last if)
- document DivPoly, RootsWithMultiples,
- document OdeSolve
- document Dimensions, IsSquareMatrix, Tr.
- document Deriv, Berlekamp, ExtendedEuclidean, ExtendedEuclideanMonic
- document IsVariable
- document the fact that VarList can also be called with a second argument, a filter predicate.
- document Extended predicates in the pattern matcher (needs to be explained).
- document DefaultTokenizer()
- document XmlTokenizer, XmlExplodeTag
- document BSearch, FindIsq Search for a zero in a monotonously growing function. BSearch returns -1 if not found, FindIsq returns the insertion point.
- document MultiDivide, MultiGcd, Groebner
- document DefLoadFunction
- document CharString (input integer, output a string with one char, using the ascii code passed in).
- document FloatIsInt
- document Explain what is destructive about the Destructive... routines, why they are there, and when to use them.
- document Do slightly more on pure functions, to show why they are useful. Show for example Select.
- document Explain what Simplify currently does (internal algorithm).
- document The PcreLexer and PcreNextToken functions
- document Small summary of regular expressions syntax accepted.
- document Html... commands.
- document some blurb on the pattern matching/multivirtual functionality.
- Clean up integration code, and document algorithm used.
- document the extra Is... predicates for matrices that was added by Jonathan
- document threaded use of integration
2) Web site improvements
- allow saving multiple programs in cookies
- work through mommies feedback
- computer calculations made easy zou ik in lijn met het logo plaatsen liefst in lijn met de groene balletjes. Nu zweeft het een beetje los.
- Get Yacas en contact us is goed, maar ik zou het wat lager plaatsen in lijn met de tabs, maar wel zo laten als tekst links.
- Explain that a connection to the server is not needed, and that Yacas can be run off-line (with a link to a download of the Yacas web site).
============================================================================================================
- should I reconsider the way things are compressed? tgz? Why not zip?
- when leaving codeedit page, ask to remember code?
- think through wat it would look like if you could add content
- make all screens go 100% (edit, tutorial?) or at least center?
- create a clickable program snippet that is other than a one-liner (?)
- ideally programs should be uploaded to the datahub from the example
pages themselves, and not from recent.html, but for some reason that did
not work. When going from deeply-linked, trying it out does not work any
more and editing it also not.
- make descr/view/edit pages not reload, but refresh content dynamically
- In the tutorial, at "Solve", show how to verify that results are correct
3) Research
- Scan through my articles
- scan through examples already in examples directory in scripts dir
- take a look at Axiom code
- take a look at Maxima code
============================================================================================================
- Think through series of articles on tensors.
- Quaternions example?
- Example: the logarithmic derivative example from Fateman is nice.
- example: inverse, integrate taylor of 1/f'
- example: generating a polynomial solution for an ordinary DE
- For fun: try to understand Hensel lifting, and can it be made to apply
to say Feynman diagrams?
5) Math improvements
============================================================================================================
- allow control over formatting of floats.
- bumping up a version number seems to force a recompile of all the C++ files, config.h rewritten or so?
- make all the code more consistent, assuming that variables are real-valued.
- remove use of UnFence/HoldArg in favor of macros
- after use of UnFence/HoldArg has been removed, remove support for it
- local transforms: postpredicates do not seem to work any more.
- pattern matcher that can work on rings
- Change the system to use the II way of dealing with complex numbers in
favor of the Complex(r,i) construct.
- When the change to the II way of doing complex numbers is finished, add
it to the tutorial (if not already there), and change the manual
accordingly
- replace perl code in favor of C++ code, easier to maintain.
- sparserep from multi, use for uni too
- lists/arrays interchangable
- remove all uses of local files/directories.
- global var access, test code using a function to return a list of global
variables.
- Clean up Solve code, and document algorithm used.
- remove the final references to stdlib in the code.
- put Nl() in a common place (if it is still defined in different places
or an odd place).
- test Apart for polys. This might have to be adjusted by adding using the
same mechanism used for the integer version.
- Taylor on functions containing Abs/Sign can not be trusted (no idea what
I meant by that, but worth checking).
- Define the Local,.. functions based on their Macro counterparts, in the
scripts.
- also define a Head and Tail for arrays, and append/concat/
insert/delete/copy. This will ease swapping between lists and arrays.
- Allow for type convertors in pattern matchers. For instance: IsUniVar,
should be combined with CanBeUni and NormalForm to get the correct one
back.
- A RuleBaseDefined-like function that returns a list of defined arities.
- FindZeroes (polynoms and other functions)
- redivide some code ('newly')
- make suchthat more powerful, so it simplifies sin(x)=cos(x) to tan(x)=1
to x=Pi/4
- groebner bases
- see if using arrays for matrices speeds up things.
- Fix CanBeUni so that it deals correctly with 1/c
- EquateCoefs equate coefficients in two polys, and return as list.
- document /. and /:: with <-
- allow solve to return a list usable in /.
- matrix^negative is inverse^positive
6) Bugs:
============================================================================================================
- some limits not working correctly when using infinity: Limit(x,Infinity)
Zeta(x)
- factorize not checking for correctness of arguments:
Factorize(Infinity), Factorize(-1)
- Limit(x,0)D(x,2)Sin(x)/x never terminates (or rather takes a very long
time), which in turn causes Taylor(x,0,5)Sin(x)/x to never terminate.
- Limit(x,Infinity) x^n/Ln(x) returns n*Infinity, should be Infinity
- Limit(x,0,Right) x^( Ln(a)/(1+Ln(x)) ) returns 1, should be "a"
- [A:={{1,2,3,4},{0,1,2,3},{0,0,1,2},{I,0,I,I}}; EigenValues(A);] hangs
- L'Hopital's theorem is not always the correct thing to do. There
is a paper by Richardson, Salvy et al "Asymptotic expansions of exp-log
functions" that may be helpful.
- TrigSimpCombine(x^500)' exhausts the stack
- 'Solve(Exp(x^2)==Exp(x),x)' yields {} instead of {0,1}.
- BUG: InverseTaylor not working correctly for Sin and Tan???
- BUG: complex^float.
- Mod(a,b) generates some "UniVariate()" calls if a and b are undefined (I
expected it to return unevaluated). If one of them is defined, and the
other undefined, Mod() returns some numbers. Mod(x,-3) returns
unevaluated. I'm not sure what the "correct" meaning of Mod is for
negative moduli bases, but the answer should in any case be non-negative.
Mod(a,b) is defined as the smallest non-negative number c such that a-c is
divisible by b.
- Simplify(4-x-y) returns 4-y-x, Simplify(4-y-x) returns 4-x-y
- Functions to be implemented in the Java version still:
- LispFastMod
- YacasDllLoad
- LispPatchLoad
- LispPatchString
- Some more functions that are defined in yacasmain.cpp: Exit, IsExitRequested, HistorySize, StaSiz, IsPromptShown, ReadCmdLineString, FileSize
- LispDefaultTokenizer
- LispCommonLispTokenizer
- LispXmlTokenizer
- LispExplodeTag
- LispCustomEval
- LispCustomEvalExpression
- LispCustomEvalResult
- LispCustomEvalLocals
- LispCustomEvalStop
- LispTraceRule
- LispTraceStack
- command line flags for Java console version, useful for doing the test scripts
- Supporting the default read-eval-print loop from script in Java?
- Run the tests from Java
- Give some performance statistics on comparison between Java and C++
8) Unsorted:
============================================================================================================
- Search for defines I want to remove
- Document TeXFormMaxPrec()
- Document DefFileList()
- check that unnecessary scripts are not loaded unnecessarily (in debug mode?)
- Document FormulaMaxWidth()
- Document SetFormulaMaxWidth(width)
- Document the debugging facilities in the debug version, warnings on setting global variables etcetera.
- Global variables are still used in the wester test file
- Global variables are still used in the scripts that build the manuals
- Global variables are still used in the scripts that create the plugin stubs
- Global variables are still used in the scripts that compile/create for example libmath.cpp
- Is there not enough in common between the different files platfileio.h that we should perhaps consider merging them?
- For N, Verbose, etcetera, in stead of LocalSymbols guarding scope, perhaps a macro that generalizes the concept (with getters and setters, for a type of expandable singleton).
- have the application work in a directory structure that is identical to the source tree. --rootdir should be more general (set it and you can find the documentation also, etcetera).
- plotting functions are extremely verbose, this code needs to be reduced I feel
- other os-ish modules that I think are ugly, ShowPS ? Tries to write to /tmp/?
- examples direcory in scripts/, needed?
- allow sending openmath expressions and receiving them from a socket.
- allow parsing without having to require a ;
- removing ] from output
- Remove MacroSet/MacroClear and friends in favor of macros? makes the whole system simpler, and easier to compile.
- Erf does not work for numbers larger than one but not too large.
- http://www.causascientia.org/math_stat/Dists/Compendium.pdf
- remove TODOs in the source code
- document as of yet undocumented functions
- Try Yacas from some other applet, as a scripting language
- Try out MapReduce
- allow for a custom REP loop in server mode (would actually be trivial when sockets are defined in Yacas language)
- Mention MultiGcd in the documentation where polynomial operations are explained.
- make sure there are no collisions (axiom link in links.html for example) ???
- change all references to LISP in to YACAS, and Lisp in to Yacas
- univar.rep/Cyclotomic.ys is the only file to start with a capital (perhaps change to lower case?)
- some garbage (double defined functions) I'd like to remove from univar
- Taylor series expansion of Tan is slow, use other form for derivative?
- Solve: see if I can recreate HEQS?
- YacasInterpreter: also allow it to work from an applet?
- Write test for Solve({mean==(A/(A+B)),variance==((A*B)/(((A+B)^2) * (A+B+1)))},{A,B})
- There are warnings about YacasBase not having a virtual destructor, problem?
- document the behavior of underscores in Yacas.
- Clebsch-Gordan coefficients:
- Get Clebsch-Gordan code in to the main Yacas distribution.
- Test code for Clebsch-Gordan
- documentation for Clebsch-Gordan
- document *how* the random number generators work.
- -pc flags should also withhold the In> and Out> printing. Document that you need to use --read-eval-print ""
- http://centaur.maths.qmul.ac.uk/Computer_Algebra/MathAlgs/mathalgs.pdf
- restructure the documentation (there are a lot of unfinished parts written by Ayal).
- rewrite anumber, and document it this time.
- implement precision tracking the way Serge wants it, in the anumber version of BigNumber
- slowness of Taylor, due to its trivial implementation. Perhaps we should do something about this as soon as we have series calculus.
- Solve is way too simplistic.
- (Is this still true?) MatchAtom still compares atoms by string representation! It should raise an error if you define a pattern with a float in it.
============================================================================================================
9) Article fodder:
UI to search solution spaces
============================
Computers have made many laborious tasks easier to do. You can look up mathematical things in a database-ish way, or have the computer do repetitive work. There are more things computers are good at. Because you can design a user interface, you can design how it interacts with humans, you can effectively design a custom tool for a task.
When I did my internship (high-energy physics, Zeus, 1995-1996, at NIKHEF H) I used a user interface to get more results. The task at hand with high-energy physics is as follows; you have this massive accelerator that accelerates particles in a tube. The accelerated particle beams collide, and out of the collision come other particles. The particles that come out of it can tell you something about the structure of the particles that collided. Now at the point where the collision takes place people place what they call a detector. This detector detects particles coming from the collision. The collisions occur at enormous rates, so you get an enormous amount of data coming from these detectors. Any way, the data is filtered a bit (the amount of data coming from these detectors is so vast that one can not possibly hope to capture all of it, so electronics boards are designed to be able to handle the high bandwidth of data and filter out the events for which it is absolutely sure that the researchers will not be interested in it, reducing the amount of data captured), and then ends on a harddisk somewhere, in what they call (or used to call, don't know how it works nowadays) ntuples, essentially one big database table with rows of records, each record with some fields. Each row is an isolated event that might be of interest. Now the trick is to make a selection of the events, and plot a certain number. For example, one could take all the events where the electron (one of the incoming particles) scattered heavily backwards, and then plot the mass of the whole system, as in a histogram, where you accumulate the results of events with mass between two values in one bin, mass between other values in the next bin, etcetera. You would then see a sea of noise, with hopefully a peak in it, which would be called a "resonance", and would indicate that there had been a short-lived particle with that mass. The narrower the peak, the longer-lived the particles. The wider the peak, the shorter-lived the particles. This way you could measure the speed at which they decayed, which you can also calculate from theory sometimes, or at least use as an input parameter for theory. And you could measure the precise point of the top, so as to give you the mass of the particle. And you could count the number of events that were in the peak, and again compare that to theory, which should be able to give a prediction of the amount of events that were observed given the intensity of the beams colliding against each other. The trick would be to find the area where the resonance (the peak) should be, and try to design filters that reduce the background noise while keeping as much as possible of the signal. The filters would be simple things (often referred to as <i>cuts</i>, as they cut out a part of the data). For example, you could select all the events for which a specific value in one of the fields of the ntuple was larger than a certain value. Or smaller than a specific value. Large part of the work consisted of just trial-and-error, finding the good cuts to apply as to get the best view on the resonance. The cut to apply was the real information being sought. It required hard work, putting in many many many hours. The more hours you worked, the more likely you were to find something interesting. Being smart is not enough in such a case, as luck plays a big role (as they say, luck is when opportunity meets preparation). After you found the best cuts to apply to the data, it was surprisingly little information you needed to communicate. It could be as little as just a few conditionals, selecting all the events with, say, a detected electron, and where the virtual photon had a larger energy than such and so, and ... Surprisingly hard work for so little information. One would then proceed to get an estimate of the curve representing the noise, and subtract that from the data, to arrive at the pure signal.
A good estimate of the total noise is then subtracted from the total data in what is hoped to then be the resulting signal of the resonance being sought. The task is thus essentially just to count how often something happened, and to try to make a wise selection of the events to look at.
<make a drawing explaining the noise versus signal>
One problem I encountered during my internship was that due to the fact that there was just such a vast amount of data, each time I wanted to change a cut, you had to wait forever (10 minutes sometimes), for the result. You would wander off and do something else, and come back to the window where you were trying the cut, wondering what it was again you were trying out. It all just moved very slow.
So one weekend I resolved to make a nice little tool to make my life easier. The entire group worked on a Silicon Graphics workstation at that time, which apparently had cost the equivalent of 150,000.00 euros, and carried an astonishing 256 megabytes of RAM. Twelve people worked on that. Chances are you are now reading this article on a computer that cost a fraction of that machine, and has many times more memory than we had back then. And we were doing cutting edge research! But I digress.
I used what knowledge I had already gleaned from the data to make a stricter selection on the data. What resulted was something like 38 megabytes of data remaining. What I then did was load that all in to memory (I waited until every one had gone home so I had the full system to myself, one advantage of working on big iron). In addition, I kept an index of each field, and sorted the records per that field, in that index. Now, I created a little user interface that would show a graph, histogram, of the counts of number of events per bin. And I defined scrollbars that allowed me to define ranges from within to select data. Those were effectively two cuts, one to the left and one to the right, limiting the amount to fall within a range of two values, a<x<b. I defined that for certain fields that I thought might give me the results I was looking for (in hindsight, I was already close to finding the right cuts any way, this tool just made me find it faster, but more on that later). For each event, I would keep a reference count. The reference count would start at zero, but as soon as the event fell outside of the selection, the reference count would be increased by one. When it fell from outside a selection to inside a selection again, the count would be decreased. When the scrollbar got dragged, I would only have to visit a few of the events, as I had a sorted index of them. Moreover, for each event, I could then remove it from the bin count if its reference count became nonzero, and add it to the bin again if the reference count became zero again.
The above allowed me to go through the data with breakneck speed. I could dynamically change cuts and see the result a split-second later, where previously I would have had to wait for ten minutes sometimes. My internship was already a success because I had found the resonance I was looking for. But with the tool I was able to find two more resonances on the Monday morning following the weekend in which I had coded up the tool. Unfortunately, I later found out that other researchers had already found these resonances, but they must have only found them a short period before I did, as I hadn't found any publications yet when I found the resonances. If memory serves (it is more than ten years ago now) the cuts they found were different, but could probably be shown to be roughly equivalent to what I had found. I had dramatically increased the amount of space I could search per unit of time, increasing the chance of finding something interesting accordingly.
The point I want to make in this article that there might actually be a place for such tools in science. There might be a place for graphical user interfaces. Obviously they do not merit real new knowledge about nature, and would thus not merit a scientific publication, but as a tool they could be very useful. At the end of the day, research is about finding new things, and because what you are looking for is effectively unknown, you proceed by trial and error. And the more you try and the more you err, the more chance you have to accidentally run in to something interesting. With a graphical user interface you can make a custom tool that allows you to search a much much much larger space. With the example given in this article I went mining through data but one can equally make a tool that allows one to search in the world of platonic beauty, to discover new objects in the platonic world. Because such a tool could potentially make you much more productive, effectively making you in to many many researchers as you become as productive as many researchers. Moreover, this is an under-researched area, not many scientists looking at this. Fair enough, you would not be able to publish an article on how the tool works. Just the results of applying the tools yourself. But there is possibly something interesting to be found here. I can not help but wonder what great names from the past would have done had they had access to computers. Would they have used computers to do their work? Probably. Creating user interfaces to search larger parts of problem-solution spaces? Maybe...
The reason this has not been done could quite possibly be that it means you write a one-off tool to allow you to search in a space. In effect you write something you intend to throw away again soon. This goes against the usual activity of a scientist, which is to discover things that have eternal value.
For the coming period, I will be exploring this idea, and abusing the Yacas web site for this. Over time, this article section should fill up with articles on this subject, with little applets and snippets of Javascript to demonstrate the point. The focus will not be the usual approach where the applet creator tries to teach something, but rather the focus will be on tools that allow you to venture off in to the unknown. I believe that this is a fruitful area where a lot can be discovered still.
Embeddable applets
==================
I have thought in the past on-and-off about writing tools that would allow teachers to create lesson material using Yacas. This usually evolved in to an idea where there was some notebook (or similar metaphor), with the authoring tools to allow such a teacher to write rich documents, with graphs, interactive, etcetera (you would not want to write material for teachers, as most teachers probably think they can do a better job at it than you).
It is only recently that I realized that those tools actually already exist! There is no reason not to start using html with JavaScript, in combination with a Java applet. The Java applet could do the more computationally intensive work, like calculations or plotting, where one would use JavaScript for creating the user interface, the interactivity, and html for the layout.
You can use Yacas as an applet inside a page. In effect, it acts like a little server that runs inside the page. The JavaScript code can send requests to it, and receive answers back. Teachers could literally start to write interactive lesson material without having to install any software at all (a text editor and a web browser will do). No need to maintain a server, a plain web site will do. No need for the user to install any special software, other than a browser with Java and JavaScript support.
<some example applet allowing the user to perform operations on formulas, highschool>
- One-off tasks, completable in a few hours
- A look at Google Analytics
- Example: RootsOfUnity (nice example of threading): Exp(2*Pi*I*(1 .. n)/n)
- Example: Average (nice example of threading): Average(list_IsList) <-- Add(list)/Length(list);
- Example: Fibonacci series, Lucas series.
- Verify( Fibonacci(242), 168083057059453008835412295811648513482449585399521 );
- Verify( Fibonacci(6,.5), 2.03125 );
- Verify( Fibonacci(3,.5), 1.25 );
- Article: rant on strong typing versus test code
- Article on splitting documentation between the two target audiences "user" and "maintainer".
- poking fun at systems by caricaturizing their properties
================================================
FILE: appveyor.yml
================================================
branches:
only:
- master
- develop
skip_tags: true
platform:
- x64
configuration:
- Release
environment:
matrix:
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
CMAKE_GENERATOR: "Visual Studio 16 2019"
ENABLE_CYACAS_GUI: On
ENABLE_CYACAS_KERNEL: On
QTDIR: C:\Qt\5.15.2\msvc2019_64
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
CMAKE_GENERATOR: "Visual Studio 17 2022"
ENABLE_CYACAS_GUI: Off
ENABLE_CYACAS_KERNEL: On
QTDIR: C:\Qt\5.15.2\msvc2022_64
- APPVEYOR_BUILD_WORKER_IMAGE: Ubuntu2004
CMAKE_GENERATOR: "Ninja"
ENABLE_CYACAS_GUI: Off
ENABLE_CYACAS_KERNEL: On
QTDIR: $HOME/Qt/5.15.2/gcc_64/bin
- APPVEYOR_BUILD_WORKER_IMAGE: macos-bigsur
CMAKE_GENERATOR: "Xcode"
ENABLE_CYACAS_GUI: Off
ENABLE_CYACAS_KERNEL: Off
QTDIR: $HOME/Qt/5.15.2/clang_64/bin
install:
- cmd: if not exist C:\Tools\vcpkg\installed\x64-windows\bin (
cd c:\tools\vcpkg &
vcpkg install boost-filesystem:x64-windows &
vcpkg install boost-date-time:x64-windows &
vcpkg install boost-serialization:x64-windows &
vcpkg install boost-uuid:x64-windows &
vcpkg install boost-dll:x64-windows &
vcpkg install openssl:x64-windows &
vcpkg install zeromq:x64-windows &
vcpkg install jsoncpp:x64-windows &
vcpkg install cppzmq:x64-windows &
vcpkg integrate install
)
- sh: if [ "$APPVEYOR_BUILD_WORKER_IMAGE" == "Ubuntu2004" ]; then
sudo apt-get update -qq;
sudo apt-get install -qq libboost-all-dev libssl-dev libjsoncpp-dev libzmq3-dev;
fi
- sh: if [ "$APPVEYOR_BUILD_WORKER_IMAGE" == "macos-bigsur" ]; then
brew update;
brew upgrade;
brew install boost jsoncpp zeromq;
fi
cache:
- c:\tools\vcpkg\installed\ -> appveyor.yml
before_build:
- cmd: cd %APPVEYOR_BUILD_FOLDER%
- cmd: cmake -H. -Bbuild -G "%CMAKE_GENERATOR%" -DCMAKE_TOOLCHAIN_FILE=c:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake -DENABLE_CYACAS_KERNEL=%ENABLE_CYACAS_KERNEL% -DENABLE_CYACAS_UNIT_TESTS=Off -DENABLE_CYACAS_BENCHMARKS=Off -DENABLE_CYACAS_GUI=%ENABLE_CYACAS_GUI% -DCMAKE_PREFIX_PATH="%QTDIR%" -DCMAKE_INSTALL_PREFIX=%APPVEYOR_BUILD_FOLDER%\install
- sh: cd $APPVEYOR_BUILD_FOLDER
- sh: cmake -H. -Bbuild -G $CMAKE_GENERATOR -DCMAKE_BUILD_TYPE=Release -DENABLE_CYACAS_KERNEL=$ENABLE_CYACAS_KERNEL -DENABLE_CYACAS_UNIT_TESTS=Off -DENABLE_CYACAS_BENCHMARKS=Off -DENABLE_CYACAS_GUI=$ENABLE_CYACAS_GUI -DCMAKE_PREFIX_PATH="$QTDIR" -DCMAKE_INSTALL_PREFIX=$APPVEYOR_BUILD_FOLDER/install
build_script:
- cmd: cd %APPVEYOR_BUILD_FOLDER%\build
- cmd: cmake --build . --config Release --target install
- sh: cd $APPVEYOR_BUILD_FOLDER/build
- sh: cmake --build . --config Release --target install
test_script:
- cmd: cd %APPVEYOR_BUILD_FOLDER%\build
- cmd: ctest -C Release
- sh: cd $APPVEYOR_BUILD_FOLDER/build
- sh: ctest -C Release
after_build:
- cmd: cd ..\install
- cmd: 7z a yacas.zip *
- sh: cd ../install
- sh: zip -r yacas.zip *
artifacts:
- path: install/yacas.zip
name: yacas
================================================
FILE: build.xml
================================================
<project name="jyacas" default="jar" basedir=".">
<description>
jyacas build file
</description>
<property name="version" value="1.9.2" />
<property name="main" value="net.sf.yacas.YacasConsole" />
<property name="src" location="jyacas" />
<property name="scripts" location="scripts" />
<property name="tests" location="tests" />
<property name="build" location="build/ant" />
<property name="dist" location="dist/lib" />
<fileset dir="jyacas/lib" id="libs">
<include name="junit-4.11.jar" />
<include name="hamcrest-core-1.3.jar" />
</fileset>
<target name="init">
<tstamp/>
<mkdir dir="${build}" />
</target>
<target name="compile" depends="init"
description="compile the source" >
<delete file="${src}/net/sf/yacas/CVersion.java" quiet="true" />
<copy file="${src}/CVersion.java.in" tofile="${src}/net/sf/yacas//CVersion.java" >
<filterchain>
<replacestring from="$${YACAS_VERSION}" to="${version}"/>
</filterchain>
</copy>
<javac srcdir="${src}" destdir="${build}" includeantruntime="false">
<classpath>
<fileset refid="libs" />
</classpath>
<!--<compilerarg value="-Xlint"/>!-->
</javac>
<mkdir dir="${build}/scripts"/>
<copy todir="${build}/scripts">
<fileset dir="${scripts}"/>
</copy>
<copy todir="${build}/tests">
<fileset dir="${tests}"/>
</copy>
</target>
<target name="run" depends="compile" description="run yacas">
<java classname="${main}" classpath="${build}" fork="true">
<arg value="--rootdir" />
<arg value="${build}/scripts/" />
</java>
</target>
<target name="jar" depends="compile"
description="generate the distribution" >
<mkdir dir="${dist}"/>
<jar destfile="${dist}/yacas-${version}.jar" basedir="${build}" excludes="tests/**">
<manifest>
<attribute name="Main-Class" value="${main}"/>
<attribute name="Specification-Version" value="${version}"/>
<attribute name="Implementation-Version" value="${version}"/>
</manifest>
</jar>
</target>
<target name="test" depends="compile" description="run the tests">
<copy todir="${build}/tests">
<fileset dir="${scripts}"/>
</copy>
<junit dir="${build}" fork="yes" printsummary="withOutAndErr"
showoutput="true" errorProperty="test.failed"
failureProperty="test.failed" filtertrace="false">
<formatter type="xml" />
<formatter usefile="false" type="brief" />
<test name="net.sf.yacas.YacasTest" />
<classpath>
<pathelement path="${build}" />
<fileset refid="libs" />
</classpath>
</junit>
</target>
<target name="clean" description="clean up" >
<delete dir="${build}"/>
<delete dir="${dist}"/>
</target>
</project>
================================================
FILE: cyacas/CMakeLists.txt
================================================
if (APPLE)
set(CMAKE_MACOSX_RPATH 1)
set(CMAKE_INSTALL_FRAMEWORK_PREFIX "/Library/Frameworks" CACHE STRING "Directory to install frameworks to.")
set(CMAKE_INSTALL_BUNDLE_PREFIX "/Applications" CACHE STRING "Directory to install application bundles to.")
endif()
if (CMAKE_CXX_COMPILER_ID STREQUAL GNU OR CMAKE_CXX_COMPILER_ID STREQUAL Clang OR CMAKE_CXX_COMPILER_ID STREQUAL AppleClang)
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -Wall -fPIC")
elseif (MSVC)
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4800")
add_definitions(-DYACAS_NO_CONSTEXPR -DYACAS_NO_ATOMIC_TYPES -DYACAS_UINT32_T_IN_GLOBAL_NAMESPACE)
endif ()
if (CMAKE_SYSTEM_NAME STREQUAL Emscripten)
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -s DISABLE_EXCEPTION_CATCHING=0 -s ASSERTIONS=1 -s EXTRA_EXPORTED_RUNTIME_METHODS=['cwrap'] -s ALLOW_MEMORY_GROWTH=1")
set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --embed-file ${PROJECT_SOURCE_DIR}/scripts@/share/yacas/scripts")
endif ()
include(CheckIPOSupported)
check_ipo_supported(RESULT IPO_SUPPORTED)
add_library(coverage_config INTERFACE)
if (ENABLE_CODE_COVERAGE AND CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
# Add required flags (GCC & LLVM/Clang)
target_compile_options(coverage_config INTERFACE
-g # generate debug info
--coverage # sets all required flags
)
if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.13)
target_link_options(coverage_config INTERFACE --coverage)
else ()
target_link_libraries(coverage_config INTERFACE --coverage)
endif ()
endif ()
add_subdirectory (libyacas_mp)
add_subdirectory (libyacas)
if (ENABLE_CYACAS_CONSOLE)
add_subdirectory (yacas)
endif ()
if (ENABLE_CYACAS_GUI)
add_subdirectory (yacas-gui)
endif ()
if (ENABLE_CYACAS_KERNEL)
add_subdirectory (yacas-kernel)
endif ()
if (ENABLE_CYACAS_XEUS)
add_subdirectory (xeus-yacas)
endif ()
================================================
FILE: cyacas/libyacas/CMakeLists.txt
================================================
configure_file (
"config/yacas/yacas_version.h.in"
"${CMAKE_CURRENT_BINARY_DIR}/config/yacas/yacas_version.h"
)
set (SOURCES
src/associationclass.cpp
src/deffile.cpp
src/infixparser.cpp
src/lispatom.cpp
src/lispenvironment.cpp
src/lispeval.cpp
src/lisperror.cpp
src/lispio.cpp
src/lispobject.cpp
src/lispparser.cpp
src/lispuserfunc.cpp
src/mathcommands.cpp
src/mathuserfunc.cpp
src/standard.cpp
src/stdfileio.cpp
src/arggetter.cpp
src/stringio.cpp
src/tokenizer.cpp
src/yacasapi.cpp
src/lispevalhash.cpp
src/patterns.cpp
src/patternclass.cpp
src/substitute.cpp
src/mathcommands2.cpp
src/mathcommands3.cpp
src/mempool.cpp
src/errors.cpp
src/patcher.cpp
src/xmltokenizer.cpp
src/anumber.cpp
src/yacasnumbers.cpp
src/numbers.cpp
src/platmath.cpp
src/lisphash.cpp)
set (HEADERS
include/yacas/anumber.h
include/yacas/anumber.inl
include/yacas/arggetter.h
include/yacas/arrayclass.h
include/yacas/associationclass.h
include/yacas/corefunctions.h
include/yacas/deffile.h
include/yacas/errors.h
include/yacas/evalfunc.h
include/yacas/genericobject.h
include/yacas/GPL_stuff.h
include/yacas/infixparser.h
include/yacas/lispatom.h
include/yacas/lispenvironment.h
include/yacas/lisperror.h
include/yacas/lispeval.h
include/yacas/lispevalhash.h
include/yacas/lispglobals.h
include/yacas/lisphash.h
include/yacas/lispio.h
include/yacas/lispobject.h
include/yacas/lispoperator.h
include/yacas/lispparser.h
include/yacas/lispstring.h
include/yacas/lispuserfunc.h
include/yacas/mathcommands.h
include/yacas/mathuserfunc.h
include/yacas/mempool.h
include/yacas/noncopyable.h
include/yacas/numbers.h
include/yacas/patcher.h
include/yacas/patternclass.h
include/yacas/patterns.h
include/yacas/platfileio.h
include/yacas/platmath.h
include/yacas/refcount.h
include/yacas/standard.h
include/yacas/standard.inl
include/yacas/stringio.h
include/yacas/string_utils.h
include/yacas/substitute.h
include/yacas/tokenizer.h
include/yacas/utf8/core.h
include/yacas/utf8/checked.h
include/yacas/utf8/unchecked.h
include/yacas/utf8.h
include/yacas/xmltokenizer.h
include/yacas/yacas.h)
add_library (libyacas ${SOURCES} ${HEADERS})
set_target_properties (libyacas PROPERTIES OUTPUT_NAME "yacas" INTERPROCEDURAL_OPTIMIZATION ${IPO_SUPPORTED})
target_include_directories (libyacas PUBLIC include "${CMAKE_CURRENT_BINARY_DIR}/config")
target_link_libraries (libyacas PUBLIC libyacas_mp coverage_config)
install (TARGETS libyacas LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT app)
install (DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} COMPONENT dev)
install (FILES "${CMAKE_CURRENT_BINARY_DIR}/config/yacas/yacas_version.h" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/yacas COMPONENT dev)
# if (APPLE)
# add_library (libyacas_framework SHARED ${SOURCES} ${HEADERS})
# set_target_properties(libyacas_framework PROPERTIES OUTPUT_NAME "yacas" VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION} FRAMEWORK ON)
# target_link_libraries(libyacas_framework libyacas_mp)
# target_include_directories (libyacas_framework PUBLIC include "${CMAKE_CURRENT_BINARY_DIR}/config")
# add_custom_command(TARGET libyacas_framework POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory ${PROJECT_SOURCE_DIR}/scripts $<TARGET_FILE_DIR:libyacas_framework>/Resources/scripts)
# add_custom_command(TARGET libyacas_framework POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/include $<TARGET_FILE_DIR:libyacas_framework>/Headers)
# add_custom_command(TARGET libyacas_framework POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_BINARY_DIR}/config $<TARGET_FILE_DIR:libyacas_framework>/Headers)
# add_custom_command(TARGET libyacas_framework POST_BUILD COMMAND cd "$<TARGET_FILE_DIR:libyacas_framework>/../.." && rm -f Headers && ln -s Versions/Current/Headers Headers)
# install (TARGETS libyacas_framework FRAMEWORK DESTINATION ${CMAKE_INSTALL_FRAMEWORK_PREFIX} COMPONENT framework)
# endif()
================================================
FILE: cyacas/libyacas/config/yacas/yacas_version.h.in
================================================
#ifndef YACAS_VERSION
#define YACAS_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
#define YACAS_VERSION_MINOR @PROJECT_VERSION_MINOR@
#define YACAS_VERSION_MICRO @PROJECT_VERSION_PATCH@
#define YACAS_VERSION "@PROJECT_VERSION@"
#endif
================================================
FILE: cyacas/libyacas/include/yacas/GPL_stuff.h
================================================
#ifndef YACAS_GPL_STUFF_H
#define YACAS_GPL_STUFF_H
#define GPL_base_text \
"Yacas is Free Software--Free as in Freedom--so you can redistribute Yacas or\n" \
"modify it under certain conditions. Yacas comes with ABSOLUTELY NO WARRANTY.\n" \
"See the GNU Lesser General Public License (LGPL) version 2.1 or (at your\n" \
"discretion) any later version for the full conditions.\n"
#define Yacas_Web_info \
"See http://www.yacas.org/ for more information on yacas. and documentation.\n"\
"Type ?? for help. Or type ?function for help on a function.\n"
#define Yacas_help_info \
"Type ?license or ?licence to see the LGPL version 2.1;\n"
// This is the full text for systems where the online help (?blah) is available
#define GPL_blurb GPL_base_text Yacas_help_info Yacas_Web_info "\n"
// This is for systems where online help (?blah) is normally not available
#define GPL_blurb_nohelp GPL_base_text Yacas_Web_info "\n"
#endif
================================================
FILE: cyacas/libyacas/include/yacas/anumber.h
================================================
#ifndef YACAS_ANUMBER_H
#define YACAS_ANUMBER_H
#include <cassert>
#include <cctype>
#include <string>
#include <vector>
#include "yacas/mp/zz.hpp"
// These define the internal types for the arbitrary precision
// number module. The larger they are the better. PlatDoubleWord
// should be at least twice as big as PlatWord, to prevent overflowing
// during multiplication.
typedef std::uint32_t PlatWord;
typedef std::uint64_t PlatDoubleWord;
typedef std::int64_t PlatSignedDoubleWord;
/* Quantities derived from the platform-dependent types for doing
* arithmetic.
*/
#define WordBits (8*sizeof(PlatWord))
#define WordBase (((PlatDoubleWord)1)<<WordBits)
/* Class ANumber represents an arbitrary precision number. it is
* basically an array of PlatWord objects, with the first element
* being the least significant. iExp <= 0 for integers.
*/
class ANumber : public std::vector<PlatWord>
{
public:
ANumber(const std::string& aString,int aPrecision,int aBase=10);
ANumber(const yacas::mp::ZZ&, int aPrecision);
explicit ANumber(int aPrecision);
//TODO the properties of this object are set in the member initialization list, but then immediately overwritten by the CopyFrom. We can make this slightly cleaner by only initializing once.
inline ANumber(const ANumber& aOther) : std::vector<PlatWord>(), iExp(0),iNegative(false),iPrecision(0),iTensExp(0)
{
CopyFrom(aOther);
}
void CopyFrom(const ANumber& aOther);
bool ExactlyEqual(const ANumber& aOther);
void SetTo(const std::string& aString,int aBase=10);
int Precision() const;
void SetPrecision(int aPrecision) {iPrecision = aPrecision;}
void ChangePrecision(int aPrecision);
void RoundBits();
void DropTrailZeroes();
void Expand();
void Negate();
bool IsZero() const;
bool IsNegative() const;
bool IsEven() const;
void Print(std::ostream&, const std::string& prefix) const;
public:
int iExp;
bool iNegative;
int iPrecision;
int iTensExp;
};
inline
int ANumber::Precision() const
{
return iPrecision;
}
bool BaseLessThan(const ANumber& a1, const ANumber& a2);
bool BaseGreaterThan(const ANumber& a1, const ANumber& a2);
void BaseDivide(ANumber& aQuotient, ANumber& aRemainder, ANumber& a1, ANumber& a2);
void IntegerDivide(ANumber& aQuotient, ANumber& aRemainder, ANumber& a1, ANumber& a2);
bool Significant(ANumber& a);
int WordDigits(int aPrecision, int aBase);
// Operations on ANumber.
void Negate(ANumber& aNumber);
void ANumberToString(std::string& aResult, ANumber& aNumber, int aBase, bool aForceFloat=false);
void Add(ANumber& aResult, ANumber& a1, ANumber& a2);
void Subtract(ANumber& aResult, ANumber& a1, ANumber& a2);
void Multiply(ANumber& aResult, ANumber& a1, ANumber& a2);
void Divide(ANumber& aQuotient, ANumber& aRemainder, ANumber& a1, ANumber& a2);
bool GreaterThan(ANumber& a1, ANumber& a2);
bool LessThan(ANumber& a1, ANumber& a2);
void BaseShiftRight(ANumber& a, int aNrBits);
void BaseShiftLeft(ANumber& a, int aNrBits);
void NormalizeFloat(ANumber& a2, int digitsNeeded);
inline
void ANumber::Negate()
{
iNegative = !iNegative;
// FIXME: do we need negative zero?
if (IsZero())
iNegative = false;
}
inline
bool ANumber::IsZero() const
{
return std::all_of(begin(), end(), [](PlatWord a) {return a == 0;});
}
inline
bool ANumber::IsNegative() const
{
return iNegative;
}
inline
bool ANumber::IsEven() const
{
return (front() & 1) == 0;
}
#include "anumber.inl"
#endif
================================================
FILE: cyacas/libyacas/include/yacas/anumber.inl
================================================
#include "anumber.h"
/* BaseTimesInt : multiply a with one digit in the range 0..(aBase-1)
*/
template<class T>
inline void BaseTimesInt(T& a,PlatDoubleWord aNumber, PlatDoubleWord aBase)
{
PlatDoubleWord carry=0;
const int nr=a.size();
typename T::value_type * aptr = &a[0];
for (int i=0;i<nr;i++)
{
const PlatDoubleWord word = ((PlatDoubleWord)(*aptr))*aNumber+carry;
*aptr++ = word % aBase;
carry= word / aBase;
}
if (carry)
a.push_back(carry);
}
template<class T>
inline void WordBaseTimesInt(T& a,PlatDoubleWord aNumber)
{
PlatDoubleWord carry=0;
const int nr=a.size();
typename T::value_type * aptr = &a[0];
for (int i=0;i<nr;i++)
{
const PlatDoubleWord word = ((PlatDoubleWord)(*aptr))*aNumber+carry;
*aptr++ = word;
carry= word >> WordBits;
}
if (carry)
a.push_back(carry);
}
template<class T>
inline void BaseDivideInt(T& a,PlatDoubleWord aNumber, PlatDoubleWord aBase, PlatDoubleWord& aCarry)
{
const int nr=a.size();
PlatDoubleWord carry=0;
typename T::value_type * aptr = &a[0];
for (int i=nr-1;i>=0;i--) {
const PlatDoubleWord word = (carry*aBase)+((PlatDoubleWord)(aptr[i]));
aptr[i] = word / aNumber;
carry= word % aNumber;
}
//carry now is the remainder
aCarry = carry;
}
/* GrowDigits : add digits to a until it has aDigits digits
*/
template<class T>
inline void GrowDigits(T& a, std::size_t aDigits)
{
if (aDigits <= a.size())
return;
a.resize(aDigits, 0);
}
/* BaseAdd : destructively add aSource to aTarget, in base aBase.
*/
template<class T>
inline void BaseAdd(T& aTarget, const T& aSource, PlatDoubleWord aBase)
{
// Initialize result
GrowDigits(aTarget,aSource.size());
aTarget.push_back(0);
int nr = std::min(aTarget.size(), aSource.size());
PlatDoubleWord carry=0;
const typename T::value_type * sourcePtr = &aSource[0];
typename T::value_type * targetPtr = &aTarget[0];
for (int digit=0;digit<nr;digit++)
{
PlatDoubleWord word;
word = (PlatDoubleWord)targetPtr[digit] +
(PlatDoubleWord)sourcePtr[digit] + carry;
PlatDoubleWord newDigit = (word%aBase);
PlatDoubleWord newCarry = (word/aBase);
targetPtr[digit] = (typename T::value_type)newDigit;
carry = newCarry;
}
while (carry != 0)
{
PlatSignedDoubleWord ww = targetPtr[nr];
ww+=carry;
targetPtr[nr] = (typename T::value_type)(ww%aBase); // PDG - cast to avoid compile-time warning
carry = ww/aBase;
nr++;
}
}
template<class T>
inline void WordBaseAdd(T& aTarget, const T& aSource)
{
// Initialize result
GrowDigits(aTarget,aSource.size());
aTarget.push_back(0);
int nr = std::min(aTarget.size(), aSource.size());
PlatDoubleWord carry=0;
const typename T::value_type * sourcePtr = &aSource[0];
typename T::value_type * targetPtr = &aTarget[0];
for (int digit=0;digit<nr;digit++)
{
PlatDoubleWord word;
word = (PlatDoubleWord)targetPtr[digit] +
(PlatDoubleWord)sourcePtr[digit] + carry;
PlatWord newDigit = (PlatWord)(word);
PlatWord newCarry = (PlatWord)(word >> WordBits);
targetPtr[digit] = (typename T::value_type)newDigit;
carry = newCarry;
}
while (carry != 0)
{
PlatSignedDoubleWord ww = targetPtr[nr];
ww+=carry;
targetPtr[nr] = (typename T::value_type)ww; // PDG - cast to avoid compile-time warning
carry = ww >> WordBits;
nr++;
}
}
template<class T>
inline void BaseSubtract(T& aResult, T& a2, int offset)
{
if (a2.IsZero())
return;
// Initialize result
int nr = a2.size();
typename T::value_type * resultPtr = &aResult[0];
typename T::value_type * a2ptr = &a2[0];
while (a2ptr[nr-1] == 0)
nr--;
// Subtract on a per-digit basis
PlatSignedDoubleWord carry=0;
int digit;
for (digit=0;digit<nr;digit++)
{
PlatSignedDoubleWord word;
word = ((PlatSignedDoubleWord)resultPtr[digit+offset]) -
((PlatSignedDoubleWord)a2ptr[digit]) +
(PlatSignedDoubleWord)carry;
carry=0;
while (word<0)
{
word+=WordBase;
carry--;
}
resultPtr[digit+offset] = ((PlatWord)(word));
}
while (carry != 0)
{
assert(nr+offset<aResult.size());
int newCarry = 0;
PlatSignedDoubleWord ww = resultPtr[nr+offset]+carry;
while (ww<0)
{
ww = ww + WordBase;
newCarry = newCarry - 1;
}
resultPtr[nr+offset]=(typename T::value_type)ww;
carry = newCarry;
offset++;
}
}
/* BaseIntNumber : convert a number into a different base,
*/
inline void BaseIntNumber(std::string& aTarget, PlatSignedDoubleWord aNumber, PlatWord aBase)
{
// Assume aBase is an integer > 0.
// Assume aNumber is an integer > 0.
// Assume PlatDoubleWord is an integer type.
// Will maximum digit (i.e., aBase-1) convert to T::value_type right?
//LISPASSERT( (typename T::value_type)(aBase) == (aBase) ); // use aBase instead, to help CTCE
aTarget.clear();
while (aNumber != 0)
{
aTarget.push_back(aNumber%aBase);
aNumber/=aBase;
}
if (aTarget.empty())
aTarget.push_back(0);
}
// BaseAddMultiply : multiply x and y, and add result to aTarget
//
inline
void BaseAddMultiply(std::string& aTarget, const std::string& x, const std::string& y, PlatDoubleWord aBase) {
const unsigned nrx = static_cast<unsigned>(x.size());
const unsigned nry = static_cast<unsigned>(y.size());
GrowDigits(aTarget, nrx + nry + 1);
std::string::value_type *targetPtr = &aTarget[0];
const std::string::value_type *xPtr = &x[0];
const std::string::value_type *yPtr = &y[0];
for (unsigned ix = 0; ix < nrx; ix++) {
PlatDoubleWord carry = 0;
for (unsigned iy = 0; iy < nry; iy++) {
const PlatDoubleWord word =
static_cast<PlatDoubleWord> (targetPtr[ix + iy]) +
static_cast<PlatDoubleWord> (xPtr[ix]) *
static_cast<PlatDoubleWord> (yPtr[iy]) + carry;
targetPtr[ix + iy] = word % aBase;
carry = word / aBase;
}
targetPtr[ix + nry] += carry;
}
}
template<class T>
inline void WordBaseAddMultiply(T& aTarget, const T& x, const T& y)
{
const unsigned nrx=x.size();
const unsigned nry=y.size();
GrowDigits(aTarget,nrx+nry+1);
typename T::value_type *targetPtr = &aTarget[0];
const typename T::value_type *xPtr = &x[0];
const typename T::value_type *yPtr = &y[0];
for (unsigned ix=0;ix<nrx;ix++)
{
PlatDoubleWord carry = 0;
for (unsigned iy=0;iy<nry;iy++)
{
PlatDoubleWord word =
static_cast<PlatDoubleWord>(targetPtr[ix+iy])+
static_cast<PlatDoubleWord>(xPtr[ix])*
static_cast<PlatDoubleWord>(yPtr[iy])+carry;
targetPtr[ix+iy] = word;
carry = word >> WordBits;
}
const PlatDoubleWord word =
static_cast<PlatDoubleWord>(targetPtr[ix+nry])+carry;
targetPtr[ix+nry] = word;
assert((word >> WordBits) == 0);
}
}
/* BaseMultiply : multiply x and y, and put result in aTarget
*/
template<class T>
inline void BaseMultiply(T& aTarget, const T& x, const T& y, PlatDoubleWord aBase)
{
aTarget.resize(1);
aTarget[0] = 0;
BaseAddMultiply(aTarget, x, y, aBase);
}
template<class T>
inline void WordBaseMultiply(T& aTarget, const T& x, const T& y)
{
aTarget.resize(1);
aTarget[0] = 0;
WordBaseAddMultiply(aTarget, x, y);
}
template<class T>
inline
bool IsZero(const T& a)
{
const typename T::value_type *ptr = &a[0];
const typename T::value_type *endptr = ptr + a.size();
while (ptr != endptr)
if (*ptr++ != 0)
return false;
return true;
}
template<class T>
inline void WordBaseDivide(T& aQuotient, T& aRemainder, T& a1, T& a2)
{
// Find the values n and m as described in Knuth II:
int n=a2.size();
assert(n>0);
assert(a2[n-1] != 0);
//a1.size() = m+n => m = a1.size()-n
int m = a1.size()-n;
assert(m>=0);
aQuotient.resize(m+1);
//D1:
//this calculates d = base/(a2[n-1]+1);
PlatDoubleWord d = WordBase/(static_cast<PlatDoubleWord>(a2[n-1])+1);
WordBaseTimesInt(a1, d);
WordBaseTimesInt(a2, d);
a1.push_back(0);
a2.push_back(0);
//D2:
int j = m;
while (j>=0)
{
//D3:
PlatDoubleWord q = (a1[j+n]*WordBase+a1[j+n-1])/a2[n-1];
PlatDoubleWord r = (a1[j+n]*WordBase+a1[j+n-1])%a2[n-1];
REDO:
if (q == WordBase || q*a2[n-2] > WordBase*r+a1[j+n-2])
{
q = q - 1;
r = r + a2[n-1];
if (r < WordBase)
goto REDO;
}
//D4:
ANumber sub(aQuotient.Precision());
sub.CopyFrom(a2);
WordBaseTimesInt(sub, q);
sub.push_back(0);
PlatSignedDoubleWord carry;
{//Subtract the two
//TODO this can be generalized!!!!
//
// Beware though: this is not a normal subtraction. Only a
// certain set of digits ends up being subtracted.
// First check if qv isn't too big...
carry = 0;
for (int digit=0;digit<=n;digit++)
{
PlatSignedDoubleWord word;
word = ((PlatSignedDoubleWord)a1[digit+j]) -
((PlatSignedDoubleWord)sub[digit]) +
(PlatSignedDoubleWord)carry;
carry=0;
while (word<0)
{
word+=WordBase;
carry--;
}
}
if (carry)
{
q--;
sub.CopyFrom(a2);
WordBaseTimesInt(sub, q);
sub.push_back(0);
}
carry = 0;
for (int digit=0;digit<=n;digit++)
{
PlatSignedDoubleWord word;
word = ((PlatSignedDoubleWord)a1[digit+j]) -
((PlatSignedDoubleWord)sub[digit]) +
(PlatSignedDoubleWord)carry;
carry=0;
while (word<0)
{
word+=WordBase;
carry--;
}
a1[digit+j] = ((PlatWord)(word));
}
}
assert(carry == 0);
//D5:
aQuotient[j] = (typename T::value_type)q;
//D7:
j--;
}
//D8:
a1.resize(n);
PlatDoubleWord carry;
BaseDivideInt(a1, d, WordBase,carry);
aRemainder.CopyFrom(a1);
}
inline
void ANumber::Expand()
{
if (iExp+1>int(size()))
insert(end(), iExp+1-int(size()), 0);
}
================================================
FILE: cyacas/libyacas/include/yacas/arggetter.h
================================================
#ifndef YACAS_ARGGETTER_H
#define YACAS_ARGGETTER_H
#include "lispenvironment.h"
/// Get an argument that should be a short integer
int GetShortIntegerArgument(LispEnvironment& aEnvironment, int aStackTop, int iArgNr);
#endif
================================================
FILE: cyacas/libyacas/include/yacas/arrayclass.h
================================================
#ifndef YACAS_ARRAYCLASS_H
#define YACAS_ARRAYCLASS_H
#include "lispobject.h"
#include "genericobject.h"
#include <vector>
class ArrayClass final: public GenericClass
{
public:
//required
ArrayClass(std::size_t aSize,LispObject* aInitialItem);
const char* TypeName() const override;
//array-specific
std::size_t Size() const;
LispObject* GetElement(std::size_t aItem) const;
void SetElement(std::size_t aItem,LispObject* aObject);
private:
std::vector<LispPtr> iArray;
};
inline
ArrayClass::ArrayClass(std::size_t aSize, LispObject* aInitialItem):
iArray(aSize, LispPtr(aInitialItem))
{
}
inline
const char* ArrayClass::TypeName() const
{
return "\"Array\"";
}
inline
std::size_t ArrayClass::Size() const
{
return iArray.size();
}
inline
LispObject* ArrayClass::GetElement(std::size_t aItem) const
{
assert(aItem > 0 && aItem<=iArray.size());
return iArray[aItem-1];
}
inline
void ArrayClass::SetElement(std::size_t aItem, LispObject* aObject)
{
assert(aItem > 0 && aItem<=iArray.size());
iArray[aItem-1] = aObject;
}
#endif
================================================
FILE: cyacas/libyacas/include/yacas/associationclass.h
================================================
/*
* This file is part of yacas.
* Yacas is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesset General Public License as
* published by the Free Software Foundation, either version 2.1
* of the License, or (at your option) any later version.
*
* Yacas is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with yacas. If not, see <http://www.gnu.org/licenses/>.
*
*/
/*
* File: associationclass.h
* Author: mazur
*
* Created on September 29, 2015, 3:44 PM
*/
#ifndef ASSOCIATIONCLASS_H
#define ASSOCIATIONCLASS_H
#include "lispobject.h"
#include "genericobject.h"
#include "standard.h"
#include <map>
class AssociationClass final: public GenericClass
{
public:
AssociationClass(const LispEnvironment& env);
const char* TypeName() const override;
std::size_t Size() const;
bool Contains(LispObject* k) const;
LispObject* GetElement(LispObject* k);
void SetElement(LispObject* k,LispObject* v);
bool DropElement(LispObject* k);
LispPtr Keys() const;
LispPtr ToList() const;
LispPtr Head() const;
private:
class Key {
public:
Key(const LispEnvironment& env, LispObject* p):
value(p), _env(env) {}
bool operator == (const Key& rhs) const
{
return InternalEquals(_env, value, rhs.value);
}
bool operator < (const Key& rhs) const
{
return InternalStrictTotalOrder(_env, value, rhs.value);
}
LispPtr value;
private:
const LispEnvironment& _env;
};
const LispEnvironment& _env;
std::map<Key, LispPtr> _map;
};
inline
AssociationClass::AssociationClass(const LispEnvironment& env):
_env(env)
{
}
inline
const char* AssociationClass::TypeName() const
{
return "\"Association\"";
}
inline
std::size_t AssociationClass::Size() const
{
return _map.size();
}
inline
bool AssociationClass::Contains(LispObject* k) const
{
return _map.find(Key(_env, k)) != _map.end();
}
inline
LispObject* AssociationClass::GetElement(LispObject* k)
{
auto p = _map.find(Key(_env, k));
if (p != _map.end())
return p->second;
return nullptr;
}
inline
void AssociationClass::SetElement(LispObject* k, LispObject* v)
{
_map[Key(_env, LispPtr(k))] = v;
}
inline
bool AssociationClass::DropElement(LispObject* k)
{
return _map.erase(Key(_env, LispPtr(k)));
}
#endif /* ASSOCIATIONCLASS_H */
================================================
FILE: cyacas/libyacas/include/yacas/corefunctions.h
================================================
//
// declare the core functions that have special syntax
//
OPERATOR(bodied,KMaxPrecedence,While)
OPERATOR(bodied,KMaxPrecedence,Rule)
OPERATOR(bodied,KMaxPrecedence,MacroRule)
OPERATOR(bodied,KMaxPrecedence,RulePattern)
OPERATOR(bodied,KMaxPrecedence,MacroRulePattern)
OPERATOR(bodied,KMaxPrecedence,FromFile)
OPERATOR(bodied,KMaxPrecedence,FromString)
OPERATOR(bodied,KMaxPrecedence,ToFile)
OPERATOR(bodied,KMaxPrecedence,ToString)
OPERATOR(bodied,KMaxPrecedence,ToStdout)
OPERATOR(bodied,KMaxPrecedence,TraceRule)
OPERATOR(bodied,KMaxPrecedence,Subst)
OPERATOR(bodied,KMaxPrecedence,LocalSymbols)
OPERATOR(bodied,KMaxPrecedence,BackQuote)
OPERATOR(prefix,0,`)
OPERATOR(prefix,0,@)
OPERATOR(prefix,0,_)
OPERATOR(infix,0,_)
//
// Evaluation direction.
//
CORE_KERNEL_FUNCTION("Hold",LispQuote,1,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Eval",LispEval,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
//
// Input/output functions
//
CORE_KERNEL_FUNCTION("Write",LispWrite,1,YacasEvaluator::Function | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("WriteString",LispWriteString,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("FullForm",LispFullForm,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("DefaultDirectory",LispDefaultDirectory,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("FromFile",LispFromFile,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("FromString",LispFromString,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Read",LispRead,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("ReadToken",LispReadToken,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("ToFile",LispToFile,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("ToString",LispToString,1,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("ToStdout",LispToStdout,1,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Load",LispLoad,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("TmpFile",LispTmpFile,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
//
// Symbol protection
//
CORE_KERNEL_FUNCTION("Protect",LispProtect, 1, YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("UnProtect",LispUnProtect, 1, YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("IsProtected",LispIsProtected, 1, YacasEvaluator::Macro | YacasEvaluator::Fixed)
//
// Variable setting/clearing
//
CORE_KERNEL_FUNCTION("Set",LispSetVar,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MacroSet",LispMacroSetVar,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
// MacroClear is the same as Clear, but with its arguments evaluated first
CORE_KERNEL_FUNCTION("Clear",LispClearVar,1,YacasEvaluator::Macro | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("MacroClear",LispClearVar,1,YacasEvaluator::Function | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("Local",LispNewLocal,1,YacasEvaluator::Macro | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("MacroLocal",LispNewLocal,1,YacasEvaluator::Function | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("Variables", LispVars, 0, YacasEvaluator::Function | YacasEvaluator::Fixed)
//
// List and compound object manipulation
//
CORE_KERNEL_FUNCTION("Head",LispHead,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathNth",LispNth,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Tail",LispTail,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("DestructiveReverse",LispDestructiveReverse,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Length",LispLength,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("List",LispList,1,YacasEvaluator::Macro | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("UnList",LispUnList,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Listify",LispListify,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Concat",LispConcatenate,1,YacasEvaluator::Function | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("ConcatStrings",LispConcatenateStrings,1,YacasEvaluator::Function | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("Delete",LispDelete,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("DestructiveDelete",LispDestructiveDelete,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Insert",LispInsert,3,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("DestructiveInsert",LispDestructiveInsert,3,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Replace",LispReplace,3,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("DestructiveReplace",LispDestructiveReplace,3,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Atom",LispAtomize,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("String",LispStringify,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("CharString",LispCharString,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("FlatCopy",LispFlatCopy,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
//???CORE_KERNEL_FUNCTION("",LispNoCacheConcatenateStrings)
//
// Program control flow
//
CORE_KERNEL_FUNCTION("Prog",LispProgBody,1,YacasEvaluator::Macro | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("While",LispWhile,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("If",LispIf,2,YacasEvaluator::Macro | YacasEvaluator::Variable)
//
// Error handling
//
CORE_KERNEL_FUNCTION("Check",LispCheck,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("TrapError",LispTrapError,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("GetCoreError",LispGetCoreError,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
//
// User function definition
//
CORE_KERNEL_FUNCTION("Prefix",LispPreFix,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Infix",LispInFix,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Postfix",LispPostFix,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Bodied",LispBodied,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("RuleBase",LispRuleBase,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MacroRuleBase",LispMacroRuleBase,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("RuleBaseListed",LispRuleBaseListed,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MacroRuleBaseListed",LispMacroRuleBaseListed,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("DefMacroRuleBase",LispDefMacroRuleBase,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("DefMacroRuleBaseListed",LispDefMacroRuleBaseListed,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("HoldArg",LispHoldArg,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Rule",LispNewRule,5,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MacroRule",LispMacroNewRule,5,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("UnFence",LispUnFence,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Retract",LispRetract,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
//
// Predicates
//
CORE_KERNEL_FUNCTION("MathNot",LispNot,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION_ALIAS("Not",LispNot,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathAnd",LispLazyAnd,1,YacasEvaluator::Macro | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION_ALIAS("And",LispLazyAnd,1,YacasEvaluator::Macro | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("MathOr",LispLazyOr,1,YacasEvaluator::Macro | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION_ALIAS("Or",LispLazyOr,1,YacasEvaluator::Macro | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("Equals",LispEquals,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION_ALIAS("=",LispEquals,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("LessThan",LispLessThan,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("GreaterThan",LispGreaterThan,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("IsFunction",LispIsFunction,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("IsAtom",LispIsAtom,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("IsNumber",LispIsNumber,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("IsInteger",LispIsInteger,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("IsList",LispIsList,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("IsString",LispIsString,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("IsBound",LispIsBound,1,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("StrictTotalOrder",LispStrictTotalOrder,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
//
// Math functions (REQUIRING number inputs);.
//
CORE_KERNEL_FUNCTION("MathMultiply",LispMultiply,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathAdd",LispAdd,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathSubtract",LispSubtract,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathDivide",LispDivide,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Builtin'Precision'Set",YacasBuiltinPrecisionSet,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathGetExactBits",LispGetExactBits,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathSetExactBits",LispSetExactBits,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathBitCount",LispBitCount,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathSign",LispMathSign,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathIsSmall",LispMathIsSmall,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathNegate",LispMathNegate,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathFloor",LispFloor,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathCeil",LispCeil,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathAbs",LispAbs,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathMod",LispMod,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathDiv",LispDiv,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("BitsToDigits",LispBitsToDigits,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("DigitsToBits",LispDigitsToBits,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathGcd",LispGcd,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("FastArcSin",LispFastArcSin,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("FastLog",LispFastLog,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("FastPower",LispFastPower,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("ShiftLeft",LispShiftLeft,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("ShiftRight",LispShiftRight,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("FromBase",LispFromBase,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("ToBase",LispToBase,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MaxEvalDepth",LispMaxEvalDepth,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("DefLoad",LispDefLoad,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Use",LispUse,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("RightAssociative",LispRightAssociative,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("LeftPrecedence",LispLeftPrecedence,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("RightPrecedence",LispRightPrecedence,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("IsBodied",LispIsBodied,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("IsInfix",LispIsInFix,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("IsPrefix",LispIsPreFix,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("IsPostfix",LispIsPostFix,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("OpPrecedence",LispGetPrecedence,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("OpLeftPrecedence",LispGetLeftPrecedence,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("OpRightPrecedence",LispGetRightPrecedence,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Builtin'Precision'Get",YacasBuiltinPrecisionGet,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("BitAnd",LispBitAnd,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("BitOr",LispBitOr,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("BitXor",LispBitXor,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Secure",LispSecure,1,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("FindFile",LispFindFile,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("FindFunction",LispFindFunction,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
// Generic object support
CORE_KERNEL_FUNCTION("IsGeneric",LispIsGeneric,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("GenericTypeName",LispGenericTypeName,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Array'Create",GenArrayCreate,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Array'Size",GenArraySize,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Array'Get",GenArrayGet,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Array'Set",GenArraySet,3,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Association'Create",GenAssociationCreate,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Association'Size",GenAssociationSize,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Association'Contains",GenAssociationContains,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Association'Get",GenAssociationGet,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Association'Set",GenAssociationSet,3,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Association'Drop",GenAssociationDrop,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Association'Keys",GenAssociationKeys,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Association'ToList",GenAssociationToList,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Association'Head",GenAssociationHead,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("CustomEval",LispCustomEval,4,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("CustomEval'Expression",LispCustomEvalExpression,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("CustomEval'Result",LispCustomEvalResult,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("CustomEval'Locals",LispCustomEvalLocals,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("CustomEval'Stop",LispCustomEvalStop,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("TraceRule",LispTraceRule,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("TraceStack",LispTraceStack,1,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("LispRead",LispReadLisp,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("LispReadListed",LispReadLispListed,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Type",LispType,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("StringMid'Get",YacasStringMidGet,3,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("StringMid'Set",YacasStringMidSet,3,YacasEvaluator::Function | YacasEvaluator::Fixed)
// Pattern matching
CORE_KERNEL_FUNCTION("Pattern'Create",GenPatternCreate,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Pattern'Matches",GenPatternMatches,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("RuleBaseDefined",LispRuleBaseDefined,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("DefLoadFunction",LispDefLoadFunction,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("RuleBaseArgList",LispRuleBaseArgList,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("RulePattern",LispNewRulePattern,5,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MacroRulePattern",LispMacroNewRulePattern,5,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Subst",LispSubst,3,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("LocalSymbols",LispLocalSymbols,1,YacasEvaluator::Macro | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("FastIsPrime",LispFastIsPrime,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("MathFac",LispFac,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("ApplyPure",LispApplyPure,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("PrettyReader'Set",YacasPrettyReaderSet,1,YacasEvaluator::Function | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("PrettyReader'Get",YacasPrettyReaderGet,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("PrettyPrinter'Set",YacasPrettyPrinterSet,1,YacasEvaluator::Function | YacasEvaluator::Variable)
CORE_KERNEL_FUNCTION("PrettyPrinter'Get",YacasPrettyPrinterGet,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("GarbageCollect",LispGarbageCollect,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("SetGlobalLazyVariable",LispSetGlobalLazyVariable,2,YacasEvaluator::Macro | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("PatchLoad",LispPatchLoad,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("PatchString",LispPatchString,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("DefaultTokenizer",LispDefaultTokenizer,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("XmlTokenizer",LispXmlTokenizer,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("XmlExplodeTag",LispExplodeTag,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Builtin'Assoc",YacasBuiltinAssoc,2,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("CurrentFile",LispCurrentFile,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("CurrentLine",LispCurrentLine,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("`",LispBackQuote,1,YacasEvaluator::Macro | YacasEvaluator::Fixed)
//
// Operating System services
//
CORE_KERNEL_FUNCTION("SystemCall", LispSystemCall, 1, YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("SystemName", LispSystemName, 0, YacasEvaluator::Function | YacasEvaluator::Fixed)
//
// Debugging functions
//
CORE_KERNEL_FUNCTION("MathDebugInfo",LispDumpBigNumberDebugInfo,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("InDebugMode",LispInDebugMode,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("DebugFile",LispDebugFile,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("DebugLine",LispDebugLine,1,YacasEvaluator::Function | YacasEvaluator::Fixed)
//
// Information functions
//
CORE_KERNEL_FUNCTION("Interpreter",interpreter,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
CORE_KERNEL_FUNCTION("Version",LispVersion,0,YacasEvaluator::Function | YacasEvaluator::Fixed)
================================================
FILE: cyacas/libyacas/include/yacas/deffile.h
================================================
/** \file deffile.h deffiles, which speed up loading.
* This module adds support for loading files which specify
* which script file to look for when trying to use a specific
* function.
*/
#ifndef YACAS_DEFFILE_H
#define YACAS_DEFFILE_H
#include "yacas/lispstring.h"
#include <unordered_map>
#include <unordered_set>
/** LispDefFile represents one file that can be loaded just-in-time.
*/
class LispDefFile
{
public:
LispDefFile(const std::string& aFile);
void SetLoaded();
bool IsLoaded() const;
const std::string& FileName() const;
private:
std::string iFileName;
bool iIsLoaded;
public:
std::unordered_set<const LispString*> symbols;
};
/** LispDefFiles maintains an array of files that can be defloaded.
* When the user invokes a DefLoad on a file, an entry is added to the
* array of deffiles in the LispEnvironment class. When the function
* is called, and there is no body of rules defined for this function,
* the engine looks up the correct file to load from this associated
* has class.
*/
class LispDefFiles
{
public:
LispDefFile* File(const std::string& aFileName);
private:
std::unordered_map<std::string, LispDefFile> _map;
};
class LispEnvironment;
void LoadDefFile(LispEnvironment& aEnvironment, const std::string& aFileName);
inline
bool LispDefFile::IsLoaded() const
{
return iIsLoaded;
}
inline
const std::string& LispDefFile::FileName() const
{
return iFileName;
}
#endif
================================================
FILE: cyacas/libyacas/include/yacas/errors.h
================================================
#ifndef YACAS_ERRORS_H
#define YACAS_ERRORS_H
#include "lispenvironment.h"
void CheckArg(bool pred, int arg_idx, LispEnvironment& env, int stack_top);
void CheckArgIsString(LispPtr arg, int arg_idx, LispEnvironment& env, int stack_top);
void CheckArgIsString(int arg_idx, LispEnvironment& env, int stack_top);
void CheckArgIsList(LispPtr arg, int arg_idx, LispEnvironment& env, int stack_top);
void CheckArgIsList(int arg_idx, LispEnvironment& env, int stack_top);
void CheckNrArgs(int n, LispPtr& aArguments, LispEnvironment& aEnvironment);
void ShowStack(LispEnvironment& aEnvironment);
void ShowFunctionError(LispPtr& aArguments, LispEnvironment& aEnvironment);
void CheckSecure(LispEnvironment& env, int stack_top);
#endif
================================================
FILE: cyacas/libyacas/include/yacas/evalfunc.h
================================================
#ifndef YACAS_EVALFUNCBASE_H
#define YACAS_EVALFUNCBASE_H
// class EvalFuncBase defines the interface to 'something that can
// evaluate'
class LispEnvironment;
class EvalFuncBase
{
public:
virtual void Evaluate(LispPtr& aResult,LispEnvironment& aEnvironment,
LispPtr& aArguments) const = 0;
virtual ~EvalFuncBase() = default;
};
#endif
================================================
FILE: cyacas/libyacas/include/yacas/genericobject.h
================================================
#ifndef YACAS_GENERICOBJECT_H
#define YACAS_GENERICOBJECT_H
/// Abstract class which can be put inside a LispGenericClass.
class GenericClass {
public:
GenericClass() : iReferenceCount(0) {};
virtual ~GenericClass() = default;
virtual const char* TypeName() const = 0;
public:
unsigned iReferenceCount; //TODO: perhaps share the method of reference counting with how it is done in other places
};
#endif
================================================
FILE: cyacas/libyacas/include/yacas/infixparser.h
================================================
/** \file infixparser.h
* parsing and printing in the infix style.
*
*/
#ifndef YACAS_INFIXPARSER_H
#define YACAS_INFIXPARSER_H
#include "lispparser.h"
#include "lispoperator.h"
#include <ostream>
#include <unordered_map>
class InfixParser final: public LispParser
{
public:
InfixParser(LispTokenizer& aTokenizer,
LispInput& aInput,
LispEnvironment& aEnvironment,
LispOperators& aPrefixOperators,
LispOperators& aInfixOperators,
LispOperators& aPostfixOperators,
LispOperators& aBodiedOperators);
void Parse(LispPtr& aResult) override;
public:
LispOperators& iPrefixOperators;
LispOperators& iInfixOperators;
LispOperators& iPostfixOperators;
LispOperators& iBodiedOperators;
private:
void ParseCont(LispPtr& aResult);
};
class ParsedObject {
public:
ParsedObject(InfixParser& aParser):
iParser(aParser),
iEndOfFile(false),
iLookAhead(0),
iResult(0)
{
}
void Parse();
private:
void ReadToken();
void MatchToken(const LispString * aToken);
void ReadExpression(int depth);
void ReadAtom();
private:
void GetOtherSide(int aNrArgsToCombine, int depth);
void Combine(int aNrArgsToCombine);
void InsertAtom(const LispString* aString);
private:
void Fail(); // called when parsing fails, raising an exception
private:
InfixParser& iParser;
private:
bool iEndOfFile;
const LispString* iLookAhead;
public:
LispPtr iResult;
};
class InfixPrinter final: public LispPrinter
{
public:
InfixPrinter(LispOperators& aPrefixOperators,
LispOperators& aInfixOperators,
LispOperators& aPostfixOperators,
LispOperators& aBodiedOperators)
: iPrefixOperators(aPrefixOperators),
iInfixOperators(aInfixOperators),
iPostfixOperators(aPostfixOperators),
iBodiedOperators(aBodiedOperators),
iPrevLastChar(0),iCurrentEnvironment(nullptr){}
void Print(
const LispPtr& aExpression,
std::ostream& aOutput,
LispEnvironment& aEnvironment) override;
void RememberLastChar(char aChar) override;
private:
void Print(
const LispPtr& aExpression,
std::ostream& aOutput,
int iPrecedence);
void WriteToken(std::ostream& aOutput, const std::string& aString);
private:
LispOperators& iPrefixOperators;
LispOperators& iInfixOperators;
LispOperators& iPostfixOperators;
LispOperators& iBodiedOperators;
char iPrevLastChar;
LispEnvironment* iCurrentEnvironment;
};
#endif
================================================
FILE: cyacas/libyacas/include/yacas/lispatom.h
================================================
/** \file lispatom.h
* implementation of the standard lisp elements: atom and sublist.
*
* class LispAtom. This class implements one atom, which is a
* reference to a string it represents, and a pointer to the next
* lisp atom if it is in a list.
* It also has a pointer to the annotation object.
* The local class LispPtr implements automatic garbage collection
* through reference counting.
*
* The class LispNumber inherits from LispAtom and holds a numeric atom
* in the string representation and in the numeric representation (BigNumber).
* The string representation is converted to BigNumber (using the current precision for floats) when a numeric
* operation is first requested on the atom. The BigNumber representation is
* converted to the string representation whenever the number needs to be printed i.e. LispAtom::String() method is requested.
* The string is held in the number (to avoid repeated conversions) and also cached in the string cache (this caching will eventually be abandoned).
* When LispNumber is constructed from BigNumber, no string representation is available.
* Conversion from string to BigNumber is done only if no BigNumber object is present.
*/
#ifndef YACAS_LISPATOM_H
#define YACAS_LISPATOM_H
#include "lispobject.h"
#include "lispstring.h"
#include "mempool.h"
#include "numbers.h" // RefPtr<BigNumber> needs definition of BigNumber
#include "noncopyable.h"
/// This should be used whenever constants 2, 10 mean binary and decimal.
// maybe move somewhere else?
#ifdef YACAS_NO_CONSTEXPR
const int BASE10 = 10;
const int BASE2 = 2;
#else
constexpr int BASE10 = 10;
constexpr int BASE2 = 2;
#endif
class LispEnvironment;
class LispAtom: public LispObject, public FastAlloc<LispAtom>
{
public:
static LispObject* New(LispEnvironment& aEnvironment, const std::string& aString);
const LispString* String() override;
LispObject* Copy() const override { return new LispAtom(*this); }
private:
LispAtom(const LispString* aString);
LispStringSmartPtr iString;
};
//------------------------------------------------------------------------------
// LispSublist
class LispSubList: public LispObject, public FastAlloc<LispSubList>
{
public:
static LispSubList* New(LispObject* aSubList);
~LispSubList() override;
LispPtr* SubList() override { return &iSubList; }
LispObject* Copy() const override { return new LispSubList(*this); }
private:
// Constructor is private -- use New() instead
LispSubList(LispObject* aSubList) : iSubList(aSubList) {} // iSubList's constructor is messed up (it's a LispPtr, duh)
public:
LispSubList(const LispSubList& other): LispObject(other), iSubList(other.iSubList) {}
private:
LispPtr iSubList;
};
//------------------------------------------------------------------------------
// LispGenericClass
class LispGenericClass: public LispObject, public FastAlloc<LispGenericClass>
{
public:
static LispGenericClass* New(GenericClass* aClass);
~LispGenericClass() override;
GenericClass* Generic() override;
LispObject* Copy() const override { return new LispGenericClass(*this); }
private:
// Constructor is private -- use New() instead
LispGenericClass(GenericClass* aClass);
public:
LispGenericClass(const LispGenericClass& other) : LispObject(other), iClass(other.iClass) { iClass->iReferenceCount++; }
private:
LispGenericClass& operator=(const LispGenericClass& other) = delete;
private:
GenericClass* iClass;
};
class LispNumber: public LispObject, public FastAlloc<LispNumber>
{
public:
/// constructors:
/// construct from another LispNumber
LispNumber(BigNumber* aNumber) : iNumber(aNumber), iString(nullptr) {}
LispNumber(const LispNumber& other) : LispObject(other), iNumber(other.iNumber), iString(other.iString) {}
/// construct from a decimal string representation (also create a number object) and use aBasePrecision decimal digits
LispNumber(LispString * aString, int aBasePrecision) : iNumber(nullptr), iString(aString) { Number(aBasePrecision); }
LispObject* Copy() const override { return new LispNumber(*this); }
/// return a string representation in decimal with maximum decimal precision allowed by the inherent accuracy of the number
LispString * String() override;
/// give access to the BigNumber object; if necessary, will create a BigNumber object out of the stored string, at given precision (in decimal?)
BigNumber* Number(int aPrecision) override;
private:
/// number object; nullptr if not yet converted from string
RefPtr<BigNumber> iNumber;
/// string representation in decimal; nullptr if not yet converted from BigNumber
RefPtr<LispString> iString;
};
#endif
================================================
FILE: cyacas/libyacas/include/yacas/lispenvironment.h
================================================
/** \file lispenvironment.h
* General environment access.
*
*/
#ifndef YACAS_LISPENVIRONMENT_H
#define YACAS_LISPENVIRONMENT_H
#include "lispobject.h"
#include "lisphash.h"
#include "lispevalhash.h"
#include "lispuserfunc.h"
#include "deffile.h"
#include "lisperror.h"
#include "lispio.h"
#include "stringio.h"
#include "lispglobals.h"
#include "lispoperator.h"
#include "xmltokenizer.h"
#include "errors.h"
#include "noncopyable.h"
#include <atomic>
#include <string>
#include <sstream>
#include <vector>
#include <deque>
#include <unordered_set>
typedef std::unordered_set<LispStringSmartPtr, std::hash<const LispString*> > LispIdentifiers;
class LispDefFiles;
class LispInput;
class LispOutput;
class LispPrinter;
class LispUserFunction;
class LispMultiUserFunction;
class LispEvaluatorBase;
class BasicEvaluator;
class DefaultDebugger;
class LispEnvironment;
/// The Lisp environment.
/// This huge class is the central class of the Yacas program. It
/// implements a dialect of Lisp.
class LispEnvironment: NonCopyable {
public:
/// \name Constructor and destructor
//@{
LispEnvironment(YacasCoreCommands &aCoreCommands,
LispUserFunctions& aUserFunctions,
LispGlobal& aGlobals,
LispHashTable& aHashTable,
std::ostream& aOutput,
LispPrinter& aPrinter,
LispOperators &aPreFixOperators,
LispOperators &aInFixOperators,
LispOperators &aPostFixOperators,
LispOperators &aBodiedOperators,
LispIdentifiers& protected_symbols,
LispInput* aCurrentInput);
~LispEnvironment();
//@}
public:
/// \name Lisp variables
//@{
/// Assign a value to a Lisp variable.
/// \param aString name of the variable
/// \param aValue value to be assigned to \a aString
///
/// If there is a local variable with the name \a aString, the
/// object \a aValue is assigned to it. Otherwise, a
/// LispGlobalVariable is constructed, and it is associated with
/// \a aValue in #iGlobals.
/// \sa FindLocal
void SetVariable(const LispString* aString, LispPtr& aValue, bool aGlobalLazyVariable);
/// Get the value assigned to a variable.
/// \param aVariable name of the variable
/// \param aResult (on exit) value of \a aVariable
///
/// - If there is a local variable with the name \a aString,
/// \a aResult is set to point to the value assigned to this local
/// variable.
/// - If there is a global variable \a aString and its
/// #iEvalBeforeReturn is false, its value is returned via
/// \a aResult.
/// - If there is a global variable \a aString and its
/// #iEvalBeforeReturn is true, its value is evaluated. The
/// result is assigned back to the variable, its
/// #iEvalBeforeReturn is set to false, and a copy of the result
/// is returned in \a aResult.
/// - Otherwise, \a aResult is set to #nullptr.
void GetVariable(const LispString* aVariable, LispPtr& aResult);
void UnsetVariable(const LispString * aString);
void PushLocalFrame(bool aFenced);
void PopLocalFrame();
void NewLocal(const LispString* aVariable, LispObject* aValue);
void CurrentLocals(LispPtr& aResult);
void GlobalVariables(LispPtr& aResult);
//@}
public:
/// \name Lisp functions
//@{
/// Return the #iCoreCommands attribute.
const YacasCoreCommands& CoreCommands() const;
const LispUserFunctions& UserFunctions() const;
/// Add a command to the list of core commands.
/// \param aEvaluatorFunc C function evaluating the core command
/// \param aString name of the command
/// \param aNrArgs number of arguments
/// \param aFlags flags, see YacasEvaluator::FunctionFlags
void SetCommand(YacasEvalCaller aEvaluatorFunc, const char* aString,int aNrArgs,int aFlags);
void RemoveCoreCommand(char* aString);
inline LispHashTable& HashTable();
LispUserFunction* UserFunction(LispPtr& aArguments);
LispUserFunction* UserFunction(const LispString* aName,int aArity);
/// Return LispMultiUserFunction with given name.
/// \param aArguments name of the multi user function
///
/// The table of user functions, #iUserFunctions, is consulted. If
/// a user function with the given name exists, it is returned.
/// Otherwise, a new LispMultiUserFunction is constructed, added
/// to #iUserFunctions, and returned.
LispMultiUserFunction* MultiUserFunction(const LispString* aArguments);
LispDefFiles& DefFiles();
void DeclareRuleBase(const LispString* aOperator, LispPtr& aParameters,
int aListed);
void DeclareMacroRuleBase(const LispString* aOperator, LispPtr& aParameters,
int aListed);
void DefineRule(const LispString* aOperator,int aArity,
int aPrecedence, LispPtr& aPredicate,
LispPtr& aBody);
void DefineRulePattern(const LispString* aOperator,int aArity,
int aPrecedence, LispPtr& aPredicate,
LispPtr& aBody);
void UnFenceRule(const LispString* aOperator,int aArity);
void Retract(const LispString* aOperator,int aArity);
void HoldArgument(const LispString* aOperator, const LispString* aVariable);
void Protect(const LispString*);
void UnProtect(const LispString*);
bool Protected(const LispString*) const;
//@}
public:
/// \name Precision
//@{
/// set precision to a given number of decimal digits
void SetPrecision(int aPrecision);
int Precision(void) const;
int BinaryPrecision(void) const;
//@}
public:
void SetPrettyPrinter(const LispString* aPrettyPrinter);
const LispString* PrettyPrinter();
void SetPrettyReader(const LispString* aPrettyReader);
const LispString* PrettyReader();
public:
int GetUniqueId();
public:
LispPrinter& CurrentPrinter();
public:
/// \name Operators
//@{
LispOperators& PreFix();
LispOperators& InFix();
LispOperators& PostFix();
LispOperators& Bodied();
//@}
public:
/// \name Input and output
//@{
LispInput* CurrentInput();
void SetCurrentInput(LispInput* aInput);
public:
std::ostream& CurrentOutput();
void SetCurrentOutput(std::ostream&);
//@}
protected:
/// current precision for user interaction, in decimal and in binary
int iPrecision;
int iBinaryPrecision;
public:
std::vector<std::string> iInputDirectories;
//DeletingLispCleanup iCleanup;
int iEvalDepth;
int iMaxEvalDepth;
#ifdef YACAS_NO_ATOMIC_TYPES
volatile bool
#else
std::atomic_bool
#endif // YACAS_NO_ATOMIC_TYPES
stop_evaluation;
LispEvaluatorBase* iEvaluator;
public: // Error information when some error occurs.
InputStatus iInputStatus;
bool secure;
public: // pre-found
RefPtr<LispObject> iTrue;
RefPtr<LispObject> iFalse;
RefPtr<LispObject> iEndOfFile;
RefPtr<LispObject> iEndStatement;
RefPtr<LispObject> iProgOpen;
RefPtr<LispObject> iProgClose;
RefPtr<LispObject> iNth;
RefPtr<LispObject> iBracketOpen;
RefPtr<LispObject> iBracketClose;
RefPtr<LispObject> iListOpen;
RefPtr<LispObject> iListClose;
RefPtr<LispObject> iComma;
RefPtr<LispObject> iList;
RefPtr<LispObject> iProg;
int iLastUniqueId;
public: // Error reporting
std::ostringstream iErrorOutput;
DefaultDebugger* iDebugger;
private:
LispPtr *FindLocal(const LispString * aVariable);
struct LispLocalVariable {
LispLocalVariable(const LispString* var, LispObject* val):
var(var), val(val)
{
}
LispStringSmartPtr var;
LispPtr val;
};
struct LocalVariableFrame {
LocalVariableFrame(std::size_t first, bool fenced):
first(first), fenced(fenced)
{
}
std::size_t first;
bool fenced;
};
std::vector<LispLocalVariable> _local_vars;
std::vector<LocalVariableFrame> _local_frames;
public:
std::ostream* iInitialOutput;
private:
/// Hash of core commands with associated YacasEvaluator
YacasCoreCommands& iCoreCommands;
LispUserFunctions& iUserFunctions;
LispHashTable& iHashTable;
LispDefFiles iDefFiles;
LispPrinter& iPrinter;
std::ostream* iCurrentOutput;
/// Hash of global variables with their values
LispGlobal& iGlobals;
LispOperators& iPreFixOperators;
LispOperators& iInFixOperators;
LispOperators& iPostFixOperators;
LispOperators& iBodiedOperators;
LispIdentifiers& protected_symbols;
LispInput* iCurrentInput;
const LispString* iPrettyReader;
const LispString* iPrettyPrinter;
public:
LispTokenizer iDefaultTokenizer;
XmlTokenizer iXmlTokenizer;
LispTokenizer* iCurrentTokenizer;
std::deque<LispPtr> iStack;
};
inline int LispEnvironment::Precision(void) const
{
return iPrecision;
}
inline int LispEnvironment::BinaryPrecision(void) const
{
return iBinaryPrecision;
}
inline const YacasCoreCommands& LispEnvironment::CoreCommands() const
{
return iCoreCommands;
}
inline const LispUserFunctions& LispEnvironment::UserFunctions() const
{
return iUserFunctions;
}
inline LispHashTable& LispEnvironment::HashTable()
{
return iHashTable;
}
// Local lisp stack, unwindable by the exception handler
class LispLocalFrame
{
public:
LispLocalFrame(LispEnvironment& aEnvironment, bool aFenced)
: iEnvironment(aEnvironment)
{
iEnvironment.PushLocalFrame(aFenced);
};
virtual ~LispLocalFrame()
{
iEnvironment.PopLocalFrame();
};
private:
LispEnvironment& iEnvironment;
};
class LispSecureFrame
{
public:
LispSecureFrame(LispEnvironment& aEnvironment):
iEnvironment(aEnvironment), previous_secure(aEnvironment.secure)
{
iEnvironment.secure = true;
};
virtual ~LispSecureFrame()
{
iEnvironment.secure = previous_secure;
};
private:
LispEnvironment& iEnvironment;
bool previous_secure;
};
// LispLocalInput takes ownership over the LispInput class
class LispLocalInput: NonCopyable
{
public:
LispLocalInput(LispEnvironment& aEnvironment, LispInput* aInput)
: iEnvironment(aEnvironment),iPreviousInput(iEnvironment.CurrentInput())
{
iEnvironment.SetCurrentInput(aInput);
};
virtual ~LispLocalInput()
{
iEnvironment.SetCurrentInput(iPreviousInput);
};
private:
LispEnvironment& iEnvironment;
LispInput* iPreviousInput;
};
// LispLocalInput takes ownership over the LispInput class
class LispLocalOutput: NonCopyable
{
public:
LispLocalOutput(LispEnvironment& aEnvironment, std::ostream& aOutput)
: iEnvironment(aEnvironment), iPreviousOutput(&iEnvironment.CurrentOutput())
{
iEnvironment.SetCurrentOutput(aOutput);
};
virtual ~LispLocalOutput()
{
iEnvironment.SetCurrentOutput(*iPreviousOutput);
};
private:
LispEnvironment& iEnvironment;
std::ostream* iPreviousOutput;
};
class LispLocalEvaluator: NonCopyable
{
public:
LispLocalEvaluator(LispEnvironment& aEnvironment,LispEvaluatorBase* aNewEvaluator);
~LispLocalEvaluator();
private:
LispEvaluatorBase* iPreviousEvaluator;
LispEnvironment& iEnvironment;
};
class LispLocalTrace: NonCopyable
{
public:
LispLocalTrace(LispUserFunction* aUserFunc);
~LispLocalTrace();
private:
LispUserFunction* iUserFunc;
};
inline void LispEnvironment::SetPrettyReader(const LispString* aPrettyReader)
{
iPrettyReader = aPrettyReader;
}
inline const LispString* LispEnvironment::PrettyReader()
{
return iPrettyReader;
}
inline void LispEnvironment::SetPrettyPrinter(const LispString * aPrettyPrinter)
{
iPrettyPrinter = aPrettyPrinter;
}
inline const LispString* LispEnvironment::PrettyPrinter()
{
return iPrettyPrinter;
}
#endif
================================================
FILE: cyacas/libyacas/include/yacas/lisperror.h
================================================
#ifndef YACAS_LISPERROR_H
#define YACAS_LISPERROR_H
#include <string>
class LispError {
public:
LispError(const std::string& msg);
const char* what() const;
private:
const std::string _what;
};
inline
LispError::LispError(const std::string& what):
_what(what)
{
}
inline
const char* LispError::what() const
{
return _what.c_str();
}
class LispErrInvalidArg: public LispError {
public:
LispErrInvalidArg():
LispError("Invalid argument") {}
};
class LispErrWrongNumberOfArgs: public LispError {
public:
LispErrWrongNumberOfArgs():
LispError("Wrong number of arguments") {}
};
class LispErrNotList: public LispError {
public:
LispErrNotList():
LispError("Argument is not a list") {}
};
class LispErrListNotLongEnough: public LispError {
public:
LispErrListNotLongEnough():
LispError("List not long enough") {}
};
class LispErrInvalidStack: public LispError {
public:
LispErrInvalidStack():
LispError("Invalid stack") {}
};
class Quitting: public LispError {
public:
Quitting():
LispError("Quitting...") {}
};
class LispErrNotEnoughMemory: public LispError {
public:
LispErrNotEnoughMemory():
LispError("Not enough memory") {}
};
class InvalidToken: public LispError {
public:
InvalidToken():
LispError("Empty token during parsing") {}
};
class LispErrInvalidExpression: public LispError {
public:
LispErrInvalidExpression():
LispError("Error parsing expression") {}
explicit LispErrInvalidExpression(const std::string& ctx):
LispError("Error parsing expression near token " + ctx) {}
};
class LispErrUnprintableToken: public LispError {
public:
LispErrUnprintableToken():
LispError("Unprintable atom") {}
};
class LispErrFileNotFound: public LispError {
public:
LispErrFileNotFound():
LispError("File not found") {}
};
class LispErrReadingFile: public LispError {
public:
LispErrReadingFile():
LispError("Error reading file") {}
};
class LispErrCreatingUserFunction: public LispError {
public:
LispErrCreatingUserFunction():
LispError("Could not create user function") {}
};
class LispErrCreatingRule: public LispError {
public:
LispErrCreatingRule():
LispError("Could not create rule") {}
};
class LispErrArityAlreadyDefined: public LispError {
public:
LispErrArityAlreadyDefined():
LispError("Rule base with this arity already defined") {}
};
class LispErrCommentToEndOfFile: public LispError {
public:
LispErrCommentToEndOfFile():
LispError("Reaching end of file within a comment block") {}
};
class LispErrNotString: public LispError {
public:
LispErrNotString():
LispError("Argument is not a string") {}
};
class LispErrNotInteger: public LispError {
public:
LispErrNotInteger():
LispError("Argument is not an integer") {}
};
class LispErrParsingInput: public LispError {
public:
LispErrParsingInput():
LispError("Error while parsing input") {}
};
class LispErrMaxRecurseDepthReached: public LispError {
public:
LispErrMaxRecurseDepthReached():
LispError("Max evaluation stack depth reached.\nPlease use MaxEvalDepth to increase the stack size as needed.") {}
};
class LispErrDefFileAlreadyChosen: public LispError {
public:
LispErrDefFileAlreadyChosen():
LispError("DefFile already chosen for function") {}
};
class LispErrDivideByZero: public LispError {
public:
LispErrDivideByZero():
LispError("Divide by zero") {}
};
class LispErrNotAnInFixOperator: public LispError {
public:
LispErrNotAnInFixOperator():
LispError("Trying to make a non-infix operator right-associative") {}
};
class LispErrUser: public LispError {
public:
LispErrUser(const std::string& msg):
LispError(msg) {}
};
class LispErrIsNotInFix: public LispError {
public:
LispErrIsNotInFix():
LispError("Trying to get precedence of non-infix operator") {}
};
class LispErrSecurityBreach: public LispError {
public:
LispErrSecurityBreach():
LispError("Trying to perform an insecure action") {}
};
class LispErrLibraryNotFound: public LispError {
public:
LispErrLibraryNotFound():
LispError("Could not find library") {}
};
class LispErrUserInterrupt: public LispError {
public:
LispErrUserInterrupt():
LispError("User interrupted calculation") {}
};
class LispErrNonBooleanPredicateInPattern: public LispError {
public:
LispErrNonBooleanPredicateInPattern():
LispError("Predicate doesn't evaluate to a boolean in pattern") {}
};
class LispErrProtectedSymbol: public LispError {
public:
explicit LispErrProtectedSymbol(const std::string& s):
LispError(std::string("Attempt to override protected symbol: ") + s) {}
};
class LispErrGeneric: public LispError {
public:
LispErrGeneric(const std::string& what):
LispError(what) {}
};
class LispEnvironment;
class LispOutput;
void HandleError(const LispError&, LispEnvironment& aEnvironment, std::ostream& aOutput);
#endif
================================================
FILE: cyacas/libyacas/include/yacas/lispeval.h
================================================
/** \file lispeval.h
* Evaluation of expressions.
*
*/
#ifndef YACAS_LISPEVAL_H
#define YACAS_LISPEVAL_H
#include "lispobject.h"
#include "lispenvironment.h"
class UserStackInformation {
public:
UserStackInformation()
: iOperator(),iExpression(),iRulePrecedence(-1),iSide(0)
{
}
LispPtr iOperator;
LispPtr iExpression;
int iRulePrecedence;
int iSide; // 0=pattern, 1=body
};
/// Abstract evaluator for Lisp expressions.
/// Eval() is a pure virtual function, to be provided by the derived class.
/// The other functions are stubs.
class LispEvaluatorBase {
public:
LispEvaluatorBase() : iBasicInfo() {}
virtual ~LispEvaluatorBase() = default;
virtual void Eval(LispEnvironment& aEnvironment, LispPtr& aResult, LispPtr& aExpression)=0;
virtual void ResetStack();
virtual UserStackInformation& StackInformation();
virtual void ShowStack(LispEnvironment& aEnvironment, std::ostream& aOutput);
private:
UserStackInformation iBasicInfo;
};
/// The basic evaluator for Lisp expressions.
class BasicEvaluator : public LispEvaluatorBase
{
public:
/// Evaluate a Lisp expression
/// \param aEnvironment the Lisp environment, in which the
/// evaluation should take place.
/// \param aResult the result of the evaluation.
/// \param aExpression the expression to evaluate.
///
/// First, the evaluation depth is checked. An error is raised if
/// the maximum evaluation depth is exceeded.
///
/// The next step is the actual evaluation. \a aExpression is a
/// LispObject, so we can distinguish three cases.
/// - If \a aExpression is a string starting with \c " , it is
/// simply copied in \a aResult. If it starts with another
/// character (this includes the case where it represents a
/// number), the environment is checked to see whether a
/// variable with this name exists. If it does, its value is
/// copied in \a aResult, otherwise \a aExpression is copied.
/// - If \a aExpression is a list, the head of the list is
/// examined. If the head is not a string. InternalApplyPure()
/// is called. If the head is a string, it is checked against
/// the core commands; if there is a check, the corresponding
/// evaluator is called. Then it is checked agaist the list of
/// user function with GetUserFunction() . Again, the
/// corresponding evaluator is called if there is a check. If
/// all fails, ReturnUnEvaluated() is called.
/// - Otherwise (ie. if \a aExpression is a generic object), it is
/// copied in \a aResult.
///
/// \note The result of this operation must be a unique (copied)
/// element! Eg. its Next might be set...
///
/// The LispPtr it can be stored in to is passed in as argument, so it
/// does not need to be constructed by the calling environment.
void Eval(LispEnvironment& aEnvironment, LispPtr& aResult, LispPtr& aExpression) override;
};
class TracedEvaluator : public BasicEvaluator
{
public:
void Eval(LispEnvironment& aEnvironment, LispPtr& aResult, LispPtr& aExpression) override;
protected:
std::ostringstream errorOutput;
};
class TracedStackEvaluator final: public BasicEvaluator
{
public:
TracedStackEvaluator() : objs() {}
~TracedStackEvaluator() override;
void Eval(LispEnvironment& aEnvironment, LispPtr& aResult, LispPtr& aExpression) override;
void ResetStack() override;
UserStackInformation& StackInformation() override;
void ShowStack(LispEnvironment& aEnvironment, std::ostream& aOutput) override;
private:
void PushFrame();
void PopFrame();
private:
std::vector<UserStackInformation*> objs;
};
/* GetUserFunction : get user function, possibly loading the required
files to read in the function definition */
LispUserFunction* GetUserFunction(LispEnvironment& aEnvironment,
LispPtr* subList);
/* Tracing functions */
void TraceShowEnter(LispEnvironment& aEnvironment,
LispPtr& aExpression);
void TraceShowLeave(LispEnvironment& aEnvironment, LispPtr& aResult,
LispPtr& aExpression);
void TraceShowArg(LispEnvironment& aEnvironment,LispPtr& aParam,
LispPtr& aValue);
void ShowExpression(LispString& outString, LispEnvironment& aEnvironment,
LispPtr& aExpression);
class YacasDebuggerBase {
public:
virtual ~YacasDebuggerBase() = default;
virtual void Start() = 0;
virtual void Finish() = 0;
virtual void Enter(LispEnvironment& aEnvironment,
LispPtr& aExpression) = 0;
virtual void Leave(LispEnvironment& aEnvironment, LispPtr& aResult,
LispPtr& aExpression) = 0;
virtual void Error(LispEnvironment& aEnvironment) = 0;
virtual bool Stopped() = 0;
};
class DefaultDebugger final: public YacasDebuggerBase
{
public:
DefaultDebugger(LispPtr& aEnter, LispPtr& aLeave, LispPtr& aError)
: iEnter(aEnter), iLeave(aLeave), iError(aError), iTopExpr(),iTopResult(),iStopped(false),defaultEval() {};
void Start() override;
void Finish() override;
void Enter(LispEnvironment& aEnvironment, LispPtr& aExpression) override;
void Leave(LispEnvironment& aEnvironment, LispPtr& aResult, LispPtr& aExpression) override;
void Error(LispEnvironment& aEnvironment) override;
bool Stopped() override;
LispPtr iEnter;
LispPtr iLeave;
LispPtr iError;
LispPtr iTopExpr;
LispPtr iTopResult;
bool iStopped;
protected:
BasicEvaluator defaultEval;
};
#endif
================================================
FILE: cyacas/libyacas/include/yacas/lispevalhash.h
================================================
/** \file lispevalhash.h
* Storage of executable commands
*
*/
#ifndef YACAS_LISPEVALHASH_H
#define YACAS_LISPEVALHASH_H
#include "lispobject.h"
#include "evalfunc.h"
#include <unordered_map>
// new-style evaluator, passing arguments onto the stack in LispEnvironment
typedef void (*YacasEvalCaller)(LispEnvironment& aEnvironment,int aStackTop);
class YacasEvaluator: public EvalFuncBase
{
public:
// FunctionFlags can be orred when passed to the constructor of this function
enum FunctionFlags
{
Function=0, // Function: evaluate arguments
Macro=1, // Function: don't evaluate arguments
Fixed = 0, // fixed number of arguments
Variable = 2 // variable number of arguments
};
YacasEvaluator(YacasEvalCaller aCaller,int aNrArgs, int aFlags)
: iCaller(aCaller), iNrArgs(aNrArgs), iFlags(aFlags)
{
}
void Evaluate(LispPtr& aResult,
LispEnvironment& aEnvironment,
LispPtr& aArguments) const override;
private:
YacasEvalCaller iCaller;
int iNrArgs;
int iFlags;
};
typedef std::unordered_map<LispStringSmartPtr, YacasEvaluator, std::hash<const LispString*> > YacasCoreCommands;
#endif
================================================
FILE: cyacas/libyacas/include/yacas/lispglobals.h
================================================
/** \file lispglobals.h
* Storage of globals in a associated hash
*
*/
#ifndef YACAS_LISPGLOBALS_H
#define YACAS_LISPGLOBALS_H
#include "lispobject.h"
#include "lisphash.h"
/// Value of a Lisp global variable.
/// The only special feature of this class is the attribute
/// #iEvalBeforeReturn, which defaults to #false. If this
/// attribute is set to #true, the value in #iValue needs to be
/// evaluated to get the value of the Lisp variable.
/// \sa LispEnvironment::GetVariable()
class LispGlobalVariable {
public:
LispGlobalVariable(const LispGlobalVariable& aOther);
LispGlobalVariable(LispPtr& aValue): iValue(aValue), iEvalBeforeReturn(false) {}
LispGlobalVariable& operator=(const LispGlobalVariable& aOther);
void SetEvalBeforeReturn(bool aEval);
LispPtr iValue;
bool iEvalBeforeReturn;
};
typedef std::unordered_map<LispStringSmartPtr, LispGlobalVariable, std::hash<const LispString*> > LispGlobal;
inline
LispGlobalVariable::LispGlobalVariable(const LispGlobalVariable& aOther):
iValue(aOther.iValue),
iEvalBeforeReturn(false)
{
}
inline
void LispGlobalVariable::SetEvalBeforeReturn(bool aEval)
{
iEvalBeforeReturn = aEval;
}
inline
LispGlobalVariable& LispGlobalVariable::operator=(const LispGlobalVariable& aOther)
{
iValue = aOther.iValue;
return *this;
}
#endif
================================================
FILE: cyacas/libyacas/include/yacas/lisphash.h
================================================
/** \file lisphash.h
* hashing of strings. Each string will exist only once in the
* hash table, and have an unique id.
*/
#ifndef YACAS_LISPHASH_H
#define YACAS_LISPHASH_H
#include "lispstring.h"
#include <unordered_map>
/**
* This is the symbol table, implemented as a hash table for fast
* lookup. It is meant to store any string just once, have fast
* searching for strings and return a reference to the string.
* This also allows fast comparison of two strings (two strings
* are equal iff the pointers to the strings are equal).
*/
class LispHashTable {
public:
// If string not yet in table, insert. Afterwards return the string.
const LispString* LookUp(const std::string&);
void GarbageCollect();
private:
std::unordered_map<std::string, LispStringSmartPtr> _rep;
};
#endif
================================================
FILE: cyacas/libyacas/include/yacas/lispio.h
================================================
/** \file lispio.h
* definitions of pure input output classes.
*/
#ifndef YACAS_LISPIO_H
#define YACAS_LISPIO_H
#include <cstddef>
#include <string>
class InputStatus
{
public:
InputStatus() : iFileName("none") , iLineNumber(-1) {}
void SetTo(const std::string& aFileName);
void RestoreFrom(InputStatus& aPreviousStatus);
int LineNumber() const;
const std::string& FileName() const;
void NextLine();
private:
std::string iFileName;
int iLineNumber;
};
inline
int InputStatus::LineNumber() const
{
return iLineNumber;
}
inline
const std::string& InputStatus::FileName() const
{
return iFileName;
}
inline
void InputStatus::NextLine()
{
iLineNumber++;
}
/** \class LispInput : pure abstract class declaring the interface
* that needs to be implemented by a file (something that expressions
* can be read from).
*/
class LispInput
{
public:
/** Constructor with InputStatus. InputStatus retains the information
* needed when an error occurred, and the file has already been
* closed.
*/
LispInput(InputStatus& aStatus) : iStatus(aStatus) {};
virtual ~LispInput() = default;
/// Return the next character in the file
virtual char32_t Next() = 0;
/** Peek at the next character in the file, without advancing the file
* pointer.
*/
virtual char32_t Peek() = 0;
virtual const InputStatus& Status() const {return iStatus;};
/// Check if the file position is past the end of the file.
virtual bool EndOfStream() const = 0;
virtual std::size_t Position() const = 0;
virtual void SetPosition(std::size_t aPosition) = 0;
protected:
InputStatus& iStatus;
};
#endif
================================================
FILE: cyacas/libyacas/include/yacas/lispobject.h
================================================
/** \file lispobject.h
* Implementation of basic LispObject, which is the base class for
* anything that can be put in a linked list.
*
* class LispObject. This class implements one lisp object, which is a
* abstract class containing reference counting and a next pointer.
* derive from this to implement specific types of list elements.
* The local class LispPtr implements automatic garbage collection
* through reference counting.
*
*/
#ifndef YACAS_LISPOBJECT_H
#define YACAS_LISPOBJECT_H
#include "refcount.h"
#include "lispstring.h"
#include "genericobject.h"
#include "noncopyable.h"
class LispObject;
class BigNumber;
/** class LispPtr. A LispPtr is a smart pointer to a LispObject.
* It does the reference counting, and consequent destruction if needed.
* LispPtr is used in LispObject as a pointer to the next object; and
* LispPtr::GoNext() advances one step in this LispObject::Nixed() chain.
* Diverse built-in functions use LispPtr to hold temporary values.
*/
typedef RefPtr<LispObject> LispPtr;
/** class LispObject is the base object class that can be put in
* linked lists. It either has a pointer to a string, obtained through
* String(), or it is a holder for a sublist, obtainable through SubList(),
* or it is a generic object, in which case Generic() returns non-nullptr.
* Only one of these three functions should return a non-nullptr value.
* It is a reference-counted object. LispPtr handles the reference counting.
*/
class LispObject: public RefCount
{
public:
inline LispPtr& Nixed();
public: //Derivables
virtual ~LispObject() = default;
/** Return string representation, or nullptr if the object doesn't have one.
* the string representation is only relevant if the object is a
* simple atom. This method returns nullptr by default.
*/
virtual const LispString* String() { return nullptr; }
/** If this object is a list, return a pointer to it.
* Default behaviour is to return nullptr.
*/
virtual LispPtr* SubList() { return nullptr; }
virtual GenericClass* Generic() { return nullptr; }
/** If this is a number, return a BigNumber representation
*/
virtual BigNumber* Number([[maybe_unused]] int aPrecision) { return nullptr; }
virtual LispObject* Copy() const = 0;
public:
int Equal(LispObject& aOther);
inline int operator==(LispObject& aOther);
inline int operator!=(LispObject& aOther);
protected:
inline LispObject() :
iNext()
{
}
inline LispObject([[maybe_unused]] const LispObject& other) :
RefCount(),
iNext()
{
}
inline LispObject& operator=([[maybe_unused]] const LispObject& other)
{
return *this;
}
private:
LispPtr iNext;
};
/**
* class LispIterator works almost like LispPtr, but doesn't enforce
* reference counting, so it should be faster. Use LispIterator
* (instead of LispPtr) to traverse a lisp expression non-destructively.
*/
class LispIterator {
public:
// ala TEMPLATE CLASS iterator
//typedef forward_iterator_tag iterator_category;
typedef LispPtr value_type;
typedef int /*ptrdiff_t*/ difference_type;
typedef LispPtr* pointer;
typedef LispPtr& reference;
public:
LispIterator() : _Ptr(0) {} // construct with null node pointer
LispIterator(pointer ptr) : _Ptr(ptr) {} // construct with node pointer
/*non-standard*/ LispIterator(reference ref) : _Ptr(&ref) {} // construct with node reference
reference operator*() const { return (*(_Ptr)); } // return designated value
pointer operator->() const { return (_Ptr); } // return pointer to class object
inline LispIterator& operator++() // preincrement
{
//precondition: _Ptr != nullptr
assert(_Ptr != nullptr);
//expand: _Ptr = _Nextnode(_Ptr);
LispObject * pObj = _Ptr->operator->();
_Ptr = pObj ? &(pObj->Nixed()) : nullptr;
return (*this);
}
LispIterator operator++(int) { LispIterator _Tmp = *this; ++*this; return (_Tmp); } // postincrement
bool operator==(const LispIterator& other) const { return (_Ptr == other._Ptr); } // test for iterator equality
bool operator!=(const LispIterator& other) const { return (!(*this == other)); } // test for iterator inequality
// The following operators are not used yet, and would need to be tested before used.
//LispIterator& operator--() { _Ptr = _Prevnode(_Ptr); return (*this); } // predecrement
//LispIterator operator--(int) { LispIterator _Tmp = *this; --*this; return (_Tmp); } // postdecrement
protected:
pointer _Ptr; // pointer to node
public:
inline LispObject* getObj() const { return (*_Ptr).operator->(); }
};
class LispConstIterator {
public:
// ala TEMPLATE CLASS iterator
//typedef forward_iterator_tag iterator_category;
typedef const LispPtr value_type;
typedef int /*ptrdiff_t*/ difference_type;
typedef const LispPtr* pointer;
typedef const LispPtr& reference;
public:
LispConstIterator() : _Ptr(0) {} // construct with null node pointer
LispConstIterator(pointer ptr) : _Ptr(ptr) {} // construct with node pointer
/*non-standard*/ LispConstIterator(reference ref) : _Ptr(&ref) {} // construct with node reference
reference operator*() const { return (*(_Ptr)); } // return designated value
pointer operator->() const { return (_Ptr); } // return pointer to class object
inline LispConstIterator& operator++() // preincrement
{
//precondition: _Ptr != nullptr
assert(_Ptr != nullptr);
//expand: _Ptr = _Nextnode(_Ptr);
LispObject * pObj = _Ptr->operator->();
_Ptr = pObj ? &(pObj->Nixed()) : nullptr;
return (*this);
}
LispConstIterator operator++(int) { LispConstIterator _Tmp = *this; ++*this; return (_Tmp); } // postincrement
bool operator==(const LispConstIterator& other) const { return (_Ptr == other._Ptr); } // test for iterator equality
bool operator!=(const LispConstIterator& other) const { return (!(*this == other)); } // test for iterator inequality
// The following operators are not used yet, and would need to be tested before used.
//LispConstIterator& operator--() { _Ptr = _Prevnode(_Ptr); return (*this); } // predecrement
//LispConstIterator operator--(int) { LispConstIterator _Tmp = *this; --*this; return (_Tmp); } // postdecrement
protected:
pointer _Ptr; // pointer to node
public:
inline const LispObject* getObj() const { return (*_Ptr).operator->(); }
};
inline LispPtr& LispObject::Nixed()
{
return iNext;
}
inline int LispObject::operator==(LispObject& aOther)
{
return Equal(aOther);
}
inline int LispObject::operator!=(LispObject& aOther)
{
return !Equal(aOther);
}
#endif
================================================
FILE: cyacas/libyacas/include/yacas/lispoperator.h
================================================
/*
* This file is part of yacas.
* Yacas is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesset General Public License as
* published by the Free Software Foundation, either version 2.1
* of the License, or (at your option) any later version.
*
* Yacas is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with yacas. If not, see <http://www.gnu.org/licenses/>.
*
*/
/*
* File: lispoperator.h
* Author: mazur
*
* Created on February 12, 2016, 3:05 PM
*/
#ifndef LISPOPERATOR_H
#define LISPOPERATOR_H
#include <unordered_map>
#ifdef YACAS_NO_CONSTEXPR
const int KMaxPrecedence = 60000;
#else
constexpr int KMaxPrecedence = 60000;
#endif
class LispInFixOperator {
public:
explicit
#ifndef YACAS_NO_CONSTEXPR
constexpr
#endif
LispInFixOperator(int aPrecedence = KMaxPrecedence):
iPrecedence(aPrecedence),
iLeftPrecedence(aPrecedence),
iRightPrecedence(aPrecedence),
iRightAssociative(false)
{}
void SetRightAssociative()
{
iRightAssociative = true;
}
void SetLeftPrecedence(int aPrecedence)
{
iLeftPrecedence = aPrecedence;
}
void SetRightPrecedence(int aPrecedence)
{
iRightPrecedence = aPrecedence;
}
int iPrecedence;
int iLeftPrecedence;
int iRightPrecedence;
bool iRightAssociative;
};
typedef std::unordered_map<const LispStringSmartPtr, LispInFixOperator, std::hash<const LispString*> > LispOperators;
#endif
================================================
FILE: cyacas/libyacas/include/yacas/lispparser.h
================================================
/** \file lispparser.h
* parsing and printing in the old-fashioned lisp style
*
*/
#ifndef YACAS_LISPPARSER_H
#define YACAS_LISPPARSER_H
#include "lispobject.h"
#include "tokenizer.h"
#include "lispio.h"
#include "evalfunc.h"
#include <ostream>
class LispParser {
public:
LispParser(LispTokenizer& aTokenizer, LispInput& aInput,
LispEnvironment& aEnvironment);
virtual void Parse(LispPtr& aResult );
protected:
void ParseList(LispPtr& aResult);
void ParseAtom(LispPtr& aResult, const LispString* aToken);
public:
LispTokenizer& iTokenizer;
LispInput& iInput;
LispEnvironment& iEnvironment;
int iListed;
};
class LispPrinter {
public:
virtual void Print(
const LispPtr& aExpression,
std::ostream& aOutput,
LispEnvironment& aEnvironment);
virtual void RememberLastChar(char aChar);
private:
void PrintExpression(
const LispPtr& aExpression,
std::ostream& aOutput,
LispEnvironment& aEnvironment,
int aDepth=0);
void Indent(std::ostream& aOutput, int aDepth);
};
#endif
================================================
FILE: cyacas/libyacas/include/yacas/lispstring.h
================================================
/** \file lispstring.h
* Defining a string class.
*/
#ifndef YACAS_LISPSTRING_H
#define YACAS_LISPSTRING_H
#include "refcount.h"
#include <string>
/** \class LispString : zero-terminated byte-counted string.
* Also keeps a reference count for any one interested.
*/
class LispString: public RefCount, public std::string
{
public:
explicit LispString(const std::string& = "");
};
inline LispString::LispString(const std::string& s):
std::string(s)
{
}
typedef RefPtr<const LispString> LispStringSmartPtr;
#endif
================================================
FILE: cyacas/libyacas/include/yacas/lispuserfunc.h
================================================
#ifndef YACAS_LISPUSERFUNC_H
#define YACAS_LISPUSERFUNC_H
#include "lispobject.h"
#include "evalfunc.h"
#include <vector>
#include <unordered_map>
class LispEnvironment;
/// Abstract class providing the basic user function API.
/// Instances of this class are associated to the name of the function
/// via an associated hash table. When obtained, they can be used to
/// evaluate the function with some arguments.
class LispUserFunction : public EvalFuncBase
{
public:
LispUserFunction() : iFenced(true),iTraced(false) {};
virtual void HoldArgument(const LispString* aVariable) = 0;
virtual void DeclareRule(int aPrecedence, LispPtr& aPredicate,
LispPtr& aBody) = 0;
virtual void DeclareRule(int aPrecedence, LispPtr& aBody) = 0;
virtual void DeclarePattern(int aPrecedence, LispPtr& aPredicate,
LispPtr& aBody) = 0;
virtual const LispPtr& ArgList() const = 0;
public: //unfencing
inline void UnFence() {iFenced = false;};
inline bool Fenced() const {return iFenced;};
public: //tracing
inline void Trace() {iTraced = true;};
inline void UnTrace() {iTraced = false;};
inline bool Traced() const {return iTraced;};
private:
bool iFenced;
bool iTraced;
};
/// User function with a specific arity.
/// This is still an abstract class, but the arity (number of
/// arguments) of the function is now fixed.
class LispArityUserFunction : public LispUserFunction
{
public:
virtual unsigned Arity() const = 0;
virtual bool IsArity(unsigned aArity) const = 0;
};
class LispDefFile;
/// Set of LispArityUserFunction's.
/// By using this class, you can associate multiple functions (with
/// different arities) to one name. A specific LispArityUserFunction
/// can be selected by providing its name. Additionally, the name of
/// the file in which the function is defined, can be specified.
class LispMultiUserFunction final {
public:
/// Constructor.
LispMultiUserFunction() : iFunctions(),iFileToOpen(nullptr) {};
/** When adding a multi-user function to the association hash table, the copy constructor is used.
* We should at least make sure that iFunctions is empty, so there is no copying needed (for efficiency).
* Casually having a copy-constructor on CDeletingArrayGrower should be avoided, to make sure it is
* not used accidentally.
*/
inline LispMultiUserFunction([[maybe_unused]] const LispMultiUserFunction& aOther) : iFunctions(), iFileToOpen(nullptr)
{
assert(aOther.iFileToOpen == 0);
assert(aOther.iFunctions.size() == 0);
}
inline LispMultiUserFunction& operator=([[maybe_unused]] const LispMultiUserFunction& aOther)
{
// copy constructor not written yet, hence the assert
assert(aOther.iFileToOpen == 0);
assert(aOther.iFunctions.size() == 0);
assert(iFileToOpen == 0);
assert(iFunctions.size() == 0);
return *this;
}
/// Return user function with given arity.
LispUserFunction* UserFunc(int aArity);
/// Destructor.
virtual ~LispMultiUserFunction();
/// Specify that some argument should be held.
virtual void HoldArgument(const LispString* aVariable);
/// Add another LispArityUserFunction to #iFunctions.
virtual void DefineRuleBase(LispArityUserFunction* aNewFunction);
/// Delete tuser function with given arity.
virtual void DeleteBase(int aArity);
private:
/// Set of LispArityUserFunction's provided by this LispMultiUserFunction.
std::vector<LispArityUserFunction*> iFunctions;
public:
/// File to read for the definition of this function.
LispDefFile* iFileToOpen;
};
/// Associated hash of LispMultiUserFunction objects.
typedef std::unordered_map<LispStringSmartPtr, LispMultiUserFunction, std::hash<const LispString*> > LispUserFunctions;
#endif
================================================
FILE: cyacas/libyacas/include/yacas/mathcommands.h
================================================
#ifndef YACAS_MATHCOMMANDS_H
#define YACAS_MATHCOMMANDS_H
#include "lispenvironment.h"
#include "lispevalhash.h"
#include "lispobject.h"
#include "lispglobals.h"
//#define CORE_FUNCTION(NAME) void NAME(LispEnvironment& aEnvironment, LispPtr& aResult, LispPtr& aArguments);
#define CORE_KERNEL_FUNCTION(iname,fname,nrargs,flags) void fname(LispEnvironment& aEnvironment, int aStackTop);
#define CORE_KERNEL_FUNCTION_ALIAS(iname,fname,nrargs,flags) int JimDummyFunction();
#define OPERATOR(kind, prec, yacas_name) int JimDummyFunction();
#include "corefunctions.h"
#undef CORE_KERNEL_FUNCTION
#undef CORE_KERNEL_FUNCTION_ALIAS
#undef OPERATOR
#endif
================================================
FILE: cyacas/libyacas/include/yacas/mathuserfunc.h
================================================
#ifndef YACAS_MATHUSERFUNC_H
#define YACAS_MATHUSERFUNC_H
#include "lispuserfunc.h"
#include "patternclass.h"
#include "noncopyable.h"
#include <vector>
/// A mathematical function defined by several rules.
/// This is the basic class which implements functions in Yacas.
/// Evaluation is done by consulting a set of rewriting rules. The
/// body of the first rule that matches, is evaluated and this gives
/// the result of evaluating the function.
class BranchingUserFunction : public LispArityUserFunction
{
public:
/// Structure containing name of parameter and whether it is put on hold.
class BranchParameter {
public:
BranchParameter(const LispString* aParameter = nullptr, int aHold=false)
: iParameter(aParameter), iHold(aHold) {}
const LispString* iParameter;
int iHold;
};
/// Abstract base class for rules.
class BranchRuleBase {
public:
virtual ~BranchRuleBase() = default;
virtual bool Matches(LispEnvironment& aEnvironment, LispPtr* aArguments) = 0;
virtual int Precedence() const = 0;
virtual LispPtr& Body() = 0;
};
/// A rule with a predicate.
/// This rule matches if the predicate evaluates to #true.
class BranchRule : public BranchRuleBase
{
public:
BranchRule(int aPrecedence,LispPtr& aPredicate,LispPtr& aBody) : iPrecedence(aPrecedence),iBody(aBody),iPredicate(aPredicate)
{
}
/// Return true if the rule matches.
/// #iPredicate is evaluated in \a Environment. If the result
/// IsTrue(), this function returns true.
bool Matches(LispEnvironment& aEnvironment, LispPtr* aArguments);
/// Access #iPrecedence.
int Precedence() const;
/// Access #iBody.
LispPtr& Body();
protected:
BranchRule() : iPrecedence(0),iBody(),iPredicate() {};
protected:
int iPrecedence;
LispPtr iBody;
LispPtr iPredicate;
};
/// A rule that always matches.
class BranchRuleTruePredicate : public BranchRule
{
public:
BranchRuleTruePredicate(int aPrecedence,LispPtr& aBody)
{
iPrecedence = aPrecedence;
iBody = (aBody);
}
/// Return #true, always.
bool Matches(LispEnvironment& aEnvironment, LispPtr* aArguments);
};
/// A rule which matches if the corresponding PatternClass matches.
class BranchPattern : public BranchRuleBase, NonCopyable
{
public:
/// Constructor.
/// \param aPrecedence precedence of the rule
/// \param aPredicate generic object of type \c Pattern
/// \param aBody body of the rule
BranchPattern(int aPrecedence,LispPtr& aPredicate,LispPtr& aBody) : iPrecedence(aPrecedence),iBody(aBody),iPredicate(aPredicate),iPatternClass(nullptr)
{
GenericCl
gitextract_ep2z9l5r/ ├── .clang-format ├── .gitignore ├── .vscode/ │ ├── launch.json │ └── settings.json ├── AUTHORS ├── CMakeLists.txt ├── CODE_OF_CONDUCT.md ├── COPYING ├── ChangeLog ├── README.rst ├── TODO ├── appveyor.yml ├── build.xml ├── cyacas/ │ ├── CMakeLists.txt │ ├── libyacas/ │ │ ├── CMakeLists.txt │ │ ├── config/ │ │ │ └── yacas/ │ │ │ └── yacas_version.h.in │ │ ├── include/ │ │ │ └── yacas/ │ │ │ ├── GPL_stuff.h │ │ │ ├── anumber.h │ │ │ ├── anumber.inl │ │ │ ├── arggetter.h │ │ │ ├── arrayclass.h │ │ │ ├── associationclass.h │ │ │ ├── corefunctions.h │ │ │ ├── deffile.h │ │ │ ├── errors.h │ │ │ ├── evalfunc.h │ │ │ ├── genericobject.h │ │ │ ├── infixparser.h │ │ │ ├── lispatom.h │ │ │ ├── lispenvironment.h │ │ │ ├── lisperror.h │ │ │ ├── lispeval.h │ │ │ ├── lispevalhash.h │ │ │ ├── lispglobals.h │ │ │ ├── lisphash.h │ │ │ ├── lispio.h │ │ │ ├── lispobject.h │ │ │ ├── lispoperator.h │ │ │ ├── lispparser.h │ │ │ ├── lispstring.h │ │ │ ├── lispuserfunc.h │ │ │ ├── mathcommands.h │ │ │ ├── mathuserfunc.h │ │ │ ├── mempool.h │ │ │ ├── noncopyable.h │ │ │ ├── numbers.h │ │ │ ├── patcher.h │ │ │ ├── patternclass.h │ │ │ ├── patterns.h │ │ │ ├── platfileio.h │ │ │ ├── platmath.h │ │ │ ├── refcount.h │ │ │ ├── standard.h │ │ │ ├── standard.inl │ │ │ ├── string_utils.h │ │ │ ├── stringio.h │ │ │ ├── substitute.h │ │ │ ├── tokenizer.h │ │ │ ├── utf8/ │ │ │ │ ├── checked.h │ │ │ │ ├── core.h │ │ │ │ ├── cpp11.h │ │ │ │ ├── cpp17.h │ │ │ │ ├── cpp20.h │ │ │ │ └── unchecked.h │ │ │ ├── utf8.h │ │ │ ├── xmltokenizer.h │ │ │ └── yacas.h │ │ └── src/ │ │ ├── anumber.cpp │ │ ├── arggetter.cpp │ │ ├── associationclass.cpp │ │ ├── deffile.cpp │ │ ├── errors.cpp │ │ ├── infixparser.cpp │ │ ├── lispatom.cpp │ │ ├── lispenvironment.cpp │ │ ├── lisperror.cpp │ │ ├── lispeval.cpp │ │ ├── lispevalhash.cpp │ │ ├── lisphash.cpp │ │ ├── lispio.cpp │ │ ├── lispobject.cpp │ │ ├── lispparser.cpp │ │ ├── lispuserfunc.cpp │ │ ├── mathcommands.cpp │ │ ├── mathcommands2.cpp │ │ ├── mathcommands3.cpp │ │ ├── mathuserfunc.cpp │ │ ├── mempool.cpp │ │ ├── numbers.cpp │ │ ├── patcher.cpp │ │ ├── patternclass.cpp │ │ ├── patterns.cpp │ │ ├── platmath.cpp │ │ ├── standard.cpp │ │ ├── stdfileio.cpp │ │ ├── stringio.cpp │ │ ├── substitute.cpp │ │ ├── tokenizer.cpp │ │ ├── xmltokenizer.cpp │ │ ├── yacasapi.cpp │ │ └── yacasnumbers.cpp │ ├── libyacas_mp/ │ │ ├── CMakeLists.txt │ │ ├── benchmark/ │ │ │ ├── CMakeLists.txt │ │ │ └── src/ │ │ │ └── nn_benchmark.cpp │ │ ├── include/ │ │ │ └── yacas/ │ │ │ └── mp/ │ │ │ ├── limbs_vector.hpp │ │ │ ├── nn.hpp │ │ │ ├── rr.hpp │ │ │ └── zz.hpp │ │ ├── src/ │ │ │ ├── limbs_vector.cpp │ │ │ ├── nn.cpp │ │ │ ├── rr.cpp │ │ │ └── zz.cpp │ │ └── test/ │ │ ├── CMakeLists.txt │ │ └── src/ │ │ ├── nn_test.cpp │ │ └── zz_test.cpp │ ├── packaging/ │ │ ├── deb/ │ │ │ ├── changelog │ │ │ ├── compat │ │ │ ├── control │ │ │ ├── copyright │ │ │ ├── missing-sources/ │ │ │ │ ├── jquery-ui.js │ │ │ │ ├── jquery.autosize.js │ │ │ │ ├── jquery.js │ │ │ │ ├── jquery.ui-contextmenu.js │ │ │ │ └── plotly-1.49.0.js │ │ │ ├── rules │ │ │ ├── source/ │ │ │ │ ├── format │ │ │ │ └── include-binaries │ │ │ └── yacas.1 │ │ ├── ebuild/ │ │ │ └── yacas.ebuild │ │ ├── flatpak/ │ │ │ ├── org.yacas.yacas-gui.appdata.xml │ │ │ ├── org.yacas.yacas-gui.json │ │ │ └── org.yacas.yacas.json │ │ ├── nsis/ │ │ │ ├── COPYING │ │ │ └── yacas-win64.nsi │ │ ├── pkg/ │ │ │ ├── distribution.xml │ │ │ ├── license.txt │ │ │ └── readme.html │ │ ├── rpm/ │ │ │ └── yacas.spec │ │ └── snap/ │ │ ├── snap/ │ │ │ └── gui/ │ │ │ └── yacas.gui.desktop │ │ └── snapcraft.yaml │ ├── xeus-yacas/ │ │ ├── CMakeLists.txt │ │ ├── include/ │ │ │ └── xeus-yacas/ │ │ │ └── xeus-yacas.hpp │ │ └── src/ │ │ ├── interpreter.cpp │ │ └── main.cpp │ ├── yacas/ │ │ ├── CMakeLists.txt │ │ ├── include/ │ │ │ ├── commandline.h │ │ │ ├── core_yacasmain.h │ │ │ ├── stdcommandline.h │ │ │ ├── unixcommandline.h │ │ │ └── win32commandline.h │ │ ├── res/ │ │ │ └── yacas.rc │ │ └── src/ │ │ ├── commandline.cpp │ │ ├── js_interface.cpp │ │ ├── stdcommandline.cpp │ │ ├── unixcommandline.cpp │ │ ├── win32commandline.cpp │ │ └── yacasmain.cpp │ ├── yacas-gui/ │ │ ├── CMakeLists.txt │ │ ├── img.qrc │ │ ├── include/ │ │ │ ├── cellproxy.h │ │ │ ├── mainwindow.h │ │ │ ├── preferences.h │ │ │ ├── preferences_dialog.h │ │ │ ├── yacasengine.h │ │ │ ├── yacasrequest.h │ │ │ └── yacasserver.h │ │ ├── resources/ │ │ │ ├── CMakeLists.txt │ │ │ ├── jquery/ │ │ │ │ ├── jquery.jeditable.autogrow.js │ │ │ │ └── jquery.jeditable.js │ │ │ ├── mathbar/ │ │ │ │ ├── functions.json │ │ │ │ ├── functions_parser.js │ │ │ │ ├── mathBar.js │ │ │ │ └── mathbar.css │ │ │ ├── webchannel/ │ │ │ │ └── qwebchannel.js │ │ │ ├── yacas-online.html │ │ │ ├── yacas_gui/ │ │ │ │ ├── attic/ │ │ │ │ │ └── intput.editable.js │ │ │ │ ├── yacas_gui.css │ │ │ │ └── yacas_gui.js │ │ │ └── yacas_gui.html │ │ ├── src/ │ │ │ ├── cellproxy.cpp │ │ │ ├── main.cpp │ │ │ ├── mainwindow.cpp │ │ │ ├── preferences.cpp │ │ │ ├── preferences_dialog.cpp │ │ │ ├── yacasengine.cpp │ │ │ ├── yacasrequest.cpp │ │ │ └── yacasserver.cpp │ │ ├── ui/ │ │ │ ├── mainwindow.ui │ │ │ └── preferences_dialog.ui │ │ ├── winres/ │ │ │ └── yacas_gui.rc │ │ ├── yacas-gui.desktop │ │ └── yacas.icns │ └── yacas-kernel/ │ ├── CMakeLists.txt │ ├── include/ │ │ ├── base64.hpp │ │ ├── hmac_sha256.hpp │ │ ├── yacas_engine.hpp │ │ └── yacas_kernel.hpp │ └── src/ │ ├── base64.cpp │ ├── hmac_sha256.cpp │ ├── main.cpp │ ├── yacas_engine.cpp │ └── yacas_kernel.cpp ├── docs/ │ ├── CMakeLists.txt │ ├── Makefile │ ├── book_of_algorithms/ │ │ ├── basic.rst │ │ ├── index.rst │ │ ├── integration.rst │ │ ├── multivar.rst │ │ ├── numtheory.rst │ │ ├── references.bib │ │ ├── references.rst │ │ ├── sturm-sequences.rst │ │ └── transforms.rst │ ├── conf.py │ ├── credits.rst │ ├── getting_started/ │ │ └── index.rst │ ├── glossary.rst │ ├── index.rst │ ├── license.rst │ ├── make.bat │ ├── programming_in_yacas/ │ │ └── index.rst │ ├── reference_manual/ │ │ ├── arithmetic.rst │ │ ├── calc.rst │ │ ├── consts.rst │ │ ├── controlflow.rst │ │ ├── debugging.rst │ │ ├── elementary.rst │ │ ├── functional.rst │ │ ├── graphs.rst │ │ ├── index.rst │ │ ├── io.rst │ │ ├── linear-algebra.rst │ │ ├── lists.rst │ │ ├── logic.rst │ │ ├── misc.rst │ │ ├── number-theory.rst │ │ ├── numerical-methods.rst │ │ ├── ode.rst │ │ ├── physics.rst │ │ ├── plot.rst │ │ ├── predicates.rst │ │ ├── probability-and-statistics.rst │ │ ├── programming.rst │ │ ├── random.rst │ │ ├── simplify.rst │ │ ├── solvers.rst │ │ ├── special.rst │ │ ├── strings.rst │ │ ├── univariate-polynomials.rst │ │ └── vars.rst │ ├── requirements.txt │ ├── tutorial/ │ │ └── index.rst │ └── util/ │ └── yacasdomain.py ├── jyacas/ │ ├── CMakeLists.txt │ ├── CVersion.java.in │ ├── JavaYacas.1 │ ├── MANIFEST.MF │ ├── lib/ │ │ ├── hamcrest-core-1.3.jar │ │ └── junit-4.11.jar │ └── net/ │ └── sf/ │ └── yacas/ │ ├── ArrayClass.java │ ├── AssociationClass.java │ ├── BackQuoteBehaviour.java │ ├── BasicEvaluator.java │ ├── BigNumber.java │ ├── BranchingUserFunction.java │ ├── CYacas.java │ ├── CachedStdFileInput.java │ ├── EvalFuncBase.java │ ├── GenericClass.java │ ├── InfixParser.java │ ├── InfixPrinter.java │ ├── InputDirectories.java │ ├── InputStatus.java │ ├── JarInputFile.java │ ├── LispArgList.java │ ├── LispArityUserFunction.java │ ├── LispAtom.java │ ├── LispDefFile.java │ ├── LispDefFiles.java │ ├── LispEnvironment.java │ ├── LispError.java │ ├── LispEvaluatorBase.java │ ├── LispGenericClass.java │ ├── LispGlobalVariable.java │ ├── LispHashTable.java │ ├── LispInFixOperator.java │ ├── LispInput.java │ ├── LispIterator.java │ ├── LispLocalFrame.java │ ├── LispMultiUserFunction.java │ ├── LispNumber.java │ ├── LispObject.java │ ├── LispOperators.java │ ├── LispParser.java │ ├── LispPrinter.java │ ├── LispPtr.java │ ├── LispPtrArray.java │ ├── LispStandard.java │ ├── LispSubList.java │ ├── LispTokenizer.java │ ├── LispUserFunction.java │ ├── ListedBranchingUserFunction.java │ ├── ListedMacroUserFunction.java │ ├── LocalSymbolBehaviour.java │ ├── MacroUserFunction.java │ ├── MatchAtom.java │ ├── MatchNumber.java │ ├── MatchSubList.java │ ├── MatchVariable.java │ ├── MathCommands.java │ ├── ParsedObject.java │ ├── PatternClass.java │ ├── StdFileInput.java │ ├── StreamGobbler.java │ ├── StringInput.java │ ├── SubstBehaviour.java │ ├── SubstBehaviourBase.java │ ├── UserStackInformation.java │ ├── XmlTokenizer.java │ ├── YacasConsole.java │ ├── YacasEvalCaller.java │ ├── YacasEvaluator.java │ ├── YacasException.java │ ├── YacasInterpreter.java │ ├── YacasParamMatcherBase.java │ ├── YacasPatternPredicateBase.java │ └── YacasTest.java ├── man/ │ ├── CMakeLists.txt │ └── yacas.1.rst ├── papers/ │ ├── llncs.cls │ ├── paper1.tex │ └── paper2.tex ├── scripts/ │ ├── array.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── assoc.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── base.rep/ │ │ ├── math.ys │ │ └── math.ys.def │ ├── c_form.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── calendar.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── complex.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ └── om.ys │ ├── constants.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ └── om.ys │ ├── controlflow.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── cse.rep/ │ │ ├── cse.ys │ │ └── cse.ys.def │ ├── debug.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── deffunc.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── deriv.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── example.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── examples/ │ │ ├── ABIN.ys │ │ ├── MinimumSpanningTree.ys │ │ ├── benchbuild.ys │ │ ├── benchmark.ys │ │ ├── benchmark2.ys │ │ ├── findsum.ys │ │ ├── goldbach.ys │ │ ├── pi.ys │ │ ├── queens.ys │ │ ├── series.ys │ │ └── wordproblems.ys │ ├── factors.rep/ │ │ ├── binaryfactors.ys │ │ ├── binaryfactors.ys.def │ │ ├── code.ys │ │ └── code.ys.def │ ├── functional.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ └── om.ys │ ├── graph.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── html.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── integrate.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ └── om.ys │ ├── io.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ ├── defaultprint.ys │ │ ├── defaultprint.ys.def │ │ ├── errors.ys │ │ ├── formula.ys │ │ └── print.ys │ ├── limit.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ └── om.ys │ ├── linalg.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── lists.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ ├── scopestack.ys │ │ └── scopestack.ys.def │ ├── localrules.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── logic.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ └── om.ys │ ├── multivar.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ ├── makemulti.ys │ │ ├── sparsenomial.ys │ │ ├── sparsetree.ys │ │ └── sparsetree.ys.def │ ├── newly.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── nintegrate.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── numbers.rep/ │ │ ├── GaussianIntegers.ys │ │ ├── GaussianIntegers.ys.def │ │ ├── NumberTheory.ys │ │ ├── NumberTheory.ys.def │ │ ├── code.ys │ │ ├── code.ys.def │ │ ├── nthroot.ys │ │ ├── nthroot.ys.def │ │ └── om.ys │ ├── odesolver.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── openmath.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── orthopoly.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── packages.ys │ ├── padic.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── patterns.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── physics.rep/ │ │ └── quantum/ │ │ ├── clebsch-gordan.ys │ │ └── clebsch-gordan.ys.def │ ├── plots.rep/ │ │ ├── backends-2d.ys │ │ ├── backends-3d.ys │ │ ├── code.ys │ │ ├── code.ys.def │ │ ├── plot2d.ys │ │ ├── plot2d.ys.def │ │ ├── plot3d.ys │ │ └── plot3d.ys.def │ ├── predicates.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── probability.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── products.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── pslq.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── r_form.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── rabinmiller.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── radsimp.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── random.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── rational.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── simplify.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ ├── factorial.ys │ │ └── factorial.ys.def │ ├── solve.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ └── om.ys │ ├── specfunc.rep/ │ │ ├── bernou.ys │ │ ├── bernou.ys.def │ │ ├── bessel.ys │ │ ├── bessel.ys.def │ │ ├── code.ys │ │ ├── code.ys.def │ │ ├── gamma.ys │ │ ├── gamma.ys.def │ │ ├── gammaconst.ys │ │ ├── gammaconst.ys.def │ │ ├── om.ys │ │ ├── zeta.ys │ │ └── zeta.ys.def │ ├── standard.ys │ ├── standard.ys.def │ ├── statistics.rep/ │ │ ├── distributions.ys │ │ ├── distributions.ys.def │ │ ├── hypothesystest.ys │ │ ├── hypothesystest.ys.def │ │ ├── incompletegamma.ys │ │ ├── incompletegamma.ys.def │ │ ├── randomtest.ys │ │ ├── regression.ys │ │ ├── regression.ys.def │ │ ├── statistics.ys │ │ └── statistics.ys.def │ ├── stats.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── stdarith.ys │ ├── stdarith.ys.def │ ├── stdfuncs.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ ├── elemfuncs.ys │ │ ├── elemfuncs.ys.def │ │ ├── numerical.ys │ │ ├── numerical.ys.def │ │ ├── nummethods.ys │ │ ├── nummethods.ys.def │ │ └── om.ys │ ├── stdopers.ys │ ├── stubs.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ └── om.ys │ ├── substitute.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── sums.rep/ │ │ ├── code.ys │ │ ├── code.ys.def │ │ ├── om.ys │ │ ├── taylor.ys │ │ ├── taylor.ys.def │ │ ├── taylor3.ys │ │ └── taylor3.ys.def │ ├── tensor.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── testers.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── texform.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── transforms.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── trigsimp.rep/ │ │ ├── code.ys │ │ └── code.ys.def │ ├── univar.rep/ │ │ ├── Cyclotomic.ys │ │ ├── Cyclotomic.ys.def │ │ ├── code.ys │ │ ├── code.ys.def │ │ ├── sparse.ys │ │ ├── sparse.ys.def │ │ ├── sturm.ys │ │ └── sturm.ys.def │ └── yacasinit.ys ├── tests/ │ ├── CMakeLists.txt │ ├── GaussianIntegers.yts │ ├── arithmetic.yts │ ├── association.yts │ ├── binaryfactors.yts │ ├── bitops.yts │ ├── c_tex_form.yts │ ├── calculus.yts │ ├── calendar.yts │ ├── canprove.yts │ ├── comments.yts │ ├── complex.yts │ ├── cyclotomic.yts │ ├── deriv.yts │ ├── dimensions.yts │ ├── dot.yts │ ├── graphs.yts │ ├── includetestfiles │ ├── integrate.yts │ ├── io.yts │ ├── journal.yts │ ├── linalg.yts │ ├── lists.yts │ ├── logic_simplify_test.yts │ ├── macro.yts │ ├── matrixpower.yts │ ├── multivar.yts │ ├── newly.yts │ ├── nthroot.yts │ ├── numbers.yts │ ├── numerics.yts │ ├── nummethods.yts │ ├── ode.yts │ ├── openmath.yts │ ├── orthopoly.yts │ ├── outer.yts │ ├── padic.yts │ ├── physics.yts │ ├── plots.yts │ ├── poly.yts │ ├── predicates.yts │ ├── products.yts │ ├── programming.yts │ ├── radsimp.yts │ ├── rational.yts │ ├── regress.yts │ ├── scopestack.yts │ ├── simplify.yts │ ├── solve.yts │ ├── sturm.yts │ ├── sums.yts │ ├── tensors.yts │ ├── test-yacas │ ├── test-yacas.bat │ ├── tr.yts │ ├── trace.yts │ └── transforms.yts ├── third_party/ │ └── README.rst ├── utils/ │ └── pre-commit └── yacas_UNINSTALL.sh
Showing preview only (480K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (5811 symbols across 176 files)
FILE: cyacas/libyacas/include/yacas/anumber.h
type std (line 16) | typedef std::uint32_t PlatWord;
type std (line 17) | typedef std::uint64_t PlatDoubleWord;
type std (line 18) | typedef std::int64_t PlatSignedDoubleWord;
function class (line 31) | class ANumber : public std::vector<PlatWord>
function Precision (line 45) | int Precision() const;
function Negate (line 98) | inline
function IsZero (line 109) | inline
FILE: cyacas/libyacas/include/yacas/arrayclass.h
function ArrayClass (line 25) | inline
function LispObject (line 43) | inline
function SetElement (line 50) | inline
FILE: cyacas/libyacas/include/yacas/associationclass.h
function LispPtr (line 45) | LispPtr Keys() const;
function AssociationClass (line 75) | inline
function Contains (line 93) | inline
function LispObject (line 99) | inline
function SetElement (line 108) | inline
function DropElement (line 114) | inline
FILE: cyacas/libyacas/include/yacas/deffile.h
function IsLoaded (line 23) | bool IsLoaded() const;
FILE: cyacas/libyacas/include/yacas/evalfunc.h
function class (line 7) | class EvalFuncBase
FILE: cyacas/libyacas/include/yacas/genericobject.h
function class (line 5) | class GenericClass {
FILE: cyacas/libyacas/include/yacas/infixparser.h
function class (line 38) | class ParsedObject {
FILE: cyacas/libyacas/include/yacas/lispatom.h
function LispObject (line 47) | LispObject* Copy() const override { return new LispAtom(*this); }
function LispPtr (line 62) | LispPtr* SubList() override { return &iSubList; }
function LispObject (line 63) | LispObject* Copy() const override { return new LispSubList(*this); }
function LispObject (line 83) | LispObject* Copy() const override { return new LispGenericClass(*this); }
function LispObject (line 105) | LispObject* Copy() const override { return new LispNumber(*this); }
FILE: cyacas/libyacas/include/yacas/lispenvironment.h
type std (line 31) | typedef std::unordered_set<LispStringSmartPtr, std::hash<const LispStrin...
type LispLocalVariable (line 250) | struct LispLocalVariable {
type LocalVariableFrame (line 261) | struct LocalVariableFrame {
function Precision (line 309) | inline int LispEnvironment::Precision(void) const
function BinaryPrecision (line 314) | inline int LispEnvironment::BinaryPrecision(void) const
function LispHashTable (line 331) | inline LispHashTable& LispEnvironment::HashTable()
function class (line 339) | class LispLocalFrame
function class (line 359) | class LispSecureFrame
function class (line 378) | class LispLocalInput: NonCopyable
function class (line 398) | class LispLocalOutput: NonCopyable
function class (line 416) | class LispLocalEvaluator: NonCopyable
function class (line 427) | class LispLocalTrace: NonCopyable
function SetPrettyReader (line 436) | inline void LispEnvironment::SetPrettyReader(const LispString* aPrettyRe...
function LispString (line 440) | inline const LispString* LispEnvironment::PrettyReader()
function SetPrettyPrinter (line 445) | inline void LispEnvironment::SetPrettyPrinter(const LispString * aPretty...
function LispString (line 449) | inline const LispString* LispEnvironment::PrettyPrinter()
FILE: cyacas/libyacas/include/yacas/lisperror.h
function class (line 6) | class LispError {
function LispError (line 16) | inline
function class (line 28) | class LispErrInvalidArg: public LispError {
function class (line 34) | class LispErrWrongNumberOfArgs: public LispError {
function class (line 40) | class LispErrNotList: public LispError {
function class (line 46) | class LispErrListNotLongEnough: public LispError {
function class (line 52) | class LispErrInvalidStack: public LispError {
function class (line 58) | class Quitting: public LispError {
function class (line 64) | class LispErrNotEnoughMemory: public LispError {
function class (line 70) | class InvalidToken: public LispError {
function class (line 76) | class LispErrInvalidExpression: public LispError {
function class (line 86) | class LispErrUnprintableToken: public LispError {
function class (line 92) | class LispErrFileNotFound: public LispError {
function class (line 98) | class LispErrReadingFile: public LispError {
function class (line 104) | class LispErrCreatingUserFunction: public LispError {
function class (line 110) | class LispErrCreatingRule: public LispError {
function class (line 116) | class LispErrArityAlreadyDefined: public LispError {
function class (line 122) | class LispErrCommentToEndOfFile: public LispError {
function class (line 128) | class LispErrNotString: public LispError {
function class (line 134) | class LispErrNotInteger: public LispError {
function class (line 140) | class LispErrParsingInput: public LispError {
function class (line 146) | class LispErrMaxRecurseDepthReached: public LispError {
function class (line 152) | class LispErrDefFileAlreadyChosen: public LispError {
function class (line 158) | class LispErrDivideByZero: public LispError {
function class (line 164) | class LispErrNotAnInFixOperator: public LispError {
function class (line 170) | class LispErrUser: public LispError {
function class (line 176) | class LispErrIsNotInFix: public LispError {
function class (line 182) | class LispErrSecurityBreach: public LispError {
function class (line 188) | class LispErrLibraryNotFound: public LispError {
function class (line 194) | class LispErrUserInterrupt: public LispError {
function class (line 200) | class LispErrNonBooleanPredicateInPattern: public LispError {
function class (line 206) | class LispErrProtectedSymbol: public LispError {
function class (line 212) | class LispErrGeneric: public LispError {
FILE: cyacas/libyacas/include/yacas/lispeval.h
function class (line 12) | class UserStackInformation {
function class (line 28) | class LispEvaluatorBase {
function class (line 42) | class BasicEvaluator : public LispEvaluatorBase
function class (line 81) | class TracedEvaluator : public BasicEvaluator
function class (line 127) | class YacasDebuggerBase {
FILE: cyacas/libyacas/include/yacas/lispevalhash.h
function class (line 17) | class YacasEvaluator: public EvalFuncBase
type std (line 41) | typedef std::unordered_map<LispStringSmartPtr, YacasEvaluator, std::hash...
FILE: cyacas/libyacas/include/yacas/lispglobals.h
function class (line 21) | class LispGlobalVariable {
type std (line 33) | typedef std::unordered_map<LispStringSmartPtr, LispGlobalVariable, std::...
function LispGlobalVariable (line 36) | inline
function SetEvalBeforeReturn (line 43) | inline
FILE: cyacas/libyacas/include/yacas/lisphash.h
function class (line 21) | class LispHashTable {
FILE: cyacas/libyacas/include/yacas/lispio.h
function LineNumber (line 19) | int LineNumber() const;
function NextLine (line 40) | inline
function class (line 50) | class LispInput
FILE: cyacas/libyacas/include/yacas/lispobject.h
type RefPtr (line 31) | typedef RefPtr<LispObject> LispPtr;
function class (line 40) | class LispObject: public RefCount
function class (line 95) | class LispIterator {
function class (line 130) | class LispConstIterator {
function LispPtr (line 165) | inline LispPtr& LispObject::Nixed()
function LispObject (line 170) | inline int LispObject::operator==(LispObject& aOther)
function LispObject (line 175) | inline int LispObject::operator!=(LispObject& aOther)
FILE: cyacas/libyacas/include/yacas/lispoperator.h
function SetLeftPrecedence (line 54) | void SetLeftPrecedence(int aPrecedence)
function SetRightPrecedence (line 59) | void SetRightPrecedence(int aPrecedence)
type std (line 70) | typedef std::unordered_map<const LispStringSmartPtr, LispInFixOperator, ...
FILE: cyacas/libyacas/include/yacas/lispparser.h
function class (line 16) | class LispParser {
function class (line 33) | class LispPrinter {
FILE: cyacas/libyacas/include/yacas/lispstring.h
function LispString (line 23) | inline LispString::LispString(const std::string& s):
type RefPtr (line 28) | typedef RefPtr<const LispString> LispStringSmartPtr;
FILE: cyacas/libyacas/include/yacas/lispuserfunc.h
function class (line 17) | class LispUserFunction : public EvalFuncBase
function UnTrace (line 34) | inline void UnTrace() {iTraced = false;}
function class (line 46) | class LispArityUserFunction : public LispUserFunction
function class (line 63) | class LispMultiUserFunction final {
type std (line 115) | typedef std::unordered_map<LispStringSmartPtr, LispMultiUserFunction, st...
FILE: cyacas/libyacas/include/yacas/mathuserfunc.h
function class (line 29) | class BranchRuleBase {
function Arity (line 153) | unsigned Arity() const override;
function class (line 197) | class MacroUserFunction : public BranchingUserFunction
FILE: cyacas/libyacas/include/yacas/mempool.h
function class (line 9) | class MemPool: NonCopyable {
function delete (line 35) | static void operator delete(void* p) { _pool.free(p); }
FILE: cyacas/libyacas/include/yacas/noncopyable.h
function class (line 4) | class NonCopyable {
FILE: cyacas/libyacas/include/yacas/numbers.h
function class (line 29) | class BigNumber: public RefCount {
FILE: cyacas/libyacas/include/yacas/patterns.h
function class (line 24) | class YacasParamMatcherBase {
function class (line 40) | class MatchAtom : public YacasParamMatcherBase
function MatchAtom (line 51) | inline
function class (line 58) | class MatchNumber : public YacasParamMatcherBase
function MatchNumber (line 69) | inline
function MatchSubList (line 90) | inline
function MatchSubList (line 96) | inline
function MatchVariable (line 127) | inline
function class (line 137) | class YacasPatternPredicateBase: NonCopyable {
FILE: cyacas/libyacas/include/yacas/platfileio.h
function class (line 10) | class LispLocalFile: NonCopyable {
function class (line 24) | class StdFileInput: public LispInput {
FILE: cyacas/libyacas/include/yacas/refcount.h
function operator (line 47) | operator T*() const { return iPtr; }
function _use_count (line 60) | RefCount(const RefCount&): _use_count(0) {}
FILE: cyacas/libyacas/include/yacas/standard.h
function class (line 57) | class LispObjectAdder {
FILE: cyacas/libyacas/include/yacas/string_utils.h
function std (line 10) | inline
function std (line 16) | inline
function std (line 23) | inline
function std (line 30) | inline
FILE: cyacas/libyacas/include/yacas/substitute.h
function class (line 11) | class SubstBehaviourBase {
FILE: cyacas/libyacas/include/yacas/tokenizer.h
function class (line 15) | class LispTokenizer {
FILE: cyacas/libyacas/include/yacas/utf8/checked.h
function namespace (line 34) | namespace utf8
function output_iterator (line 130) | output_iterator replace_invalid(octet_iterator start, octet_iterator end...
function std (line 136) | inline std::string replace_invalid(const std::string& s, utfchar32_t rep...
function std (line 143) | inline std::string replace_invalid(const std::string& s)
type utfchar32_t (line 294) | typedef utfchar32_t* pointer;
type utfchar32_t (line 295) | typedef utfchar32_t& reference;
type std (line 296) | typedef std::ptrdiff_t difference_type;
type std (line 297) | typedef std::bidirectional_iterator_tag iterator_category;
function utfchar32_t (line 309) | utfchar32_t operator * () const
function operator (line 320) | bool operator != (const iterator& rhs) const
function iterator (line 329) | iterator operator ++ (int)
function iterator (line 340) | iterator operator -- (int)
FILE: cyacas/libyacas/include/yacas/utf8/core.h
function namespace (line 55) | namespace utf8
function find_invalid (line 459) | inline std::size_t find_invalid(const std::string& s)
function is_valid (line 466) | bool is_valid(octet_iterator start, octet_iterator end)
function is_valid (line 471) | inline bool is_valid(const char* str)
function is_valid (line 476) | inline bool is_valid(const std::string& s)
function starts_with_bom (line 484) | bool starts_with_bom (octet_iterator it, octet_iterator end)
function starts_with_bom (line 493) | inline bool starts_with_bom(const std::string& s)
FILE: cyacas/libyacas/include/yacas/utf8/cpp11.h
function namespace (line 33) | namespace utf8
FILE: cyacas/libyacas/include/yacas/utf8/cpp17.h
function namespace (line 33) | namespace utf8
FILE: cyacas/libyacas/include/yacas/utf8/cpp20.h
function namespace (line 33) | namespace utf8
FILE: cyacas/libyacas/include/yacas/utf8/unchecked.h
function namespace (line 33) | namespace utf8
function output_iterator (line 83) | output_iterator replace_invalid(octet_iterator start, octet_iterator end...
function std (line 89) | inline std::string replace_invalid(const std::string& s, utfchar32_t rep...
function std (line 96) | inline std::string replace_invalid(const std::string& s)
type utfchar32_t (line 237) | typedef utfchar32_t* pointer;
type utfchar32_t (line 238) | typedef utfchar32_t& reference;
type std (line 239) | typedef std::ptrdiff_t difference_type;
type std (line 240) | typedef std::bidirectional_iterator_tag iterator_category;
function explicit (line 242) | explicit iterator (const octet_iterator& octet_it): it(octet_it) {}
function utfchar32_t (line 245) | utfchar32_t operator * () const
function operator (line 254) | bool operator != (const iterator& rhs) const
function iterator (line 263) | iterator operator ++ (int)
function iterator (line 274) | iterator operator -- (int)
FILE: cyacas/libyacas/include/yacas/yacas.h
function class (line 30) | class DefaultYacasEnvironment: NonCopyable
function std (line 86) | const std::string& Result() const;
FILE: cyacas/libyacas/src/anumber.cpp
function DigitIndex (line 51) | static int DigitIndex(int c)
function Digit (line 64) | static int Digit(int c)
function IntToBaseString (line 110) | std::string IntToBaseString(PlatDoubleWord aInt, int aBase)
function WordDigits (line 122) | int WordDigits(int aPrecision, int aBase)
function Multiply (line 289) | void Multiply(ANumber& aResult, ANumber& a1, ANumber& a2)
function BalanceFractions (line 336) | static void BalanceFractions(ANumber& a1, ANumber& a2)
function Add (line 378) | void Add(ANumber& aResult, ANumber& a1, ANumber& a2)
function GreaterThan (line 484) | bool GreaterThan(ANumber& a1, ANumber& a2)
function LessThan (line 496) | bool LessThan(ANumber& a1, ANumber& a2)
function ANumberToString (line 515) | void ANumberToString(std::string& aResult,
function BaseAddFull (line 647) | void BaseAddFull(ANumber& aResult, ANumber& a1, ANumber& a2)
function BaseSubtract (line 654) | void BaseSubtract(ANumber& aResult, ANumber& a1, ANumber& a2)
function BaseMultiplyFull (line 660) | void BaseMultiplyFull(ANumber& aResult, ANumber& a1, ANumber& a2)
function BaseGreaterThan (line 666) | bool BaseGreaterThan(const ANumber& a1, const ANumber& a2)
function BaseLessThan (line 707) | bool BaseLessThan(const ANumber& a1, const ANumber& a2)
function BaseShiftRight (line 712) | void BaseShiftRight(ANumber& a, int aNrBits)
function BaseShiftLeft (line 758) | void BaseShiftLeft(ANumber& a, int aNrBits)
function BaseDivide (line 856) | void BaseDivide(ANumber& aQuotient,
function IntegerDivide (line 958) | void IntegerDivide(ANumber& aQuotient,
function NormalizeFloat (line 1005) | void NormalizeFloat(ANumber& a2, int digitsNeeded)
function Divide (line 1025) | void Divide(ANumber& aQuotient, ANumber& aRemainder, ANumber& a1, ANumbe...
function Significant (line 1145) | bool Significant(ANumber& a)
FILE: cyacas/libyacas/src/arggetter.cpp
function LispString (line 10) | static const LispString*
function GetShortIntegerArgument (line 19) | int GetShortIntegerArgument(LispEnvironment& aEnvironment,
FILE: cyacas/libyacas/src/associationclass.cpp
function LispPtr (line 22) | LispPtr AssociationClass::Keys() const
function LispPtr (line 33) | LispPtr AssociationClass::ToList() const
function LispPtr (line 48) | LispPtr AssociationClass::Head() const
FILE: cyacas/libyacas/src/deffile.cpp
function LispDefFile (line 23) | LispDefFile* LispDefFiles::File(const std::string& aFileName)
function DoLoadDefFile (line 33) | static void DoLoadDefFile(LispEnvironment& aEnvironment,
function LoadDefFile (line 75) | void LoadDefFile(LispEnvironment& aEnvironment, const std::string& aFile...
FILE: cyacas/libyacas/src/errors.cpp
function ShowStack (line 7) | void ShowStack(LispEnvironment& aEnvironment)
function ShowFunctionError (line 12) | void ShowFunctionError(LispPtr& aArguments, LispEnvironment& aEnvironment)
function ShowArgTypeErrorInfo (line 18) | void ShowArgTypeErrorInfo(int aArgNr,
function CheckArg (line 43) | void CheckArg(bool pred, int arg_idx, LispEnvironment& env, int stack_top)
function CheckArgIsString (line 51) | void CheckArgIsString(LispPtr arg,
function CheckArgIsString (line 62) | void CheckArgIsString(int arg_idx, LispEnvironment& env, int stack_top)
function CheckArgIsList (line 67) | void CheckArgIsList(LispPtr arg,
function CheckArgIsList (line 78) | void CheckArgIsList(int arg_idx, LispEnvironment& env, int stack_top)
function CheckNrArgs (line 83) | void CheckNrArgs(int n, LispPtr& aArguments, LispEnvironment& aEnvironment)
function CheckSecure (line 102) | void CheckSecure(LispEnvironment& env, int stack_top)
FILE: cyacas/libyacas/src/lispatom.cpp
function LispObject (line 11) | LispObject* LispAtom::New(LispEnvironment& aEnvironment,
function LispString (line 26) | const LispString* LispAtom::String()
function LispSubList (line 35) | LispSubList* LispSubList::New(LispObject* aSubList)
function LispGenericClass (line 74) | LispGenericClass* LispGenericClass::New(GenericClass* aClass)
function GenericClass (line 91) | GenericClass* LispGenericClass::Generic()
function LispString (line 100) | LispString* LispNumber::String()
function BigNumber (line 122) | BigNumber* LispNumber::Number(int aBasePrecision)
FILE: cyacas/libyacas/src/lispenvironment.cpp
function LispPtr (line 116) | LispPtr* LispEnvironment::FindLocal(const LispString* aVariable)
function LispPrinter (line 267) | LispPrinter& LispEnvironment::CurrentPrinter()
function LispDefFiles (line 272) | LispDefFiles& LispEnvironment::DefFiles()
function LispOperators (line 277) | LispOperators& LispEnvironment::PreFix()
function LispOperators (line 281) | LispOperators& LispEnvironment::InFix()
function LispOperators (line 285) | LispOperators& LispEnvironment::PostFix()
function LispOperators (line 289) | LispOperators& LispEnvironment::Bodied()
function LispInput (line 294) | LispInput* LispEnvironment::CurrentInput()
function LispUserFunction (line 314) | LispUserFunction* LispEnvironment::UserFunction(LispPtr& aArguments)
function LispUserFunction (line 325) | LispUserFunction* LispEnvironment::UserFunction(const LispString* aName,
function LispMultiUserFunction (line 406) | LispMultiUserFunction*
FILE: cyacas/libyacas/src/lisperror.cpp
function HandleError (line 5) | void HandleError(const LispError& error,
FILE: cyacas/libyacas/src/lispeval.cpp
function LispUserFunction (line 14) | LispUserFunction* GetUserFunction(LispEnvironment& aEnvironment,
function UserStackInformation (line 34) | UserStackInformation& LispEvaluatorBase::StackInformation()
function ShowExpression (line 125) | void ShowExpression(LispString& outString,
function TraceShowExpression (line 142) | static void TraceShowExpression(LispEnvironment& aEnvironment,
function TraceShowArg (line 150) | void TraceShowArg(LispEnvironment& aEnvironment,
function TraceShowEnter (line 163) | void TraceShowEnter(LispEnvironment& aEnvironment, LispPtr& aExpression)
function TraceShowLeave (line 186) | void TraceShowLeave(LispEnvironment& aEnvironment,
function UserStackInformation (line 218) | UserStackInformation& TracedStackEvaluator::StackInformation()
FILE: cyacas/libyacas/src/lisphash.cpp
function LispString (line 3) | const LispString* LispHashTable::LookUp(const std::string& s)
FILE: cyacas/libyacas/src/lispuserfunc.cpp
function LispUserFunction (line 5) | LispUserFunction* LispMultiUserFunction::UserFunc(int aArity)
FILE: cyacas/libyacas/src/mathcommands.cpp
function LispQuote (line 47) | void LispQuote(LispEnvironment& aEnvironment, int aStackTop)
function LispEval (line 52) | void LispEval(LispEnvironment& aEnvironment, int aStackTop)
function InternalSetVar (line 62) | static void InternalSetVar(LispEnvironment& aEnvironment,
function LispSetVar (line 86) | void LispSetVar(LispEnvironment& aEnvironment, int aStackTop)
function LispMacroSetVar (line 93) | void LispMacroSetVar(LispEnvironment& aEnvironment, int aStackTop)
function LispSetGlobalLazyVariable (line 98) | void LispSetGlobalLazyVariable(LispEnvironment& aEnvironment, int aStack...
function LispClearVar (line 103) | void LispClearVar(LispEnvironment& aEnvironment, int aStackTop)
function LispVars (line 117) | void LispVars(LispEnvironment& aEnvironment, int aStackTop)
function LexLessThan (line 128) | static bool LexLessThan(const char* f1,
function LexGreaterThan (line 137) | static bool LexGreaterThan(const char* f1,
function BigLessThan (line 145) | static bool BigLessThan(BigNumber& n1, BigNumber& n2)
function BigGreaterThan (line 149) | static bool BigGreaterThan(BigNumber& n1, BigNumber& n2)
function LispStrictTotalOrder (line 154) | void LispStrictTotalOrder(LispEnvironment& aEnvironment, int aStackTop)
function LispLessThan (line 163) | void LispLessThan(LispEnvironment& aEnvironment, int aStackTop)
function LispGreaterThan (line 168) | void LispGreaterThan(LispEnvironment& aEnvironment, int aStackTop)
function LispLexCompare2 (line 173) | void LispLexCompare2(LispEnvironment& aEnvironment,
function LispFullForm (line 203) | void LispFullForm(LispEnvironment& aEnvironment, int aStackTop)
function LispHead (line 211) | void LispHead(LispEnvironment& aEnvironment, int aStackTop)
function LispNth (line 216) | void LispNth(LispEnvironment& aEnvironment, int aStackTop)
function LispTail (line 225) | void LispTail(LispEnvironment& aEnvironment, int aStackTop)
function LispUnList (line 235) | void LispUnList(LispEnvironment& aEnvironment, int aStackTop)
function LispListify (line 248) | void LispListify(LispEnvironment& aEnvironment, int aStackTop)
function LispDestructiveReverse (line 256) | void LispDestructiveReverse(LispEnvironment& aEnvironment, int aStackTop)
function LispLength (line 265) | void LispLength(LispEnvironment& aEnvironment, int aStackTop)
function LispList (line 285) | void LispList(LispEnvironment& aEnvironment, int aStackTop)
function LispConcatenate (line 301) | void LispConcatenate(LispEnvironment& aEnvironment, int aStackTop)
function LispConcatenateStrings (line 319) | void LispConcatenateStrings(LispEnvironment& aEnvironment, int aStackTop)
function InternalDelete (line 335) | static void
function LispDelete (line 366) | void LispDelete(LispEnvironment& aEnvironment, int aStackTop)
function LispDestructiveDelete (line 371) | void LispDestructiveDelete(LispEnvironment& aEnvironment, int aStackTop)
function LispFlatCopy (line 376) | void LispFlatCopy(LispEnvironment& aEnvironment, int aStackTop)
function InternalInsert (line 387) | static void
function LispInsert (line 416) | void LispInsert(LispEnvironment& aEnvironment, int aStackTop)
function LispDestructiveInsert (line 421) | void LispDestructiveInsert(LispEnvironment& aEnvironment, int aStackTop)
function InternalReplace (line 426) | static void
function LispReplace (line 460) | void LispReplace(LispEnvironment& aEnvironment, int aStackTop)
function LispDestructiveReplace (line 465) | void LispDestructiveReplace(LispEnvironment& aEnvironment, int aStackTop)
function LispNot (line 470) | void LispNot(LispEnvironment& aEnvironment, int aStackTop)
function LispLazyAnd (line 482) | void LispLazyAnd(LispEnvironment& aEnvironment, int aStackTop)
function LispLazyOr (line 522) | void LispLazyOr(LispEnvironment& aEnvironment, int aStackTop)
function LispEquals (line 563) | void LispEquals(LispEnvironment& aEnvironment, int aStackTop)
function LispWrite (line 573) | void LispWrite(LispEnvironment& aEnvironment, int aStackTop)
function LispWriteString (line 586) | void LispWriteString(LispEnvironment& aEnvironment, int aStackTop)
function LispProgBody (line 605) | void LispProgBody(LispEnvironment& aEnvironment, int aStackTop)
function LispNewLocal (line 620) | void LispNewLocal(LispEnvironment& aEnvironment, int aStackTop)
function LispWhile (line 635) | void LispWhile(LispEnvironment& aEnvironment, int aStackTop)
function MultiFix (line 652) | static void
function LispInFix (line 670) | void LispInFix(LispEnvironment& aEnvironment, int aStackTop)
function SingleFix (line 675) | static void SingleFix(int aPrecedence,
function LispPreFix (line 688) | void LispPreFix(LispEnvironment& aEnvironment, int aStackTop)
function LispPostFix (line 703) | void LispPostFix(LispEnvironment& aEnvironment, int aStackTop)
function LispBodied (line 712) | void LispBodied(LispEnvironment& aEnvironment, int aStackTop)
function LispAtomize (line 717) | void LispAtomize(LispEnvironment& aEnvironment, int aStackTop)
function LispStringify (line 728) | void LispStringify(LispEnvironment& aEnvironment, int aStackTop)
function LispLoad (line 740) | void LispLoad(LispEnvironment& aEnvironment, int aStackTop)
function LispTmpFile (line 755) | void LispTmpFile(LispEnvironment& aEnvironment, int aStackTop)
function LispProtect (line 784) | void LispProtect(LispEnvironment& env, int top)
function LispUnProtect (line 797) | void LispUnProtect(LispEnvironment& env, int top)
function LispIsProtected (line 810) | void LispIsProtected(LispEnvironment& env, int top)
function InternalRuleBase (line 823) | static void
function LispRuleBase (line 846) | void LispRuleBase(LispEnvironment& aEnvironment, int aStackTop)
function LispMacroRuleBase (line 851) | void LispMacroRuleBase(LispEnvironment& aEnvironment, int aStackTop)
function InternalDefMacroRuleBase (line 856) | void InternalDefMacroRuleBase(LispEnvironment& aEnvironment,
function LispDefMacroRuleBaseListed (line 879) | void LispDefMacroRuleBaseListed(LispEnvironment& aEnvironment, int aStac...
function LispDefMacroRuleBase (line 884) | void LispDefMacroRuleBase(LispEnvironment& aEnvironment, int aStackTop)
function LispRuleBaseListed (line 889) | void LispRuleBaseListed(LispEnvironment& aEnvironment, int aStackTop)
function LispMacroRuleBaseListed (line 894) | void LispMacroRuleBaseListed(LispEnvironment& aEnvironment, int aStackTop)
function LispHoldArg (line 899) | void LispHoldArg(LispEnvironment& aEnvironment, int aStackTop)
function InternalNewRule (line 914) | static void InternalNewRule(LispEnvironment& aEnvironment, int aStackTop)
function LispNewRule (line 951) | void LispNewRule(LispEnvironment& aEnvironment, int aStackTop)
function LispMacroNewRule (line 956) | void LispMacroNewRule(LispEnvironment& aEnvironment, int aStackTop)
function LispUnFence (line 961) | void LispUnFence(LispEnvironment& aEnvironment, int aStackTop)
function LispIsFunction (line 979) | void LispIsFunction(LispEnvironment& aEnvironment, int aStackTop)
function LispIsAtom (line 985) | void LispIsAtom(LispEnvironment& aEnvironment, int aStackTop)
function LispIsNumber (line 991) | void LispIsNumber(LispEnvironment& aEnvironment, int aStackTop)
function LispIsInteger (line 999) | void LispIsInteger(LispEnvironment& aEnvironment, int aStackTop)
function LispIsList (line 1007) | void LispIsList(LispEnvironment& aEnvironment, int aStackTop)
function LispIsString (line 1013) | void LispIsString(LispEnvironment& aEnvironment, int aStackTop)
function LispIsBound (line 1019) | void LispIsBound(LispEnvironment& aEnvironment, int aStackTop)
function LispIf (line 1033) | void LispIf(LispEnvironment& aEnvironment, int aStackTop)
function LispRetract (line 1055) | void LispRetract(LispEnvironment& aEnvironment, int aStackTop)
function YacasBuiltinPrecisionSet (line 1072) | void YacasBuiltinPrecisionSet(LispEnvironment& aEnvironment, int aStackTop)
function LispDefaultDirectory (line 1084) | void LispDefaultDirectory(LispEnvironment& aEnvironment, int aStackTop)
function LispFromFile (line 1094) | void LispFromFile(LispEnvironment& aEnvironment, int aStackTop)
function LispFromString (line 1128) | void LispFromString(LispEnvironment& aEnvironment, int aStackTop)
function LispRead (line 1151) | void LispRead(LispEnvironment& aEnvironment, int aStackTop)
function LispReadToken (line 1165) | void LispReadToken(LispEnvironment& aEnvironment, int aStackTop)
function LispToFile (line 1178) | void LispToFile(LispEnvironment& aEnvironment, int aStackTop)
function LispCheck (line 1206) | void LispCheck(LispEnvironment& aEnvironment, int aStackTop)
function LispTrapError (line 1220) | void LispTrapError(LispEnvironment& aEnvironment, int aStackTop)
function LispGetCoreError (line 1235) | void LispGetCoreError(LispEnvironment& aEnvironment, int aStackTop)
function LispSystemCall (line 1241) | void LispSystemCall(LispEnvironment& aEnvironment, int aStackTop)
function LispSystemName (line 1255) | void LispSystemName(LispEnvironment& aEnvironment, int aStackTop)
function LispMaxEvalDepth (line 1270) | void LispMaxEvalDepth(LispEnvironment& aEnvironment, int aStackTop)
function LispDefLoad (line 1281) | void LispDefLoad(LispEnvironment& aEnvironment, int aStackTop)
function LispUse (line 1296) | void LispUse(LispEnvironment& aEnvironment, int aStackTop)
function LispRightAssociative (line 1309) | void LispRightAssociative(LispEnvironment& aEnvironment, int aStackTop)
function LispLeftPrecedence (line 1325) | void LispLeftPrecedence(LispEnvironment& aEnvironment, int aStackTop)
function LispRightPrecedence (line 1347) | void LispRightPrecedence(LispEnvironment& aEnvironment, int aStackTop)
function LispInFixOperator (line 1369) | static LispInFixOperator* OperatorInfo(LispEnvironment& aEnvironment,
function LispIsInFix (line 1388) | void LispIsInFix(LispEnvironment& aEnvironment, int aStackTop)
function LispIsBodied (line 1395) | void LispIsBodied(LispEnvironment& aEnvironment, int aStackTop)
function LispGetPrecedence (line 1402) | void LispGetPrecedence(LispEnvironment& aEnvironment, int aStackTop)
function LispGetLeftPrecedence (line 1423) | void LispGetLeftPrecedence(LispEnvironment& aEnvironment, int aStackTop)
function LispGetRightPrecedence (line 1438) | void LispGetRightPrecedence(LispEnvironment& aEnvironment, int aStackTop)
function LispIsPreFix (line 1456) | void LispIsPreFix(LispEnvironment& aEnvironment, int aStackTop)
function LispIsPostFix (line 1463) | void LispIsPostFix(LispEnvironment& aEnvironment, int aStackTop)
function YacasBuiltinPrecisionGet (line 1471) | void YacasBuiltinPrecisionGet(LispEnvironment& aEnvironment, int aStackTop)
function LispToString (line 1477) | void LispToString(LispEnvironment& aEnvironment, int aStackTop)
function LispToStdout (line 1490) | void LispToStdout(LispEnvironment& aEnvironment, int aStackTop)
function LispSecure (line 1497) | void LispSecure(LispEnvironment& aEnvironment, int aStackTop)
function LispFindFile (line 1503) | void LispFindFile(LispEnvironment& aEnvironment, int aStackTop)
function LispIsGeneric (line 1521) | void LispIsGeneric(LispEnvironment& aEnvironment, int aStackTop)
function LispGenericTypeName (line 1528) | void LispGenericTypeName(LispEnvironment& aEnvironment, int aStackTop)
function GenArrayCreate (line 1537) | void GenArrayCreate(LispEnvironment& aEnvironment, int aStackTop)
function GenArraySize (line 1552) | void GenArraySize(LispEnvironment& aEnvironment, int aStackTop)
function GenArrayGet (line 1562) | void GenArrayGet(LispEnvironment& aEnvironment, int aStackTop)
function GenArraySet (line 1584) | void GenArraySet(LispEnvironment& aEnvironment, int aStackTop)
function GenAssociationCreate (line 1608) | void GenAssociationCreate(LispEnvironment& aEnvironment, int aStackTop)
function GenAssociationSize (line 1614) | void GenAssociationSize(LispEnvironment& aEnvironment, int aStackTop)
function GenAssociationContains (line 1624) | void GenAssociationContains(LispEnvironment& aEnvironment, int aStackTop)
function GenAssociationGet (line 1639) | void GenAssociationGet(LispEnvironment& aEnvironment, int aStackTop)
function GenAssociationSet (line 1655) | void GenAssociationSet(LispEnvironment& aEnvironment, int aStackTop)
function GenAssociationDrop (line 1670) | void GenAssociationDrop(LispEnvironment& aEnvironment, int aStackTop)
function GenAssociationKeys (line 1684) | void GenAssociationKeys(LispEnvironment& aEnvironment, int aStackTop)
function GenAssociationToList (line 1694) | void GenAssociationToList(LispEnvironment& aEnvironment, int aStackTop)
function GenAssociationHead (line 1704) | void GenAssociationHead(LispEnvironment& aEnvironment, int aStackTop)
function LispCustomEval (line 1715) | void LispCustomEval(LispEnvironment& aEnvironment, int aStackTop)
function LispCustomEvalExpression (line 1729) | void LispCustomEvalExpression(LispEnvironment& aEnvironment, int aStackTop)
function LispCustomEvalResult (line 1738) | void LispCustomEvalResult(LispEnvironment& aEnvironment, int aStackTop)
function LispCustomEvalLocals (line 1747) | void LispCustomEvalLocals(LispEnvironment& aEnvironment, int aStackTop)
function LispCustomEvalStop (line 1752) | void LispCustomEvalStop(LispEnvironment& aEnvironment, int aStackTop)
function LispTraceStack (line 1763) | void LispTraceStack(LispEnvironment& aEnvironment, int aStackTop)
function LispReadLisp (line 1769) | void LispReadLisp(LispEnvironment& aEnvironment, int aStackTop)
function LispReadLispListed (line 1777) | void LispReadLispListed(LispEnvironment& aEnvironment, int aStackTop)
function LispTraceRule (line 1786) | void LispTraceRule(LispEnvironment& aEnvironment, int aStackTop)
function LispType (line 1796) | void LispType(LispEnvironment& aEnvironment, int aStackTop)
function YacasStringMidGet (line 1817) | void YacasStringMidGet(LispEnvironment& aEnvironment, int aStackTop)
function YacasStringMidSet (line 1846) | void YacasStringMidSet(LispEnvironment& aEnvironment, int aStackTop)
function LispFindFunction (line 1872) | void LispFindFunction(LispEnvironment& aEnvironment, int aStackTop)
function GenPatternCreate (line 1900) | void GenPatternCreate(LispEnvironment& aEnvironment, int aStackTop)
function GenPatternMatches (line 1920) | void GenPatternMatches(LispEnvironment& aEnvironment, int aStackTop)
function LispRuleBaseDefined (line 1943) | void LispRuleBaseDefined(LispEnvironment& aEnvironment, int aStackTop)
function LispDefLoadFunction (line 1961) | void LispDefLoadFunction(LispEnvironment& aEnvironment, int aStackTop)
function LispRuleBaseArgList (line 1982) | void LispRuleBaseArgList(LispEnvironment& aEnvironment, int aStackTop)
function InternalNewRulePattern (line 2005) | static void InternalNewRulePattern(LispEnvironment& aEnvironment,
function LispNewRulePattern (line 2044) | void LispNewRulePattern(LispEnvironment& aEnvironment, int aStackTop)
function LispMacroNewRulePattern (line 2049) | void LispMacroNewRulePattern(LispEnvironment& aEnvironment, int aStackTop)
FILE: cyacas/libyacas/src/mathcommands2.cpp
function LispSubst (line 23) | void LispSubst(LispEnvironment& aEnvironment, int aStackTop)
function LispLocalSymbols (line 32) | void LispLocalSymbols(LispEnvironment& aEnvironment, int aStackTop)
function LispCharString (line 63) | void LispCharString(LispEnvironment& aEnvironment, int aStackTop)
function LispInDebugMode (line 78) | void LispInDebugMode(LispEnvironment& aEnvironment, int aStackTop)
function LispDebugFile (line 83) | void LispDebugFile(LispEnvironment& aEnvironment, int aStackTop)
function LispDebugLine (line 88) | void LispDebugLine(LispEnvironment& aEnvironment, int aStackTop)
FILE: cyacas/libyacas/src/mathcommands3.cpp
function GetNumber (line 37) | void GetNumber(RefPtr<BigNumber>& x,
function LispArithmetic1 (line 62) | void LispArithmetic1(LispEnvironment& aEnvironment,
function LispArithmetic2 (line 73) | void LispArithmetic2(LispEnvironment& aEnvironment,
function LispDumpBigNumberDebugInfo (line 89) | void LispDumpBigNumberDebugInfo(LispEnvironment& aEnvironment, int aStac...
function LispMultiply (line 97) | void LispMultiply(LispEnvironment& aEnvironment, int aStackTop)
function LispGcd (line 111) | void LispGcd(LispEnvironment& aEnvironment, int aStackTop)
function LispAdd (line 125) | void LispAdd(LispEnvironment& aEnvironment, int aStackTop)
function LispSubtract (line 146) | void LispSubtract(LispEnvironment& aEnvironment, int aStackTop)
function LispDivide (line 171) | void LispDivide(LispEnvironment& aEnvironment, int aStackTop)
function LispGetExactBits (line 242) | void LispGetExactBits(LispEnvironment& aEnvironment, int aStackTop)
function LispSetExactBits (line 252) | void LispSetExactBits(LispEnvironment& aEnvironment, int aStackTop)
function LispBitCount (line 266) | void LispBitCount(LispEnvironment& aEnvironment, int aStackTop)
function LispMathSign (line 276) | void LispMathSign(LispEnvironment& aEnvironment, int aStackTop)
function LispMathIsSmall (line 286) | void LispMathIsSmall(LispEnvironment& aEnvironment, int aStackTop)
function LispCeil (line 293) | void LispCeil(LispEnvironment& aEnvironment, int aStackTop)
function LispAbs (line 305) | void LispAbs(LispEnvironment& aEnvironment, int aStackTop)
function LispMod (line 316) | void LispMod(LispEnvironment& aEnvironment, int aStackTop)
function LispDiv (line 322) | void LispDiv(LispEnvironment& aEnvironment, int aStackTop)
function LispPower (line 340) | void LispPower(LispEnvironment& aEnvironment, int aStackTop)
function LispFac (line 345) | void LispFac(LispEnvironment& aEnvironment, int aStackTop)
function LispFastIsPrime (line 352) | void LispFastIsPrime(LispEnvironment& aEnvironment, int aStackTop)
function LispShiftLeft (line 405) | void LispShiftLeft(LispEnvironment& aEnvironment, int aStackTop)
function LispShiftRight (line 409) | void LispShiftRight(LispEnvironment& aEnvironment, int aStackTop)
function LispFromBase (line 416) | void LispFromBase(LispEnvironment& aEnvironment, int aStackTop)
function LispToBase (line 452) | void LispToBase(LispEnvironment& aEnvironment, int aStackTop)
function LispApplyPure (line 487) | void LispApplyPure(LispEnvironment& aEnvironment, int aStackTop)
function YacasPrettyReaderSet (line 507) | void YacasPrettyReaderSet(LispEnvironment& aEnvironment, int aStackTop)
function YacasPrettyReaderGet (line 523) | void YacasPrettyReaderGet(LispEnvironment& aEnvironment, int aStackTop)
function YacasPrettyPrinterSet (line 531) | void YacasPrettyPrinterSet(LispEnvironment& aEnvironment, int aStackTop)
function YacasPrettyPrinterGet (line 547) | void YacasPrettyPrinterGet(LispEnvironment& aEnvironment, int aStackTop)
function LispGarbageCollect (line 555) | void LispGarbageCollect(LispEnvironment& aEnvironment, int aStackTop)
function LispPatchLoad (line 561) | void LispPatchLoad(LispEnvironment& aEnvironment, int aStackTop)
function LispPatchString (line 584) | void LispPatchString(LispEnvironment& aEnvironment, int aStackTop)
function LispDefaultTokenizer (line 597) | void LispDefaultTokenizer(LispEnvironment& aEnvironment, int aStackTop)
function LispXmlTokenizer (line 603) | void LispXmlTokenizer(LispEnvironment& aEnvironment, int aStackTop)
function LispExplodeTag (line 609) | void LispExplodeTag(LispEnvironment& aEnvironment, int aStackTop)
function YacasBuiltinAssoc (line 684) | void YacasBuiltinAssoc(LispEnvironment& aEnvironment, int aStackTop)
function LispCurrentFile (line 720) | void LispCurrentFile(LispEnvironment& aEnvironment, int aStackTop)
function LispCurrentLine (line 726) | void LispCurrentLine(LispEnvironment& aEnvironment, int aStackTop)
function LispBackQuote (line 732) | void LispBackQuote(LispEnvironment& aEnvironment, int aStackTop)
function interpreter (line 740) | void interpreter(LispEnvironment& aEnvironment, int aStackTop)
function LispVersion (line 745) | void LispVersion(LispEnvironment& aEnvironment, int aStackTop)
function LispBitsToDigits (line 752) | void LispBitsToDigits(LispEnvironment& aEnvironment, int aStackTop)
function LispDigitsToBits (line 776) | void LispDigitsToBits(LispEnvironment& aEnvironment, int aStackTop)
FILE: cyacas/libyacas/src/mathuserfunc.cpp
function LispPtr (line 24) | LispPtr& BranchingUserFunction::BranchRule::Body()
function LispPtr (line 44) | LispPtr& BranchingUserFunction::BranchPattern::Body()
function LispPtr (line 259) | const LispPtr& BranchingUserFunction::ArgList() const
FILE: cyacas/libyacas/src/numbers.cpp
function log2_table_range (line 16) | unsigned log2_table_range()
function log2_table_lookup (line 59) | double log2_table_lookup(unsigned n)
function digits_to_bits (line 73) | unsigned long digits_to_bits(unsigned long digits, unsigned base)
function bits_to_digits (line 79) | unsigned long bits_to_digits(unsigned long bits, unsigned base)
FILE: cyacas/libyacas/src/patcher.cpp
function PatchLoad (line 13) | void PatchLoad(const std::string& content,
FILE: cyacas/libyacas/src/patterns.cpp
function YacasParamMatcherBase (line 90) | const YacasParamMatcherBase*
FILE: cyacas/libyacas/src/platmath.cpp
function GetDouble (line 13) | double GetDouble(LispObject* aInteger)
function LispObject (line 24) | LispObject* Double(LispEnvironment& aEnvironment, double aValue)
class InitPrimesTable (line 65) | class InitPrimesTable {
function primes_table_check (line 81) | unsigned primes_table_check(unsigned long p)
function LispObject (line 95) | LispObject*
FILE: cyacas/libyacas/src/standard.cpp
function InternalIsList (line 20) | bool InternalIsList(const LispEnvironment& env, const LispPtr& aPtr)
function InternalIsString (line 33) | bool InternalIsString(const LispString* aOriginal)
function InternalUnstringify (line 44) | std::string InternalUnstringify(const std::string& s)
function InternalAsciiToInt (line 61) | int InternalAsciiToInt(const LispString& aString)
function IsNumber (line 71) | bool IsNumber(const std::string& s, bool aAllowFloat)
function InternalNth (line 110) | void InternalNth(LispPtr& aResult, const LispPtr& aArg, int n)
function InternalTail (line 131) | void InternalTail(LispPtr& aResult, const LispPtr& aArg)
function InternalReverseList (line 144) | void InternalReverseList(LispPtr& aResult, const LispPtr& aOriginal)
function InternalFlatCopy (line 159) | void InternalFlatCopy(LispPtr& aResult, const LispPtr& aOriginal)
function InternalListLength (line 171) | std::size_t InternalListLength(const LispPtr& aOriginal)
function InternalStrictTotalOrder (line 182) | bool InternalStrictTotalOrder(const LispEnvironment& env,
function InternalEquals (line 275) | bool InternalEquals(const LispEnvironment& aEnvironment,
function DoInternalLoad (line 345) | void DoInternalLoad(LispEnvironment& aEnvironment, LispInput* aInput)
function InternalLoad (line 383) | void InternalLoad(LispEnvironment& aEnvironment, const std::string& aFil...
function InternalUse (line 404) | void InternalUse(LispEnvironment& aEnvironment, const std::string& aFile...
function InternalApplyString (line 420) | void InternalApplyString(LispEnvironment& aEnvironment,
function InternalApplyPure (line 435) | void InternalApplyPure(LispPtr& oper,
function InternalEvalString (line 488) | void InternalEvalString(LispEnvironment& aEnvironment,
function LispObject (line 509) | LispObject* operator+(const LispObjectAdder& left, const LispObjectAdder...
function ParseExpression (line 519) | void ParseExpression(LispPtr& aResult,
function ReturnUnEvaluated (line 538) | void ReturnUnEvaluated(LispPtr& aResult,
function PrintExpression (line 558) | void PrintExpression(LispString& aResult,
function LispString (line 576) | const LispString* SymbolName(LispEnvironment& aEnvironment,
FILE: cyacas/libyacas/src/stdfileio.cpp
function MapPathSeparators (line 9) | static void MapPathSeparators(std::string& filename)
function InternalFindFile (line 109) | std::string InternalFindFile(const std::string& fname,
FILE: cyacas/libyacas/src/substitute.cpp
function InternalSubstitute (line 7) | void InternalSubstitute(LispPtr& aTarget,
FILE: cyacas/libyacas/src/tokenizer.cpp
function IsSymbolic (line 469) | bool IsSymbolic(char c)
function IsAlpha (line 482) | bool IsAlpha(std::uint32_t c)
function IsAlNum (line 491) | bool IsAlNum(std::uint32_t c)
FILE: cyacas/libyacas/src/yacasnumbers.cpp
function LispObject (line 17) | static LispObject*
function CalculatePrecision (line 25) | static int CalculatePrecision(const std::string& str,
function LispObject (line 126) | LispObject*
function LispObject (line 148) | LispObject* PowerFloat(LispObject* int1,
function LispObject (line 199) | LispObject* ShiftLeft(LispObject* int1,
function LispObject (line 210) | LispObject* ShiftRight(LispObject* int1,
function DivideInteger (line 221) | static void DivideInteger(ANumber& aQuotient,
function LispObject (line 239) | LispObject* ModFloat(LispObject* int1,
function LispObject (line 254) | LispObject*
function BigNumber (line 297) | BigNumber& BigNumber::operator=(const BigNumber& bn)
FILE: cyacas/libyacas_mp/benchmark/src/nn_benchmark.cpp
function random_string (line 29) | std::string random_string(std::size_t length)
function BM_NN_construct_random (line 42) | static void BM_NN_construct_random(benchmark::State& state)
function BM_NN_parse (line 50) | static void BM_NN_parse(benchmark::State& state)
function BM_NN_to_string (line 61) | static void BM_NN_to_string(benchmark::State& state)
function BM_NN_shift_left (line 72) | static void BM_NN_shift_left(benchmark::State& state)
function BM_NN_add (line 83) | static void BM_NN_add(benchmark::State& state)
function BM_NN_add_self (line 95) | static void BM_NN_add_self(benchmark::State& state)
function BM_NN_add_same (line 106) | static void BM_NN_add_same(benchmark::State& state)
function BM_NN_sqr (line 119) | static void BM_NN_sqr(benchmark::State& state)
function BM_NN_mul_same (line 130) | static void BM_NN_mul_same(benchmark::State& state)
function BM_NN_mul (line 142) | static void BM_NN_mul(benchmark::State& state)
function BM_NN_div (line 154) | static void BM_NN_div(benchmark::State& state)
FILE: cyacas/libyacas_mp/include/yacas/mp/limbs_vector.hpp
type yacas::mp (line 28) | namespace yacas::mp {
class LimbsVector (line 40) | class LimbsVector {
method LimbsVector (line 80) | explicit LimbsVector(const Container& container)
method assign (line 113) | void assign(InputIterator b, InputIterator e)
FILE: cyacas/libyacas_mp/include/yacas/mp/nn.hpp
type yacas (line 34) | namespace yacas {
type mp (line 35) | namespace mp {
class NN (line 36) | class NN {
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 272) | inline NN& NN::operator+=(Limb n)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 278) | inline NN& NN::operator-=(Limb n)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 284) | inline NN& NN::operator*=(Limb n)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 290) | inline NN& NN::operator/=(Limb n)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 296) | inline NN& NN::operator%=(Limb n)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 303) | inline NN& NN::operator+=(const NN& n)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 309) | inline NN& NN::operator-=(const NN& n)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 315) | inline NN& NN::operator*=(const NN& n)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 321) | inline NN& NN::operator/=(const NN& n)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 327) | inline NN& NN::operator%=(const NN& n)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 333) | inline NN& NN::operator<<=(unsigned n)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 339) | inline NN& NN::operator>>=(unsigned n)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 345) | inline NN& NN::operator|=(const NN& b)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 361) | inline NN& NN::operator&=(const NN& b)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function NN (line 381) | inline NN& NN::operator^=(const NN& b)
type ParseError (line 53) | struct ParseError : public std::invalid_argument {
method ParseError (line 54) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 61) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 62) | explicit DivisionByZeroError(std::string_view s) :
method NN (line 69) | NN() = default;
method NN (line 150) | NN(Iter b, Iter e)
function LimbsVector (line 472) | inline const LimbsVector& NN::limbs() const { return _limbs; }
FILE: cyacas/libyacas_mp/include/yacas/mp/zz.hpp
type yacas (line 24) | namespace yacas {
type mp (line 25) | namespace mp {
class ZZ (line 26) | class ZZ {
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 114) | inline ZZ gcd(ZZ a, ZZ b)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 162) | inline ZZ& ZZ::operator+=(int i)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 189) | inline ZZ& ZZ::operator-=(int i)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 196) | inline ZZ& ZZ::operator*=(int i)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 211) | inline ZZ& ZZ::operator/=(int i)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 228) | inline ZZ& ZZ::operator%=(int i)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 245) | inline ZZ& ZZ::operator+=(const ZZ& z)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 267) | inline ZZ& ZZ::operator-=(const ZZ& z)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 289) | inline ZZ& ZZ::operator*=(const ZZ& z)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 307) | inline ZZ& ZZ::operator/=(const ZZ& z)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 326) | inline ZZ& ZZ::operator%=(const ZZ& z)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 342) | inline ZZ& ZZ::operator<<=(unsigned n)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 348) | inline ZZ& ZZ::operator>>=(unsigned n)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 356) | inline ZZ& ZZ::operator|=(const ZZ& z)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 362) | inline ZZ& ZZ::operator&=(const ZZ& z)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function ZZ (line 370) | inline ZZ& ZZ::operator^=(const ZZ& z)
type ParseError (line 33) | struct ParseError : public std::invalid_argument {
method ParseError (line 34) | ParseError(std::string_view s, std::size_t) :
type DivisionByZeroError (line 40) | struct DivisionByZeroError : public std::domain_error {
method DivisionByZeroError (line 41) | explicit DivisionByZeroError(std::string_view s) :
function NN (line 439) | inline const NN& ZZ::to_NN() const
FILE: cyacas/libyacas_mp/src/limbs_vector.cpp
type yacas::mp (line 6) | namespace yacas::mp {
function LimbsVector (line 75) | LimbsVector& LimbsVector::operator=(const LimbsVector& other)
function LimbsVector (line 82) | LimbsVector& LimbsVector::operator=(LimbsVector&& other) noexcept
FILE: cyacas/libyacas_mp/src/nn.cpp
function _mul (line 31) | void _mul(const Limb* __restrict p, unsigned n, Limb a, Limb* __restrict r)
function ssub (line 56) | bool ssub(NN& a, const NN& b)
function sadd (line 70) | void sadd(NN& a, bool& ap, const NN& b, bool bp)
function ssub (line 87) | void ssub(NN& a, bool& ap, const NN& b, bool bp)
type yacas (line 102) | namespace yacas {
type mp (line 103) | namespace mp {
function NN (line 665) | NN NN::div_rem(const NN& d)
function NN (line 684) | NN NN::div_rem_bc(const NN& d)
function NN (line 761) | NN gcd(NN a, NN b)
FILE: cyacas/libyacas_mp/src/zz.cpp
type yacas (line 23) | namespace yacas {
type mp (line 24) | namespace mp {
FILE: cyacas/libyacas_mp/test/src/nn_test.cpp
function TEST (line 25) | TEST(YMP_NNTest, construction)
function TEST (line 38) | TEST(YMP_NNTest, is_zero)
function TEST (line 45) | TEST(YMP_NNTest, comparison)
function TEST (line 53) | TEST(YMP_NNTest, parity)
function TEST (line 61) | TEST(YMP_NNTest, to_string)
function TEST (line 81) | TEST(YMP_NNTest, io)
function TEST (line 93) | TEST(YMP_NNTest, shift)
function TEST (line 120) | TEST(YMP_NNTest, sqr)
function TEST (line 187) | TEST(YMP_NNTest, mul)
function TEST (line 225) | TEST(YMP_NNTest, pow)
function TEST (line 236) | TEST(YMP_NNTest, div_rem)
function TEST (line 440) | TEST(YMP_NNTest, bitwise) {}
function TEST (line 442) | TEST(YMP_NNTest, no_digits)
function TEST (line 456) | TEST(YMP_NNTest, gcd)
FILE: cyacas/libyacas_mp/test/src/zz_test.cpp
function TEST (line 25) | TEST(YMP_ZZTest, construction)
function TEST (line 42) | TEST(YMP_ZZTest, is_zero)
function TEST (line 51) | TEST(YMP_ZZTest, comparison)
function TEST (line 63) | TEST(YMP_ZZTest, parity)
function TEST (line 78) | TEST(YMP_ZZTest, to_string)
function TEST (line 95) | TEST(YMP_ZZTest, io)
function TEST (line 107) | TEST(YMP_ZZTest, shift)
function TEST (line 129) | TEST(YMP_ZZTest, sqr)
function TEST (line 148) | TEST(YMP_ZZTest, add)
function TEST (line 173) | TEST(YMP_ZZTest, mul)
function TEST (line 209) | TEST(YMP_ZZTest, pow)
function TEST (line 217) | TEST(YMP_ZZTest, div)
function TEST (line 284) | TEST(YMP_ZZTest, rem)
function TEST (line 300) | TEST(YMP_ZZTest, no_digits)
function TEST (line 324) | TEST(YMP_ZZTest, gcd)
FILE: cyacas/packaging/deb/missing-sources/jquery-ui.js
function _super (line 128) | function _super() {
function _superApply (line 132) | function _superApply( args ) {
function processClassString (line 512) | function processClassString( classes, checkOption ) {
function handlerProxy (line 595) | function handlerProxy() {
function handlerProxy (line 639) | function handlerProxy() {
function getOffsets (line 775) | function getOffsets( offsets, width, height ) {
function parseCss (line 782) | function parseCss( element, property ) {
function getDimensions (line 786) | function getDimensions( elem ) {
function clamp (line 1482) | function clamp( value, prop, allowEmpty ) {
function stringParse (line 1509) | function stringParse( string ) {
function hue2rgb (line 1763) | function hue2rgb( p, q, h ) {
function getElementStyles (line 2037) | function getElementStyles( elem ) {
function styleDifference (line 2065) | function styleDifference( oldStyle, newStyle ) {
function _normalizeArguments (line 2558) | function _normalizeArguments( effect, options, speed, callback ) {
function standardAnimationOption (line 2610) | function standardAnimationOption( option ) {
function run (line 2687) | function run( next ) {
function parseClip (line 2835) | function parseClip( str, element ) {
function childComplete (line 3219) | function childComplete() {
function animComplete (line 3269) | function animComplete() {
function visible (line 3929) | function visible( element ) {
function reduce (line 4057) | function reduce( elem, size, border, margin ) {
function datepicker_getZindex (line 7189) | function datepicker_getZindex( elem ) {
function Datepicker (line 7218) | function Datepicker() {
function datepicker_bindHover (line 9184) | function datepicker_bindHover( dpDiv ) {
function datepicker_handleMouseover (line 9198) | function datepicker_handleMouseover() {
function datepicker_extendRemove (line 9212) | function datepicker_extendRemove( target, props ) {
function checkFocus (line 12247) | function checkFocus() {
function filteredUi (line 12454) | function filteredUi( ui ) {
function filteredUi (line 12502) | function filteredUi( ui ) {
function isOverAxis (line 13099) | function isOverAxis( x, reference, size ) {
function addItems (line 15923) | function addItems() {
function delayEvent (line 16657) | function delayEvent( type, instance, container ) {
function spinnerModifer (line 16757) | function spinnerModifer( fn ) {
function checkFocus (line 16888) | function checkFocus() {
function constrain (line 17539) | function constrain() {
function complete (line 17926) | function complete() {
function show (line 17931) | function show() {
function position (line 18483) | function position( event ) {
FILE: cyacas/packaging/deb/missing-sources/jquery.autosize.js
function setWidth (line 103) | function setWidth() {
function initMirror (line 125) | function initMirror() {
function adjust (line 159) | function adjust() {
function resize (line 210) | function resize () {
FILE: cyacas/packaging/deb/missing-sources/jquery.js
function DOMEval (line 98) | function DOMEval( code, node, doc ) {
function toType (line 128) | function toType( obj ) {
function isArrayLike (line 496) | function isArrayLike( obj ) {
function Sizzle (line 729) | function Sizzle( selector, context, results, seed ) {
function createCache (line 871) | function createCache() {
function markFunction (line 889) | function markFunction( fn ) {
function assert (line 898) | function assert( fn ) {
function addHandle (line 920) | function addHandle( attrs, handler ) {
function siblingCheck (line 935) | function siblingCheck( a, b ) {
function createInputPseudo (line 961) | function createInputPseudo( type ) {
function createButtonPseudo (line 972) | function createButtonPseudo( type ) {
function createDisabledPseudo (line 983) | function createDisabledPseudo( disabled ) {
function createPositionalPseudo (line 1039) | function createPositionalPseudo( fn ) {
function testContext (line 1062) | function testContext( context ) {
function setFilters (line 2150) | function setFilters() {}
function toSelector (line 2221) | function toSelector( tokens ) {
function addCombinator (line 2231) | function addCombinator( matcher, combinator, base ) {
function elementMatcher (line 2295) | function elementMatcher( matchers ) {
function multipleContexts (line 2309) | function multipleContexts( selector, contexts, results ) {
function condense (line 2318) | function condense( unmatched, map, filter, context, xml ) {
function setMatcher (line 2339) | function setMatcher( preFilter, selector, matcher, postFilter, postFinde...
function matcherFromTokens (line 2432) | function matcherFromTokens( tokens ) {
function matcherFromGroupMatchers (line 2490) | function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
function nodeName (line 2826) | function nodeName( elem, name ) {
function winnow (line 2836) | function winnow( elements, qualifier, not ) {
function sibling (line 3131) | function sibling( cur, dir ) {
function createOptions (line 3218) | function createOptions( options ) {
function Identity (line 3443) | function Identity( v ) {
function Thrower (line 3446) | function Thrower( ex ) {
function adoptValue (line 3450) | function adoptValue( value, resolve, reject, noValue ) {
function resolve (line 3543) | function resolve( depth, deferred, handler, special ) {
function completed (line 3908) | function completed() {
function fcamelCase (line 4003) | function fcamelCase( all, letter ) {
function camelCase (line 4010) | function camelCase( string ) {
function Data (line 4027) | function Data() {
function getData (line 4196) | function getData( data ) {
function dataAttr (line 4221) | function dataAttr( elem, key, data ) {
function adjustCSS (line 4554) | function adjustCSS( elem, prop, valueParts, tween ) {
function getDefaultDisplay (line 4622) | function getDefaultDisplay( elem ) {
function showHide (line 4645) | function showHide( elements, show ) {
function getAll (line 4746) | function getAll( context, tag ) {
function setGlobalEval (line 4771) | function setGlobalEval( elems, refElements ) {
function buildFragment (line 4787) | function buildFragment( elems, context, scripts, selection, ignored ) {
function returnTrue (line 4908) | function returnTrue() {
function returnFalse (line 4912) | function returnFalse() {
function expectSync (line 4922) | function expectSync( elem, type ) {
function safeActiveElement (line 4929) | function safeActiveElement() {
function on (line 4935) | function on( elem, types, selector, data, fn, one ) {
function leverageNative (line 5420) | function leverageNative( el, type, expectSync ) {
function manipulationTarget (line 5791) | function manipulationTarget( elem, content ) {
function disableScript (line 5802) | function disableScript( elem ) {
function restoreScript (line 5806) | function restoreScript( elem ) {
function cloneCopyEvent (line 5816) | function cloneCopyEvent( src, dest ) {
function fixInput (line 5851) | function fixInput( src, dest ) {
function domManip (line 5864) | function domManip( collection, args, callback, ignored ) {
function remove (line 5956) | function remove( elem, selector, keepData ) {
function computeStyleTests (line 6249) | function computeStyleTests() {
function roundPixelMeasures (line 6293) | function roundPixelMeasures( measure ) {
function curCSS (line 6338) | function curCSS( elem, name, computed ) {
function addGetHookIf (line 6391) | function addGetHookIf( conditionFn, hookFn ) {
function vendorPropName (line 6416) | function vendorPropName( name ) {
function finalPropName (line 6431) | function finalPropName( name ) {
function setPositiveNumber (line 6457) | function setPositiveNumber( elem, value, subtract ) {
function boxModelAdjustment (line 6469) | function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, ...
function getWidthOrHeight (line 6537) | function getWidthOrHeight( elem, dimension, extra ) {
function Tween (line 6904) | function Tween( elem, options, prop, end, easing ) {
function schedule (line 7027) | function schedule() {
function createFxNow (line 7040) | function createFxNow() {
function genFx (line 7048) | function genFx( type, includeWidth ) {
function createTween (line 7068) | function createTween( value, prop, animation ) {
function defaultPrefilter (line 7082) | function defaultPrefilter( elem, props, opts ) {
function propFilter (line 7254) | function propFilter( props, specialEasing ) {
function Animation (line 7291) | function Animation( elem, properties, options ) {
function stripAndCollapse (line 8006) | function stripAndCollapse( value ) {
function getClass (line 8012) | function getClass( elem ) {
function classesToArray (line 8016) | function classesToArray( value ) {
function buildParams (line 8638) | function buildParams( prefix, obj, traditional, add ) {
function addToPrefiltersOrTransports (line 8792) | function addToPrefiltersOrTransports( structure ) {
function inspectPrefiltersOrTransports (line 8826) | function inspectPrefiltersOrTransports( structure, options, originalOpti...
function ajaxExtend (line 8855) | function ajaxExtend( target, src ) {
function ajaxHandleResponses (line 8875) | function ajaxHandleResponses( s, jqXHR, responses ) {
function ajaxConvert (line 8933) | function ajaxConvert( s, response, jqXHR, isSuccess ) {
function done (line 9448) | function done( status, nativeStatusText, responses, headers ) {
FILE: cyacas/packaging/deb/missing-sources/plotly-1.49.0.js
function r (line 7) | function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==...
function ViewController (line 818) | function ViewController(controllers, mode) {
function createViewController (line 906) | function createViewController(options) {
function targetDepth (line 942) | function targetDepth(d) {
function left (line 947) | function left(node) {
function right (line 952) | function right(node, n) {
function justify (line 957) | function justify(node, n) {
function center (line 962) | function center(node) {
function constant (line 967) | function constant(x) {
function ascendingSourceBreadth (line 982) | function ascendingSourceBreadth(a, b) {
function ascendingTargetBreadth (line 987) | function ascendingTargetBreadth(a, b) {
function ascendingBreadth (line 994) | function ascendingBreadth(a, b) {
function value (line 1007) | function value(d) {
function nodeCenter (line 1012) | function nodeCenter(node) {
function linkSourceCenter (line 1017) | function linkSourceCenter(link) {
function linkTargetCenter (line 1022) | function linkTargetCenter(link) {
function defaultId (line 1027) | function defaultId(d) {
function defaultNodes (line 1032) | function defaultNodes(graph) {
function defaultLinks (line 1037) | function defaultLinks(graph) {
function find (line 1042) | function find(nodeById, id) {
function getNodeID (line 1048) | function getNodeID(node, id) {
function sankeyCircular (line 1059) | function sankeyCircular () {
function identifyCircles (line 1594) | function identifyCircles(graph, id, sortNodes) {
function selectCircularLinkTypes (line 1655) | function selectCircularLinkTypes(graph, id) {
function linkAngle (line 1698) | function linkAngle(link) {
function circularLinksCross (line 1706) | function circularLinksCross(link1, link2) {
function numberOfNonSelfLinkingCycles (line 1717) | function numberOfNonSelfLinkingCycles(node, id) {
function onlyCircularLink (line 1732) | function onlyCircularLink(link) {
function calcVerticalBuffer (line 1753) | function calcVerticalBuffer(links, circularLinkGap, id) {
function addCircularPathData (line 1777) | function addCircularPathData(graph, circularLinkGap, y1, id) {
function createCircularPathString (line 1915) | function createCircularPathString(link) {
function sortLinkColumnAscending (line 1988) | function sortLinkColumnAscending(link1, link2) {
function sortLinkSourceYAscending (line 1997) | function sortLinkSourceYAscending(link1, link2) {
function sortLinkSourceYDescending (line 2002) | function sortLinkSourceYDescending(link1, link2) {
function sortLinkTargetYAscending (line 2007) | function sortLinkTargetYAscending(link1, link2) {
function sortLinkTargetYDescending (line 2012) | function sortLinkTargetYDescending(link1, link2) {
function linkColumnDistance (line 2017) | function linkColumnDistance(link) {
function linkXLength (line 2022) | function linkXLength(link) {
function linkPerpendicularYToLinkSource (line 2028) | function linkPerpendicularYToLinkSource(longerLink, shorterLink) {
function linkPerpendicularYToLinkTarget (line 2043) | function linkPerpendicularYToLinkTarget(longerLink, shorterLink) {
function resolveNodeLinkOverlaps (line 2057) | function resolveNodeLinkOverlaps(graph, y0, y1, id) {
function nodesOverlap (line 2148) | function nodesOverlap(nodeA, nodeB) {
function adjustNodeHeight (line 2164) | function adjustNodeHeight(node, dy, sankeyY0, sankeyY1) {
function sortSourceLinks (line 2181) | function sortSourceLinks(graph, y1, id, moveNodes) {
function sortTargetLinks (line 2278) | function sortTargetLinks(graph, y1, id) {
function sameInclines (line 2368) | function sameInclines(link1, link2) {
function incline (line 2375) | function incline(link) {
function selfLinking (line 2380) | function selfLinking(link, id) {
function fillHeight (line 2384) | function fillHeight(graph, y0, y1) {
function targetDepth (line 2443) | function targetDepth(d) {
function left (line 2447) | function left(node) {
function right (line 2451) | function right(node, n) {
function justify (line 2455) | function justify(node, n) {
function center (line 2459) | function center(node) {
function constant (line 2465) | function constant(x) {
function ascendingSourceBreadth (line 2471) | function ascendingSourceBreadth(a, b) {
function ascendingTargetBreadth (line 2475) | function ascendingTargetBreadth(a, b) {
function ascendingBreadth (line 2479) | function ascendingBreadth(a, b) {
function value (line 2483) | function value(d) {
function nodeCenter (line 2487) | function nodeCenter(node) {
function weightedSource (line 2491) | function weightedSource(link) {
function weightedTarget (line 2495) | function weightedTarget(link) {
function defaultId (line 2499) | function defaultId(d) {
function defaultNodes (line 2503) | function defaultNodes(graph) {
function defaultLinks (line 2507) | function defaultLinks(graph) {
function find (line 2511) | function find(nodeById, id) {
function sankey (line 2528) | function sankey() {
function computeNodeLinks (line 2581) | function computeNodeLinks(graph) {
function computeNodeValues (line 2600) | function computeNodeValues(graph) {
function computeNodeDepths (line 2613) | function computeNodeDepths(graph) {
function computeNodeBreadths (line 2644) | function computeNodeBreadths(graph) {
function computeLinkBreadths (line 2738) | function computeLinkBreadths(graph) {
function horizontalSource (line 2757) | function horizontalSource(d) {
function horizontalTarget (line 2761) | function horizontalTarget(d) {
function area (line 2803) | function area(geojson) {
function calculateArea (line 2816) | function calculateArea(geom) {
function polygonArea (line 2835) | function polygonArea(coords) {
function ringArea (line 2858) | function ringArea(coords) {
function rad (line 2894) | function rad(num) {
function centroid (line 2920) | function centroid(geojson, options) {
function feature (line 3034) | function feature(geom, properties, options) {
function geometry (line 3063) | function geometry(type, coordinates, options) {
function point (line 3091) | function point(coordinates, properties, options) {
function points (line 3120) | function points(coordinates, properties, options) {
function polygon (line 3142) | function polygon(coordinates, properties, options) {
function polygons (line 3181) | function polygons(coordinates, properties, options) {
function lineString (line 3205) | function lineString(coordinates, properties, options) {
function lineStrings (line 3236) | function lineStrings(coordinates, properties, options) {
function featureCollection (line 3265) | function featureCollection(features, options) {
function multiLineString (line 3295) | function multiLineString(coordinates, properties, options) {
function multiPoint (line 3321) | function multiPoint(coordinates, properties, options) {
function multiPolygon (line 3348) | function multiPolygon(coordinates, properties, options) {
function geometryCollection (line 3375) | function geometryCollection(geometries, properties, options) {
function round (line 3397) | function round(num, precision) {
function radiansToLength (line 3416) | function radiansToLength(radians, units) {
function lengthToRadians (line 3435) | function lengthToRadians(distance, units) {
function lengthToDegrees (line 3454) | function lengthToDegrees(distance, units) {
function bearingToAzimuth (line 3466) | function bearingToAzimuth(bearing) {
function radiansToDegrees (line 3481) | function radiansToDegrees(radians) {
function degreesToRadians (line 3493) | function degreesToRadians(degrees) {
function convertLength (line 3507) | function convertLength(length, originalUnit, finalUnit) {
function convertArea (line 3524) | function convertArea(area, originalUnit, finalUnit) {
function isNumber (line 3552) | function isNumber(num) {
function isObject (line 3567) | function isObject(input) {
function validateBBox (line 3592) | function validateBBox(bbox) {
function validateId (line 3630) | function validateId(id) {
function radians2degrees (line 3640) | function radians2degrees() {
function degrees2radians (line 3644) | function degrees2radians() {
function distanceToDegrees (line 3648) | function distanceToDegrees() {
function distanceToRadians (line 3652) | function distanceToRadians() {
function radiansToDistance (line 3656) | function radiansToDistance() {
function bearingToAngle (line 3660) | function bearingToAngle() {
function convertDistance (line 3664) | function convertDistance() {
function coordEach (line 3709) | function coordEach(geojson, callback, excludeWrapCoord) {
function coordReduce (line 3856) | function coordReduce(geojson, callback, initialValue, excludeWrapCoord) {
function propEach (line 3891) | function propEach(geojson, callback) {
function propReduce (line 3950) | function propReduce(geojson, callback, initialValue) {
function featureEach (line 3986) | function featureEach(geojson, callback) {
function featureReduce (line 4038) | function featureReduce(geojson, callback, initialValue) {
function coordAll (line 4062) | function coordAll(geojson) {
function geomEach (line 4102) | function geomEach(geojson, callback) {
function geomReduce (line 4221) | function geomReduce(geojson, callback, initialValue) {
function flattenEach (line 4258) | function flattenEach(geojson, callback) {
function flattenReduce (line 4341) | function flattenReduce(geojson, callback, initialValue) {
function segmentEach (line 4387) | function segmentEach(geojson, callback) {
function segmentReduce (line 4473) | function segmentReduce(geojson, callback, initialValue) {
function lineEach (line 4514) | function lineEach(geojson, callback) {
function lineReduce (line 4581) | function lineReduce(geojson, callback, initialValue) {
function findSegment (line 4624) | function findSegment(geojson, options) {
function findPoint (line 4720) | function findPoint(geojson, options) {
function createABigTriangle (line 4812) | function createABigTriangle(gl) {
function absolutize (line 4845) | function absolutize(path){
function addLineNumbers (line 4907) | function addLineNumbers (string, start, delim) {
function linearlyIndependent (line 4928) | function linearlyIndependent(points, d) {
function affineHull (line 4949) | function affineHull(points) {
function alphaComplex (line 4981) | function alphaComplex(alpha, points) {
function alphaShape (line 4996) | function alphaShape(alpha, points) {
function normalize (line 5004) | function normalize (arr, dim) {
function normalize (line 5034) | function normalize (arr, dim, bounds) {
function compare (line 5109) | function compare(a, b) {
function isBuffer (line 5133) | function isBuffer(b) {
function pToString (line 5174) | function pToString (obj) {
function isView (line 5177) | function isView(arrbuf) {
function getName (line 5211) | function getName(func) {
function truncate (line 5261) | function truncate(s, n) {
function inspect (line 5268) | function inspect(something) {
function getMessage (line 5276) | function getMessage(self) {
function fail (line 5293) | function fail(actual, expected, message, operator, stackStartFunction) {
function ok (line 5313) | function ok(value, message) {
function _deepEqual (line 5350) | function _deepEqual(actual, expected, strict, memos) {
function isArguments (line 5416) | function isArguments(object) {
function objEquiv (line 5420) | function objEquiv(a, b, strict, actualVisitedObjects) {
function notDeepStrictEqual (line 5472) | function notDeepStrictEqual(actual, expected, message) {
function expectedException (line 5497) | function expectedException(actual, expected) {
function _tryBlock (line 5521) | function _tryBlock(block) {
function _throws (line 5531) | function _throws(shouldThrow, block, expected, message) {
function strict (line 5584) | function strict(value, message) {
function deprecated (line 5715) | function deprecated() {
function inspect (line 5762) | function inspect(obj, opts) {
function stylizeWithColor (line 5820) | function stylizeWithColor(str, styleType) {
function stylizeNoColor (line 5832) | function stylizeNoColor(str, styleType) {
function arrayToHash (line 5837) | function arrayToHash(array) {
function formatValue (line 5848) | function formatValue(ctx, value, recurseTimes) {
function formatPrimitive (line 5961) | function formatPrimitive(ctx, value) {
function formatError (line 5980) | function formatError(value) {
function formatArray (line 5985) | function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
function formatProperty (line 6005) | function formatProperty(ctx, value, recurseTimes, visibleKeys, key, arra...
function reduceToSingleString (line 6064) | function reduceToSingleString(output, base, braces) {
function isArray (line 6087) | function isArray(ar) {
function isBoolean (line 6092) | function isBoolean(arg) {
function isNull (line 6097) | function isNull(arg) {
function isNullOrUndefined (line 6102) | function isNullOrUndefined(arg) {
function isNumber (line 6107) | function isNumber(arg) {
function isString (line 6112) | function isString(arg) {
function isSymbol (line 6117) | function isSymbol(arg) {
function isUndefined (line 6122) | function isUndefined(arg) {
function isRegExp (line 6127) | function isRegExp(re) {
function isObject (line 6132) | function isObject(arg) {
function isDate (line 6137) | function isDate(d) {
function isError (line 6142) | function isError(e) {
function isFunction (line 6148) | function isFunction(arg) {
function isPrimitive (line 6153) | function isPrimitive(arg) {
function objectToString (line 6165) | function objectToString(o) {
function pad (line 6170) | function pad(n) {
function timestamp (line 6179) | function timestamp() {
function hasOwnProperty (line 6221) | function hasOwnProperty(obj, prop) {
function reduce (line 6238) | function reduce(x) {
function barycentric (line 6246) | function barycentric(simplex, point) {
function getLens (line 6301) | function getLens (b64) {
function byteLength (line 6321) | function byteLength (b64) {
function _byteLength (line 6328) | function _byteLength (b64, validLen, placeHoldersLen) {
function toByteArray (line 6332) | function toByteArray (b64) {
function tripletToBase64 (line 6377) | function tripletToBase64 (num) {
function encodeChunk (line 6384) | function encodeChunk (uint8, start, end) {
function fromByteArray (line 6397) | function fromByteArray (uint8) {
function add (line 6439) | function add(a, b) {
function cmp (line 6450) | function cmp(a, b) {
function div (line 6461) | function div(a, b) {
function makeRational (line 6477) | function makeRational(numer, denom) {
function isRat (line 6534) | function isRat(x) {
function sign (line 6545) | function sign (x) {
function bn2num (line 6557) | function bn2num(b) {
function ctzNumber (line 6583) | function ctzNumber(x) {
function isBN (line 6604) | function isBN(x) {
function num2bn (line 6616) | function num2bn(x) {
function rationalize (line 6633) | function rationalize(numer, denom) {
function str2BN (line 6660) | function str2BN(x) {
function mul (line 6671) | function mul(a, b) {
function sign (line 6682) | function sign(x) {
function sub (line 6693) | function sub(a, b) {
function roundRat (line 6706) | function roundRat (f) {
function compileSearch (line 6738) | function compileSearch(funcName, predicate, reversed, extraArgs, useNdar...
function compileBoundsSearch (line 6767) | function compileBoundsSearch(predicate, reversed, suffix, earlyOut) {
function countTrailingZeros (line 6868) | function countTrailingZeros(v) {
function calcSDF (line 7012) | function calcSDF(src, options) {
function edt (line 7096) | function edt(data, width, height, f, d, v, z) {
function edt1d (line 7118) | function edt1d(f, d, v, z, n) {
function assert (line 7146) | function assert (val, msg) {
function inherits (line 7152) | function inherits (ctor, superCtor) {
function BN (line 7162) | function BN (number, base, endian) {
function parseHex (line 7327) | function parseHex (str, start, end) {
function parseBase (line 7381) | function parseBase (str, start, end, mul) {
function toBitArray (line 7768) | function toBitArray (num) {
function smallMulTo (line 8133) | function smallMulTo (self, num, out) {
function bigMulTo (line 8755) | function bigMulTo (self, num, out) {
function jumboMulTo (line 8796) | function jumboMulTo (self, num, out) {
function FFTM (line 8820) | function FFTM (x, y) {
function MPrime (line 10080) | function MPrime (name, p) {
function K256 (line 10130) | function K256 () {
function P224 (line 10197) | function P224 () {
function P192 (line 10205) | function P192 () {
function P25519 (line 10213) | function P25519 () {
function Red (line 10264) | function Red (m) {
function Mont (line 10498) | function Mont (m) {
function boundary (line 10575) | function boundary (cells) {
function boxEmpty (line 10615) | function boxEmpty(d, box) {
function convertBoxes (line 10625) | function convertBoxes(boxes, d, data, ids) {
function boxIntersect (line 10642) | function boxIntersect(red, blue, visit, full) {
function appendItem (line 10711) | function appendItem(i,j) {
function intersectFullArray (line 10715) | function intersectFullArray(x) {
function intersectBipartiteArray (line 10721) | function intersectBipartiteArray(x, y) {
function boxIntersectWrapper (line 10728) | function boxIntersectWrapper(arg0, arg1, arg2) {
function generateBruteForce (line 10785) | function generateBruteForce(redMajor, flip, full) {
function bruteForcePlanner (line 10846) | function bruteForcePlanner(full) {
function iterInit (line 10944) | function iterInit(d, count) {
function iterPush (line 10959) | function iterPush(ptr,
function onePointPartial (line 10980) | function onePointPartial(
function onePointFull (line 11022) | function onePointFull(
function boxIntersectIter (line 11059) | function boxIntersectIter(
function insertionSort (line 11397) | function insertionSort(d, axis, start, end, boxes, ids) {
function findMedian (line 11422) | function findMedian(d, axis, start, end, boxes, ids) {
function genPartition (line 11535) | function genPartition(predicate, args) {
function wrapper (line 11559) | function wrapper(data, n0) {
function insertionSort (line 11567) | function insertionSort(left, right, data) {
function swap (line 11591) | function swap(i, j, data) {
function move (line 11602) | function move(i, j, data) {
function rotate (line 11609) | function rotate(i, j, k, data) {
function shufflePivot (line 11623) | function shufflePivot(i, j, px, py, data) {
function compare (line 11632) | function compare(i, j, data) {
function comparePivot (line 11645) | function comparePivot(i, y, b, data) {
function quickSort (line 11656) | function quickSort(left, right, data) {
function sqInit (line 11815) | function sqInit(count) {
function sqPop (line 11849) | function sqPop(queue, index, count, item) {
function sqPush (line 11857) | function sqPush(queue, index, count, item) {
function sweepBipartite (line 11863) | function sweepBipartite(
function sweepComplete (line 11938) | function sweepComplete(d, visit,
function scanBipartite (line 12042) | function scanBipartite(
function scanComplete (line 12136) | function scanComplete(
function EventEmitter (line 12249) | function EventEmitter() {
function $getMaxListeners (line 12302) | function $getMaxListeners(that) {
function emitNone (line 12317) | function emitNone(handler, isFn, self) {
function emitOne (line 12327) | function emitOne(handler, isFn, self, arg1) {
function emitTwo (line 12337) | function emitTwo(handler, isFn, self, arg1, arg2) {
function emitThree (line 12347) | function emitThree(handler, isFn, self, arg1, arg2, arg3) {
function emitMany (line 12358) | function emitMany(handler, isFn, self, args) {
function _addListener (line 12426) | function _addListener(target, type, listener, prepend) {
function onceWrapper (line 12504) | function onceWrapper() {
function _onceWrap (line 12527) | function _onceWrap(target, type, listener) {
function _listeners (line 12654) | function _listeners(target, type, unwrap) {
function listenerCount (line 12687) | function listenerCount(type) {
function spliceOne (line 12708) | function spliceOne(list, index) {
function arrayClone (line 12714) | function arrayClone(arr, n) {
function unwrapListeners (line 12721) | function unwrapListeners(arr) {
function objectCreatePolyfill (line 12729) | function objectCreatePolyfill(proto) {
function objectKeysPolyfill (line 12734) | function objectKeysPolyfill(obj) {
function functionBindPolyfill (line 12741) | function functionBindPolyfill(context) {
function typedArraySupport (line 12794) | function typedArraySupport () {
function createBuffer (line 12821) | function createBuffer (length) {
function Buffer (line 12841) | function Buffer (arg, encodingOrOffset, length) {
function from (line 12867) | function from (value, encodingOrOffset, length) {
function assertSize (line 12932) | function assertSize (size) {
function alloc (line 12940) | function alloc (size, fill, encoding) {
function allocUnsafe (line 12964) | function allocUnsafe (size) {
function fromString (line 12982) | function fromString (string, encoding) {
function fromArrayLike (line 13006) | function fromArrayLike (array) {
function fromArrayBuffer (line 13015) | function fromArrayBuffer (array, byteOffset, length) {
function fromObject (line 13038) | function fromObject (obj) {
function checked (line 13063) | function checked (length) {
function SlowBuffer (line 13073) | function SlowBuffer (length) {
function byteLength (line 13164) | function byteLength (string, encoding) {
function slowToString (line 13213) | function slowToString (encoding, start, end) {
function swap (line 13291) | function swap (b, n, m) {
function bidirectionalIndexOf (line 13431) | function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
function arrayIndexOf (line 13487) | function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
function hexWrite (line 13555) | function hexWrite (buf, string, offset, length) {
function utf8Write (line 13580) | function utf8Write (buf, string, offset, length) {
function asciiWrite (line 13584) | function asciiWrite (buf, string, offset, length) {
function latin1Write (line 13588) | function latin1Write (buf, string, offset, length) {
function base64Write (line 13592) | function base64Write (buf, string, offset, length) {
function ucs2Write (line 13596) | function ucs2Write (buf, string, offset, length) {
function base64Slice (line 13678) | function base64Slice (buf, start, end) {
function utf8Slice (line 13686) | function utf8Slice (buf, start, end) {
function decodeCodePointsArray (line 13764) | function decodeCodePointsArray (codePoints) {
function asciiSlice (line 13782) | function asciiSlice (buf, start, end) {
function latin1Slice (line 13792) | function latin1Slice (buf, start, end) {
function hexSlice (line 13802) | function hexSlice (buf, start, end) {
function utf16leSlice (line 13815) | function utf16leSlice (buf, start, end) {
function checkOffset (line 13854) | function checkOffset (offset, ext, length) {
function checkInt (line 14029) | function checkInt (buf, value, offset, ext, max, min) {
function checkIEEE754 (line 14217) | function checkIEEE754 (buf, value, offset, ext, max, min) {
function writeFloat (line 14222) | function writeFloat (buf, value, offset, littleEndian, noAssert) {
function writeDouble (line 14240) | function writeDouble (buf, value, offset, littleEndian, noAssert) {
function base64clean (line 14379) | function base64clean (str) {
function toHex (line 14393) | function toHex (n) {
function utf8ToBytes (line 14398) | function utf8ToBytes (string, units) {
function asciiToBytes (line 14478) | function asciiToBytes (str) {
function utf16leToBytes (line 14487) | function utf16leToBytes (str, units) {
function base64ToBytes (line 14503) | function base64ToBytes (str) {
function blitBuffer (line 14507) | function blitBuffer (src, dst, offset, length) {
function isInstance (line 14518) | function isInstance (obj, type) {
function numberIsNaN (line 14523) | function numberIsNaN (obj) {
function canonicalizeEdge (line 14539) | function canonicalizeEdge(e) {
function compareEdge (line 14543) | function compareEdge(a, b) {
function canonicalizeEdges (line 14547) | function canonicalizeEdges(edges) {
function getDefault (line 14551) | function getDefault(options, property, dflt) {
function cdt2d (line 14558) | function cdt2d(points, edges, options) {
function testFlip (line 14621) | function testFlip(points, triangulation, stack, a, b, x) {
function delaunayRefine (line 14651) | function delaunayRefine(points, triangulation) {
function FaceIndex (line 14737) | function FaceIndex(cells, neighbor, constraint, flags, active, next, bou...
function compareCell (line 14749) | function compareCell(a, b) {
function indexCells (line 14780) | function indexCells(triangulation, infinity) {
function filterCells (line 14846) | function filterCells(cells, flags, target) {
function classifyFaces (line 14857) | function classifyFaces(triangulation, target, infinity) {
function PartialHull (line 14925) | function PartialHull(a, b, idx, lowerIds, upperIds) {
function Event (line 14934) | function Event(a, b, type, idx) {
function compareEvent (line 14947) | function compareEvent(a, b) {
function testPoint (line 14960) | function testPoint(hull, p) {
function addPoint (line 14964) | function addPoint(cells, hulls, points, p, idx) {
function findSplit (line 15004) | function findSplit(hull, edge) {
function splitHulls (line 15020) | function splitHulls(hulls, points, event) {
function mergeHulls (line 15031) | function mergeHulls(hulls, points, event) {
function monotoneTriangulate (line 15044) | function monotoneTriangulate(points, edges) {
function Triangulation (line 15108) | function Triangulation(stars, edges) {
function removePair (line 15115) | function removePair(list, j, k) {
function compareLex (line 15128) | function compareLex(a, b) {
function createTriangulation (line 15199) | function createTriangulation(numVerts, edges) {
function compileSearch (line 15210) | function compileSearch(funcName, predicate, reversed, extraArgs, earlyOu...
function compileBoundsSearch (line 15238) | function compileBoundsSearch(predicate, reversed, suffix, earlyOut) {
function orientation (line 15265) | function orientation(s) {
function dot (line 15285) | function dot(a, b) {
function barycentricCircumcenter (line 15294) | function barycentricCircumcenter(points) {
function circumcenter (line 15331) | function circumcenter(points) {
function circumradius (line 15353) | function circumradius(points) {
function clamp (line 15367) | function clamp(value, min, max) {
function boundRat (line 15390) | function boundRat (r) {
function boundEdges (line 15399) | function boundEdges (points, edges) {
function boundPoints (line 15416) | function boundPoints (points) {
function getCrossings (line 15431) | function getCrossings (points, edges, edgeBounds) {
function getTJunctions (line 15452) | function getTJunctions (points, edges, edgeBounds, vertBounds) {
function cutEdges (line 15470) | function cutEdges (floatPoints, edges, crossings, junctions, useColor) {
function dedupPoints (line 15564) | function dedupPoints (floatPoints, ratPoints, floatBounds) {
function compareLex2 (line 15632) | function compareLex2 (a, b) { return (a[0] - b[0]) || (a[1] - b[1]) }
function compareLex3 (line 15633) | function compareLex3 (a, b) {
function dedupEdges (line 15647) | function dedupEdges (edges, labels, useColor) {
function preRound (line 15686) | function preRound (points, edges, useColor) {
function snapRound (line 15693) | function snapRound (points, edges, useColor) {
function cleanPSLG (line 15721) | function cleanPSLG (points, edges, colors) {
function ratPerp (line 15769) | function ratPerp (a, b) {
function solveIntersection (line 15780) | function solveIntersection (a, b, c, d) {
function toNumber (line 15811) | function toNumber (rgba, normalized) {
function fromNumber (line 15836) | function fromNumber (n, normalized) {
function isInt (line 16063) | function isInt(color) {
function parse (line 16109) | function parse (cstr) {
function createColormap (line 16517) | function createColormap (spec) {
function rgb2float (line 16626) | function rgb2float (rgba) {
function rgb2hex (line 16635) | function rgb2hex (rgba) {
function rgbaStr (line 16645) | function rgbaStr (rgba) {
function testInterior (line 16660) | function testInterior(a, b, c) {
function compareAngle (line 16673) | function compareAngle(a, b, c, d) {
function compareInt (line 16740) | function compareInt(a, b) {
function compareCells (line 16744) | function compareCells(a, b) {
function compareOrientedCells (line 16799) | function compareOrientedCells(a, b) {
function convexHull (line 16812) | function convexHull(points) {
function convexHull1d (line 16834) | function convexHull1d(points) {
function convexHull2D (line 16860) | function convexHull2D(points) {
function permute (line 16884) | function permute(points, front) {
function invPermute (line 16899) | function invPermute(cells, front) {
function convexHullnD (line 16922) | function convexHullnD(points, d) {
function parseFont (line 17286) | function parseFont (value) {
function parseLineHeight (line 17368) | function parseLineHeight(value) {
function verify (line 17464) | function verify (value, values) {
function a2o (line 17472) | function a2o (a) {
function dcubicHermite (line 17500) | function dcubicHermite(p0, v0, p1, v1, t, f) {
function cubicHermite (line 17517) | function cubicHermite(p0, v0, p1, v1, t, f) {
function Procedure (line 17542) | function Procedure() {
function compileCwise (line 17559) | function compileCwise(user_args) {
function innerFill (line 17655) | function innerFill(order, proc, body) {
function outerFill (line 17708) | function outerFill(matched, order, proc, body) {
function countMatches (line 17749) | function countMatches(orders) {
function processBlock (line 17764) | function processBlock(block, proc, dtypes) {
function typeSummary (line 17849) | function typeSummary(dtypes) {
function generateCWiseOp (line 17876) | function generateCWiseOp(proc, typesig) {
function createThunk (line 18036) | function createThunk(proc) {
function ascending (line 18205) | function ascending(a, b) {
function bisector (line 18209) | function bisector(compare) {
function ascendingComparator (line 18235) | function ascendingComparator(f) {
function pairs (line 18245) | function pairs(array, f) {
function pair (line 18252) | function pair(a, b) {
function cross (line 18256) | function cross(values0, values1, reduce) {
function descending (line 18276) | function descending(a, b) {
function number (line 18280) | function number(x) {
function variance (line 18284) | function variance(values, valueof) {
function deviation (line 18316) | function deviation(array, f) {
function extent (line 18321) | function extent(values, valueof) {
function constant (line 18364) | function constant(x) {
function identity (line 18370) | function identity(x) {
function range (line 18374) | function range(start, stop, step) {
function ticks (line 18392) | function ticks(start, stop, count) {
function tickIncrement (line 18421) | function tickIncrement(start, stop, count) {
function tickStep (line 18430) | function tickStep(start, stop, count) {
function sturges (line 18440) | function sturges(values) {
function histogram (line 18444) | function histogram() {
function quantile (line 18511) | function quantile(values, p, valueof) {
function freedmanDiaconis (line 18524) | function freedmanDiaconis(values, min, max) {
function scott (line 18529) | function scott(values, min, max) {
function max (line 18533) | function max(values, valueof) {
function mean (line 18568) | function mean(values, valueof) {
function median (line 18592) | function median(values, valueof) {
function merge (line 18617) | function merge(arrays) {
function min (line 18639) | function min(values, valueof) {
function permute (line 18674) | function permute(array, indexes) {
function scan (line 18680) | function scan(values, compare) {
function shuffle (line 18699) | function shuffle(array, i0, i1) {
function sum (line 18714) | function sum(values, valueof) {
function transpose (line 18735) | function transpose(matrix) {
function length (line 18745) | function length(d) {
function zip (line 18749) | function zip() {
function Map (line 18799) | function Map() {}
function map (line 18849) | function map(object, f) {
function apply (line 18878) | function apply(array, depth, createResult, setResult) {
function entries (line 18908) | function entries(map$$1, depth) {
function createObject (line 18927) | function createObject() {
function setObject (line 18931) | function setObject(object, key, value) {
function createMap (line 18935) | function createMap() {
function setMap (line 18939) | function setMap(map$$1, key, value) {
function Set (line 18943) | function Set() {}
function set (line 18963) | function set(object, f) {
function define (line 19016) | function define(constructor, factory, prototype) {
function extend (line 19021) | function extend(parent, definition) {
function Color (line 19027) | function Color() {}
function color (line 19207) | function color(format) {
function rgbn (line 19223) | function rgbn(n) {
function rgba (line 19227) | function rgba(r, g, b, a) {
function rgbConvert (line 19232) | function rgbConvert(o) {
function rgb (line 19239) | function rgb(r, g, b, opacity) {
function Rgb (line 19243) | function Rgb(r, g, b, opacity) {
function hex (line 19281) | function hex(value) {
function hsla (line 19286) | function hsla(h, s, l, a) {
function hslConvert (line 19293) | function hslConvert(o) {
function hsl (line 19319) | function hsl(h, s, l, opacity) {
function Hsl (line 19323) | function Hsl(h, s, l, opacity) {
function hsl2rgb (line 19360) | function hsl2rgb(h, m1, m2) {
function labConvert (line 19380) | function labConvert(o) {
function gray (line 19399) | function gray(l, opacity) {
function lab (line 19403) | function lab(l, a, b, opacity) {
function Lab (line 19407) | function Lab(l, a, b, opacity) {
function xyz2lab (line 19437) | function xyz2lab(t) {
function lab2xyz (line 19441) | function lab2xyz(t) {
function lrgb2rgb (line 19445) | function lrgb2rgb(x) {
function rgb2lrgb (line 19449) | function rgb2lrgb(x) {
function hclConvert (line 19453) | function hclConvert(o) {
function lch (line 19461) | function lch(l, c, h, opacity) {
function hcl (line 19465) | function hcl(h, c, l, opacity) {
function Hcl (line 19469) | function Hcl(h, c, l, opacity) {
function cubehelixConvert (line 19497) | function cubehelixConvert(o) {
function cubehelix (line 19511) | function cubehelix(h, s, l, opacity) {
function Cubehelix (line 19515) | function Cubehelix(h, s, l, opacity) {
function dispatch (line 19569) | function dispatch() {
function Dispatch (line 19577) | function Dispatch(_) {
function parseTypenames (line 19581) | function parseTypenames(typenames, types) {
function get (line 19631) | function get(type, name) {
function set (line 19639) | function set(type, name, callback) {
function force (line 19670) | function force() {
function x (line 19711) | function x(d) {
function y (line 19715) | function y(d) {
function force (line 19727) | function force() {
function prepare (line 19770) | function prepare(quad) {
function initialize (line 19779) | function initialize() {
function index (line 19806) | function index(d) {
function find (line 19810) | function find(nodeById, nodeId) {
function defaultStrength (line 19829) | function defaultStrength(link) {
function force (line 19833) | function force(alpha) {
function initialize (line 19850) | function initialize() {
function initializeStrength (line 19875) | function initializeStrength() {
function initializeDistance (line 19883) | function initializeDistance() {
function x$1 (line 19919) | function x$1(d) {
function y$1 (line 19923) | function y$1(d) {
function step (line 19943) | function step() {
function tick (line 19952) | function tick() {
function initializeNodes (line 19970) | function initializeNodes() {
function initializeForce (line 19984) | function initializeForce(force) {
function force (line 20069) | function force(_) {
function initialize (line 20074) | function initialize() {
function accumulate (line 20081) | function accumulate(quad) {
function apply (line 20107) | function apply(quad, x1, _, x2) {
function force (line 20179) | function force(alpha) {
function initialize (line 20191) | function initialize() {
function force (line 20233) | function force(alpha) {
function initialize (line 20239) | function initialize() {
function force (line 20273) | function force(alpha) {
function initialize (line 20279) | function initialize() {
function defaultSeparation (line 20326) | function defaultSeparation(a, b) {
function meanX (line 20330) | function meanX(children) {
function meanXReduce (line 20334) | function meanXReduce(x, c) {
function maxY (line 20338) | function maxY(children) {
function maxYReduce (line 20342) | function maxYReduce(y, c) {
function leafLeft (line 20346) | function leafLeft(node) {
function leafRight (line 20352) | function leafRight(node) {
function cluster (line 20358) | function cluster() {
function count (line 20411) | function count(node) {
function node_count (line 20420) | function node_count() {
function node_each (line 20424) | function node_each(callback) {
function node_eachBefore (line 20438) | function node_eachBefore(callback) {
function node_eachAfter (line 20449) | function node_eachAfter(callback) {
function node_sum (line 20463) | function node_sum(value) {
function node_sort (line 20473) | function node_sort(compare) {
function node_path (line 20481) | function node_path(end) {
function leastCommonAncestor (line 20497) | function leastCommonAncestor(a, b) {
function node_ancestors (line 20512) | function node_ancestors() {
function node_descendants (line 20520) | function node_descendants() {
function node_leaves (line 20528) | function node_leaves() {
function node_links (line 20538) | function node_links() {
function hierarchy (line 20548) | function hierarchy(data, children) {
function node_copy (line 20575) | function node_copy() {
function defaultChildren (line 20579) | function defaultChildren(d) {
function copyData (line 20583) | function copyData(node) {
function computeHeight (line 20587) | function computeHeight(node) {
function Node (line 20593) | function Node(data) {
function shuffle (line 20618) | function shuffle(array) {
function enclose (line 20633) | function enclose(circles) {
function extendBasis (line 20645) | function extendBasis(B, p) {
function enclosesNot (line 20674) | function enclosesNot(a, b) {
function enclosesWeak (line 20679) | function enclosesWeak(a, b) {
function enclosesWeakAll (line 20684) | function enclosesWeakAll(a, B) {
function encloseBasis (line 20693) | function encloseBasis(B) {
function encloseBasis1 (line 20701) | function encloseBasis1(a) {
function encloseBasis2 (line 20709) | function encloseBasis2(a, b) {
function encloseBasis3 (line 20721) | function encloseBasis3(a, b, c) {
function place (line 20750) | function place(b, a, c) {
function intersects (line 20774) | function intersects(a, b) {
function score (line 20779) | function score(node) {
function Node$1 (line 20788) | function Node$1(circle) {
function packEnclose (line 20794) | function packEnclose(circles) {
function siblings (line 20862) | function siblings(circles) {
function optional (line 20867) | function optional(f) {
function required (line 20871) | function required(f) {
function constantZero (line 20876) | function constantZero() {
function constant (line 20880) | function constant(x) {
function defaultRadius (line 20886) | function defaultRadius(d) {
function index (line 20890) | function index() {
function radiusLeaf (line 20926) | function radiusLeaf(radius) {
function packChildren (line 20934) | function packChildren(padding, k) {
function translateChild (line 20951) | function translateChild(k) {
function roundNode (line 20962) | function roundNode(node) {
function treemapDice (line 20969) | function treemapDice(parent, x0, y0, x1, y1) {
function partition (line 20982) | function partition() {
function defaultId (line 21036) | function defaultId(d) {
function defaultParentId (line 21040) | function defaultParentId(d) {
function stratify (line 21044) | function stratify() {
function defaultSeparation$1 (line 21103) | function defaultSeparation$1(a, b) {
function nextLeft (line 21115) | function nextLeft(v) {
function nextRight (line 21121) | function nextRight(v) {
function moveSubtree (line 21128) | function moveSubtree(wm, wp, shift) {
function executeShifts (line 21140) | function executeShifts(v) {
function nextAncestor (line 21156) | function nextAncestor(vim, v, ancestor) {
function TreeNode (line 21160) | function TreeNode(node, i) {
function treeRoot (line 21176) | function treeRoot(root) {
function tree (line 21200) | function tree() {
function treemapSlice (line 21339) | function treemapSlice(parent, x0, y0, x1, y1) {
function squarifyRatio (line 21354) | function squarifyRatio(ratio, parent, x0, y0, x1, y1) {
function squarify (line 21405) | function squarify(parent, x0, y0, x1, y1) {
function index$1 (line 21416) | function index$1() {
function binary (line 21506) | function binary(parent, x0, y0, x1, y1) {
function sliceDice (line 21553) | function sliceDice(parent, x0, y0, x1, y1) {
function resquarify (line 21559) | function resquarify(parent, x0, y0, x1, y1) {
function basis (line 21618) | function basis(t1, v0, v1, v2, v3) {
function basis$1 (line 21626) | function basis$1(values) {
function basisClosed (line 21638) | function basisClosed(values) {
function constant (line 21650) | function constant(x) {
function linear (line 21656) | function linear(a, d) {
function exponential (line 21662) | function exponential(a, b, y) {
function hue (line 21668) | function hue(a, b) {
function gamma (line 21673) | function gamma(y) {
function nogamma (line 21679) | function nogamma(a, b) {
function rgb (line 21687) | function rgb(start, end) {
function rgbSpline (line 21706) | function rgbSpline(spline) {
function array (line 21735) | function array(a, b) {
function date (line 21751) | function date(a, b) {
function number (line 21758) | function number(a, b) {
function object (line 21764) | function object(a, b) {
function zero (line 21789) | function zero(b) {
function one (line 21795) | function one(b) {
function string (line 21801) | function string(a, b) {
function value (line 21849) | function value(a, b) {
function discrete (line 21861) | function discrete(range) {
function hue$1 (line 21868) | function hue$1(a, b) {
function round (line 21876) | function round(a, b) {
function decompose (line 21893) | function decompose(a, b, c, d, e, f) {
function parseCss (line 21914) | function parseCss(value) {
function parseSvg (line 21924) | function parseSvg(value) {
function interpolateTransform (line 21933) | function interpolateTransform(parse, pxComma, pxParen, degParen) {
function cosh (line 21999) | function cosh(x) {
function sinh (line 22003) | function sinh(x) {
function tanh (line 22007) | function tanh(x) {
function zoom (line 22013) | function zoom(p0, p1) {
function hsl (line 22059) | function hsl(hue$$1) {
function lab (line 22078) | function lab(start, end) {
function hcl (line 22092) | function hcl(hue$$1) {
function cubehelix (line 22111) | function cubehelix(hue$$1) {
function piecewise (line 22138) | function piecewise(interpolate, values) {
function quantize (line 22147) | function quantize(interpolator, n) {
function Path (line 22197) | function Path() {
function path (line 22203) | function path() {
function add (line 22341) | function add(tree, x, y, d) {
function addAll (line 22384) | function addAll(data) {
function removeAll (line 22629) | function removeAll(data) {
function defaultX (line 22681) | function defaultX(d) {
function defaultY (line 22689) | function defaultY(d) {
function quadtree (line 22697) | function quadtree(nodes, x, y) {
function Quadtree (line 22702) | function Quadtree(x, y, x0, y0, x1, y1) {
function leaf_copy (line 22712) | function leaf_copy(leaf) {
function constant (line 22772) | function constant(x) {
function acos (line 22791) | function acos(x) {
function asin (line 22795) | function asin(x) {
function arcInnerRadius (line 22799) | function arcInnerRadius(d) {
function arcOuterRadius (line 22803) | function arcOuterRadius(d) {
function arcStartAngle (line 22807) | function arcStartAngle(d) {
function arcEndAngle (line 22811) | function arcEndAngle(d) {
function arcPadAngle (line 22815) | function arcPadAngle(d) {
function intersect (line 22819) | function intersect(x0, y0, x1, y1, x2, y2, x3, y3) {
function cornerTangents (line 22830) | function cornerTangents(x0, y0, x1, y1, r1, rc, cw) {
function arc (line 22871) | function arc() {
function Linear (line 23057) | function Linear(context) {
function curveLinear (line 23085) | function curveLinear(context) {
function x (line 23089) | function x(p) {
function y (line 23093) | function y(p) {
function line (line 23097) | function line() {
function area (line 23148) | function area() {
function descending (line 23252) | function descending(a, b) {
function identity (line 23256) | function identity(d) {
function pie (line 23260) | function pie() {
function Radial (line 23337) | function Radial(curve) {
function curveRadial (line 23359) | function curveRadial(curve) {
function lineRadial (line 23370) | function lineRadial(l) {
function lineRadial$1 (line 23383) | function lineRadial$1() {
function areaRadial (line 23387) | function areaRadial() {
function pointRadial (line 23413) | function pointRadial(x, y) {
function linkSource (line 23419) | function linkSource(d) {
function linkTarget (line 23423) | function linkTarget(d) {
function link (line 23427) | function link(curve) {
function curveHorizontal (line 23464) | function curveHorizontal(context, x0, y0, x1, y1) {
function curveVertical (line 23469) | function curveVertical(context, x0, y0, x1, y1) {
function curveRadial$1 (line 23474) | function curveRadial$1(context, x0, y0, x1, y1) {
function linkHorizontal (line 23483) | function linkHorizontal() {
function linkVertical (line 23487) | function linkVertical() {
function linkRadial (line 23491) | function linkRadial() {
function symbol (line 23620) | function symbol() {
function noop (line 23647) | function noop() {}
function point (line 23649) | function point(that, x, y) {
function Basis (line 23660) | function Basis(context) {
function basis (line 23697) | function basis(context) {
function BasisClosed (line 23701) | function BasisClosed(context) {
function basisClosed (line 23747) | function basisClosed(context) {
function BasisOpen (line 23751) | function BasisOpen(context) {
function basisOpen (line 23785) | function basisOpen(context) {
function Bundle (line 23789) | function Bundle(context, beta) {
function bundle (line 23833) | function bundle(context) {
function point$1 (line 23844) | function point$1(that, x, y) {
function Cardinal (line 23855) | function Cardinal(context, tension) {
function cardinal (line 23895) | function cardinal(context) {
function CardinalClosed (line 23906) | function CardinalClosed(context, tension) {
function cardinal$$1 (line 23954) | function cardinal$$1(context) {
function CardinalOpen (line 23965) | function CardinalOpen(context, tension) {
function cardinal$$1 (line 24002) | function cardinal$$1(context) {
function point$2 (line 24013) | function point$2(that, x, y) {
function CatmullRom (line 24036) | function CatmullRom(context, alpha) {
function catmullRom (line 24088) | function catmullRom(context) {
function CatmullRomClosed (line 24099) | function CatmullRomClosed(context, alpha) {
function catmullRom$$1 (line 24159) | function catmullRom$$1(context) {
function CatmullRomOpen (line 24170) | function CatmullRomOpen(context, alpha) {
function catmullRom$$1 (line 24219) | function catmullRom$$1(context) {
function LinearClosed (line 24230) | function LinearClosed(context) {
function linearClosed (line 24250) | function linearClosed(context) {
function sign (line 24254) | function sign(x) {
function slope3 (line 24262) | function slope3(that, x2, y2) {
function slope2 (line 24272) | function slope2(that, t) {
function point$3 (line 24280) | function point$3(that, t0, t1) {
function MonotoneX (line 24289) | function MonotoneX(context) {
function MonotoneY (line 24332) | function MonotoneY(context) {
function ReflectContext (line 24340) | function ReflectContext(context) {
function monotoneX (line 24351) | function monotoneX(context) {
function monotoneY (line 24355) | function monotoneY(context) {
function Natural (line 24359) | function Natural(context) {
function controlPoints (line 24403) | function controlPoints(x) {
function natural (line 24421) | function natural(context) {
function Step (line 24425) | function Step(context, t) {
function step (line 24467) | function step(context) {
function stepBefore (line 24471) | function stepBefore(context) {
function stepAfter (line 24475) | function stepAfter(context) {
function none (line 24479) | function none(series, order) {
function none$1 (line 24489) | function none$1(series) {
function stackValue (line 24495) | function stackValue(d, key) {
function stack (line 24499) | function stack() {
function expand (line 24548) | function expand(series, order) {
function diverging (line 24557) | function diverging(series, order) {
function silhouette (line 24572) | function silhouette(series, order) {
function wiggle (line 24581) | function wiggle(series, order) {
function appearance (line 24604) | function appearance(series) {
function peak (line 24609) | function peak(series) {
function ascending (line 24615) | function ascending(series) {
function sum (line 24620) | function sum(series) {
function descending$1 (line 24626) | function descending$1(series) {
function insideOut (line 24630) | function insideOut(series) {
function reverse (line 24655) | function reverse(series) {
function now (line 24735) | function now() {
function clearNow (line 24739) | function clearNow() {
function Timer (line 24743) | function Timer() {
function timer (line 24772) | function timer(callback, delay, time) {
function timerFlush (line 24778) | function timerFlush() {
function wake (line 24789) | function wake() {
function poke (line 24801) | function poke() {
function nap (line 24806) | function nap() {
function sleep (line 24821) | function sleep(time) {
function d3_documentElement (line 24875) | function d3_documentElement(node) {
function d3_window (line 24878) | function d3_window(node) {
function d3_ascending (line 24912) | function d3_ascending(a, b) {
function d3_number (line 24975) | function d3_number(x) {
function d3_numeric (line 24978) | function d3_numeric(x) {
function d3_bisector (line 25037) | function d3_bisector(compare) {
function d3_transposeLength (line 25098) | function d3_transposeLength(d) {
function d3_range_integerScale (line 25150) | function d3_range_integerScale(x) {
function d3_class (line 25155) | function d3_class(ctor, properties) {
function d3_Map (line 25177) | function d3_Map() {
function d3_map_escape (line 25210) | function d3_map_escape(key) {
function d3_map_unescape (line 25213) | function d3_map_unescape(key) {
function d3_map_has (line 25216) | function d3_map_has(key) {
function d3_map_remove (line 25219) | function d3_map_remove(key) {
function d3_map_keys (line 25222) | function d3_map_keys() {
function d3_map_size (line 25227) | function d3_map_size() {
function d3_map_empty (line 25232) | function d3_map_empty() {
function map (line 25238) | function map(mapType, array, depth) {
function entries (line 25262) | function entries(map, depth) {
function d3_Set (line 25304) | function d3_Set() {
function d3_identity (line 25322) | function d3_identity(d) {
function d3_rebind (line 25330) | function d3_rebind(target, source, method) {
function d3_vendorSymbol (line 25336) | function d3_vendorSymbol(object, name) {
function d3_noop (line 25345) | function d3_noop() {}
function d3_dispatch (line 25351) | function d3_dispatch() {}
function d3_dispatch_event (line 25366) | function d3_dispatch_event(dispatch) {
function d3_eventPreventDefault (line 25389) | function d3_eventPreventDefault() {
function d3_eventSource (line 25392) | function d3_eventSource() {
function d3_eventDispatch (line 25397) | function d3_eventDispatch(target) {
function d3_selection (line 25423) | function d3_selection(groups) {
function d3_selection_selector (line 25466) | function d3_selection_selector(selector) {
function d3_selection_selectorAll (line 25484) | function d3_selection_selectorAll(selector) {
function d3_selection_attr (line 25520) | function d3_selection_attr(name, value) {
function d3_collapse (line 25544) | function d3_collapse(s) {
function d3_selection_classedRe (line 25564) | function d3_selection_classedRe(name) {
function d3_selection_classes (line 25567) | function d3_selection_classes(name) {
function d3_selection_classed (line 25570) | function d3_selection_classed(name, value) {
function d3_selection_classedName (line 25583) | function d3_selection_classedName(name) {
function d3_selection_style (line 25612) | function d3_selection_style(name, value, priority) {
function d3_selection_property (line 25633) | function d3_selection_property(name, value) {
function d3_selection_creator (line 25672) | function d3_selection_creator(name) {
function d3_selectionRemove (line 25692) | function d3_selectionRemove() {
function bind (line 25707) | function bind(group, groupData) {
function d3_selection_dataNode (line 25777) | function d3_selection_dataNode(data) {
function d3_selection_filter (line 25799) | function d3_selection_filter(selector) {
function d3_selection_sortComparator (line 25820) | function d3_selection_sortComparator(comparator) {
function d3_selection_each (line 25831) | function d3_selection_each(groups, callback) {
function d3_selection_enter (line 25863) | function d3_selection_enter(selection) {
function d3_selection_enterInsertBefore (line 25896) | function d3_selection_enterInsertBefore(enter) {
function d3_selection_on (line 25941) | function d3_selection_on(type, listener, capture) {
function d3_selection_onListener (line 25980) | function d3_selection_onListener(listener, argumentz) {
function d3_selection_onFilter (line 25992) | function d3_selection_onFilter(listener, argumentz) {
function d3_event_dragSuppress (line 26002) | function d3_event_dragSuppress(node) {
function d3_mousePoint (line 26030) | function d3_mousePoint(container, e) {
function drag (line 26069) | function drag() {
function dragstart (line 26072) | function dragstart(id, position, subject, move, end) {
function d3_behavior_dragTouchId (line 26116) | function d3_behavior_dragTouchId() {
function d3_sgn (line 26128) | function d3_sgn(x) {
function d3_cross2d (line 26131) | function d3_cross2d(a, b, c) {
function d3_acos (line 26134) | function d3_acos(x) {
function d3_asin (line 26137) | function d3_asin(x) {
function d3_sinh (line 26140) | function d3_sinh(x) {
function d3_cosh (line 26143) | function d3_cosh(x) {
function d3_tanh (line 26146) | function d3_tanh(x) {
function d3_haversin (line 26149) | function d3_haversin(x) {
function zoom (line 26186) | function zoom(g) {
function location (line 26287) | function location(p) {
function point (line 26290) | function point(l) {
function scaleTo (line 26293) | function scaleTo(s) {
function translateTo (line 26296) | function translateTo(p, l) {
function zoomTo (line 26301) | function zoomTo(that, p, l, k) {
function rescale (line 26313) | function rescale() {
function zoomstarted (line 26321) | function zoomstarted(dispatch) {
function zoomed (line 26326) | function zoomed(dispatch) {
function zoomended (line 26334) | function zoomended(dispatch) {
function mousedowned (line 26339) | function mousedowned() {
function touchstarted (line 26354) | function touchstarted() {
function mousewheeled (line 26424) | function mousewheeled() {
function dblclicked (line 26437) | function dblclicked() {
function d3_color (line 26445) | function d3_color() {}
function d3_hsl (line 26450) | function d3_hsl(h, s, l) {
function d3_hsl_rgb (line 26465) | function d3_hsl_rgb(h, s, l) {
function d3_hcl (line 26485) | function d3_hcl(h, c, l) {
function d3_hcl_lab (line 26498) | function d3_hcl_lab(h, c, l) {
function d3_lab (line 26504) | function d3_lab(l, a, b) {
function d3_lab_rgb (line 26519) | function d3_lab_rgb(l, a, b) {
function d3_lab_hcl (line 26526) | function d3_lab_hcl(l, a, b) {
function d3_lab_xyz (line 26529) | function d3_lab_xyz(x) {
function d3_xyz_lab (line 26532) | function d3_xyz_lab(x) {
function d3_xyz_rgb (line 26535) | function d3_xyz_rgb(r) {
function d3_rgb (line 26539) | function d3_rgb(r, g, b) {
function d3_rgbNumber (line 26542) | function d3_rgbNumber(value) {
function d3_rgbString (line 26545) | function d3_rgbString(value) {
function d3_rgb_hex (line 26568) | function d3_rgb_hex(v) {
function d3_rgb_parse (line 26571) | function d3_rgb_parse(format, rgb, hsl) {
function d3_rgb_hsl (line 26607) | function d3_rgb_hsl(r, g, b) {
function d3_rgb_lab (line 26619) | function d3_rgb_lab(r, g, b) {
function d3_rgb_xyz (line 26626) | function d3_rgb_xyz(r) {
function d3_rgb_parseNumber (line 26629) | function d3_rgb_parseNumber(c) {
function d3_functor (line 26786) | function d3_functor(v) {
function d3_xhrType (line 26793) | function d3_xhrType(response) {
function d3_xhr (line 26800) | function d3_xhr(url, mimeType, response, callback) {
function d3_xhr_fixCallback (line 26875) | function d3_xhr_fixCallback(callback) {
function d3_xhrHasResponse (line 26880) | function d3_xhrHasResponse(request) {
function dsv (line 26886) | function dsv(url, row, callback) {
function response (line 26894) | function response(request) {
function typedResponse (line 26897) | function typedResponse(f) {
function token (line 26916) | function token() {
function formatRow (line 26978) | function formatRow(row) {
function formatValue (line 26981) | function formatValue(text) {
function d3_timer (line 26994) | function d3_timer(callback, delay, then) {
function d3_timer_step (line 27012) | function d3_timer_step() {
function d3_timer_mark (line 27029) | function d3_timer_mark() {
function d3_timer_sweep (line 27037) | function d3_timer_sweep() {
function d3_format_precision (line 27050) | function d3_format_precision(x, p) {
function d3_formatPrefix (line 27067) | function d3_formatPrefix(d, i) {
function d3_locale_numberFormat (line 27078) | function d3_locale_numberFormat(locale) {
function d3_format_typeDefault (line 27199) | function d3_format_typeDefault(x) {
function d3_date_utc (line 27203) | function d3_date_utc() {
function d3_time_interval (line 27269) | function d3_time_interval(local, step, number) {
function d3_time_interval_utc (line 27317) | function d3_time_interval_utc(method) {
function d3_locale_timeFormat (line 27377) | function d3_locale_timeFormat(locale) {
function d3_time_formatPad (line 27598) | function d3_time_formatPad(value, fill, width) {
function d3_time_formatRe (line 27602) | function d3_time_formatRe(names) {
function d3_time_formatLookup (line 27605) | function d3_time_formatLookup(names) {
function d3_time_parseWeekdayNumber (line 27610) | function d3_time_parseWeekdayNumber(date, string, i) {
function d3_time_parseWeekNumberSunday (line 27615) | function d3_time_parseWeekNumberSunday(date, string, i) {
function d3_time_parseWeekNumberMonday (line 27620) | function d3_time_parseWeekNumberMonday(date, string, i) {
function d3_time_parseFullYear (line 27625) | function d3_time_parseFullYear(date, string, i) {
function d3_time_parseYear (line 27630) | function d3_time_parseYear(date, string, i) {
function d3_time_parseZone (line 27635) | function d3_time_parseZone(date, string, i) {
function d3_time_expandYear (line 27639) | function d3_time_expandYear(d) {
function d3_time_parseMonthNumber (line 27642) | function d3_time_parseMonthNumber(date, string, i) {
function d3_time_parseDay (line 27647) | function d3_time_parseDay(date, string, i) {
function d3_time_parseDayOfYear (line 27652) | function d3_time_parseDayOfYear(date, string, i) {
function d3_time_parseHour24 (line 27657) | function d3_time_parseHour24(date, string, i) {
function d3_time_parseMinutes (line 27662) | function d3_time_parseMinutes(date, string, i) {
function d3_time_parseSeconds (line 27667) | function d3_time_parseSeconds(date, string, i) {
function d3_time_parseMilliseconds (line 27672) | function d3_time_parseMilliseconds(date, string, i) {
function d3_time_zone (line 27677) | function d3_time_zone(d) {
function d3_time_parseLiteralPercent (line 27681) | function d3_time_parseLiteralPercent(date, string, i) {
function d3_time_formatMulti (line 27686) | function d3_time_formatMulti(formats) {
function d3_adder (line 27717) | function d3_adder() {}
function d3_adderSum (line 27734) | function d3_adderSum(a, b, o) {
function d3_geo_streamGeometry (line 27745) | function d3_geo_streamGeometry(geometry, listener) {
function d3_geo_streamLine (line 27790) | function d3_geo_streamLine(coordinates, listener, closed) {
function d3_geo_streamPolygon (line 27796) | function d3_geo_streamPolygon(coordinates, listener) {
function d3_geo_areaRingStart (line 27825) | function d3_geo_areaRingStart() {
function d3_geo_cartesian (line 27843) | function d3_geo_cartesian(spherical) {
function d3_geo_cartesianDot (line 27847) | function d3_geo_cartesianDot(a, b) {
function d3_geo_cartesianCross (line 27850) | function d3_geo_cartesianCross(a, b) {
function d3_geo_cartesianAdd (line 27853) | function d3_geo_cartesianAdd(a, b) {
function d3_geo_cartesianScale (line 27858) | function d3_geo_cartesianScale(vector, k) {
function d3_geo_cartesianNormalize (line 27861) | function d3_geo_cartesianNormalize(d) {
function d3_geo_spherical (line 27867) | function d3_geo_spherical(cartesian) {
function d3_geo_sphericalEqual (line 27870) | function d3_geo_sphericalEqual(a, b) {
function point (line 27895) | function point(λ, φ) {
function linePoint (line 27900) | function linePoint(λ, φ) {
function lineStart (line 27940) | function lineStart() {
function lineEnd (line 27943) | function lineEnd() {
function ringPoint (line 27948) | function ringPoint(λ, φ) {
function ringStart (line 27956) | function ringStart() {
function ringEnd (line 27959) | function ringEnd() {
function angle (line 27966) | function angle(λ0, λ1) {
function compareRanges (line 27969) | function compareRanges(a, b) {
function withinRange (line 27972) | function withinRange(x, range) {
function d3_geo_centroidPoint (line 28026) | function d3_geo_centroidPoint(λ, φ) {
function d3_geo_centroidPointXYZ (line 28031) | function d3_geo_centroidPointXYZ(x, y, z) {
function d3_geo_centroidLineStart (line 28037) | function d3_geo_centroidLineStart() {
function d3_geo_centroidLineEnd (line 28058) | function d3_geo_centroidLineEnd() {
function d3_geo_centroidRingStart (line 28061) | function d3_geo_centroidRingStart() {
function d3_geo_compose (line 28091) | function d3_geo_compose(a, b) {
function d3_true (line 28100) | function d3_true() {
function d3_geo_clipPolygon (line 28103) | function d3_geo_clipPolygon(segments, compare, clipStartInside, interpol...
function d3_geo_clipPolygonLinkCircular (line 28162) | function d3_geo_clipPolygonLinkCircular(array) {
function d3_geo_clipPolygonIntersection (line 28173) | function d3_geo_clipPolygonIntersection(point, points, other, entry) {
function d3_geo_clip (line 28181) | function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) {
function d3_geo_clipSegmentLength1 (line 28273) | function d3_geo_clipSegmentLength1(segment) {
function d3_geo_clipBufferListener (line 28276) | function d3_geo_clipBufferListener() {
function d3_geo_clipSort (line 28297) | function d3_geo_clipSort(a, b) {
function d3_geo_clipAntimeridianLine (line 28301) | function d3_geo_clipAntimeridianLine(listener) {
function d3_geo_clipAntimeridianIntersect (line 28340) | function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) {
function d3_geo_clipAntimeridianInterpolate (line 28344) | function d3_geo_clipAntimeridianInterpolate(from, to, direction, listene...
function d3_geo_pointInPolygon (line 28367) | function d3_geo_pointInPolygon(point, polygon) {
function d3_geo_clipCircle (line 28396) | function d3_geo_clipCircle(radius) {
function d3_geom_clipLine (line 28492) | function d3_geom_clipLine(x0, y0, x1, y1) {
function d3_geo_clipExtent (line 28564) | function d3_geo_clipExtent(x0, y0, x1, y1) {
function d3_geo_conic (line 28698) | function d3_geo_conic(projectAt) {
function d3_geo_conicEqualArea (line 28706) | function d3_geo_conicEqualArea(φ0, φ1) {
function albersUsa (line 28733) | function albersUsa(coordinates) {
function d3_geo_pathAreaRingStart (line 28815) | function d3_geo_pathAreaRingStart() {
function d3_geo_pathBoundsPoint (line 28837) | function d3_geo_pathBoundsPoint(x, y) {
function d3_geo_pathBuffer (line 28843) | function d3_geo_pathBuffer() {
function d3_geo_pathBufferCircle (line 28888) | function d3_geo_pathBufferCircle(radius) {
function d3_geo_pathCentroidPoint (line 28904) | function d3_geo_pathCentroidPoint(x, y) {
function d3_geo_pathCentroidLineStart (line 28909) | function d3_geo_pathCentroidLineStart() {
function d3_geo_pathCentroidLineEnd (line 28923) | function d3_geo_pathCentroidLineEnd() {
function d3_geo_pathCentroidRingStart (line 28926) | function d3_geo_pathCentroidRingStart() {
function d3_geo_pathContext (line 28947) | function d3_geo_pathContext(context) {
function d3_geo_resample (line 28987) | function d3_geo_resample(project) {
function path (line 29067) | function path(object) {
function reset (line 29106) | function reset() {
function d3_geo_pathProjectStream (line 29112) | function d3_geo_pathProjectStream(project) {
function d3_geo_transform (line 29129) | function d3_geo_transform(stream) {
function d3_geo_transformPoint (line 29152) | function d3_geo_transformPoint(stream, point) {
function d3_geo_projection (line 29174) | function d3_geo_projection(project) {
function d3_geo_projectionMutator (line 29179) | function d3_geo_projectionMutator(projectAt) {
function d3_geo_projectionRadians (line 29251) | function d3_geo_projectionRadians(stream) {
function d3_geo_equirectangular (line 29256) | function d3_geo_equirectangular(λ, φ) {
function forward (line 29264) | function forward(coordinates) {
function d3_geo_identityRotation (line 29274) | function d3_geo_identityRotation(λ, φ) {
function d3_geo_rotation (line 29278) | function d3_geo_rotation(δλ, δφ, δγ) {
function d3_geo_forwardRotationλ (line 29281) | function d3_geo_forwardRotationλ(δλ) {
function d3_geo_rotationλ (line 29286) | function d3_geo_rotationλ(δλ) {
function d3_geo_rotationφγ (line 29291) | function d3_geo_rotationφγ(δφ, δγ) {
function circle (line 29305) | function circle() {
function d3_geo_circleInterpolate (line 29335) | function d3_geo_circleInterpolate(radius, precision) {
function d3_geo_circleAngle (line 29352) | function d3_geo_circleAngle(cr, point) {
function graticule (line 29365) | function graticule() {
function lines (line 29371) | function lines() {
function d3_geo_graticuleX (line 29437) | function d3_geo_graticuleX(y0, y1, dy) {
function d3_geo_graticuleY (line 29445) | function d3_geo_graticuleY(x0, x1, dx) {
function d3_source (line 29453) | function d3_source(d) {
function d3_target (line 29456) | function d3_target(d) {
function greatArc (line 29461) | function greatArc() {
function d3_geo_interpolate (line 29488) | function d3_geo_interpolate(x0, y0, x1, y1) {
function d3_geo_lengthLineStart (line 29513) | function d3_geo_lengthLineStart() {
function d3_geo_azimuthal (line 29528) | function d3_geo_azimuthal(scale, angle) {
function d3_geo_conicConformal (line 29554) | function d3_geo_conicConformal(φ0, φ1) {
function d3_geo_conicEquidistant (line 29577) | function d3_geo_conicEquidistant(φ0, φ1) {
function d3_geo_mercator (line 29599) | function d3_geo_mercator(λ, φ) {
function d3_geo_mercatorProjection (line 29605) | function d3_geo_mercatorProjection(project) {
function d3_geo_transverseMercator (line 29646) | function d3_geo_transverseMercator(λ, φ) {
function d3_geom_pointX (line 29664) | function d3_geom_pointX(d) {
function d3_geom_pointY (line 29667) | function d3_geom_pointY(d) {
function hull (line 29673) | function hull(data) {
function d3_geom_hullUpper (line 29695) | function d3_geom_hullUpper(points) {
function d3_geom_hullOrder (line 29703) | function d3_geom_hullOrder(a, b) {
function d3_geom_polygonInside (line 29757) | function d3_geom_polygonInside(p, a, b) {
function d3_geom_polygonIntersect (line 29760) | function d3_geom_polygonIntersect(c, d, a, b) {
function d3_geom_polygonClosed (line 29764) | function d3_geom_polygonClosed(coordinates) {
function d3_geom_voronoiBeach (line 29769) | function d3_geom_voronoiBeach() {
function d3_geom_voronoiCreateBeach (line 29773) | function d3_geom_voronoiCreateBeach(site) {
function d3_geom_voronoiDetachBeach (line 29778) | function d3_geom_voronoiDetachBeach(beach) {
function d3_geom_voronoiRemoveBeach (line 29784) | function d3_geom_voronoiRemoveBeach(beach) {
function d3_geom_voronoiAddBeach (line 29820) | function d3_geom_voronoiAddBeach(site) {
function d3_geom_voronoiLeftBreakPoint (line 29874) | function d3_geom_voronoiLeftBreakPoint(arc, directrix) {
function d3_geom_voronoiRightBreakPoint (line 29886) | function d3_geom_voronoiRightBreakPoint(arc, directrix) {
function d3_geom_voronoiCell (line 29892) | function d3_geom_voronoiCell(site) {
function d3_geom_voronoiCloseCells (line 29905) | function d3_geom_voronoiCloseCells(extent) {
function d3_geom_voronoiHalfEdgeOrder (line 29935) | function d3_geom_voronoiHalfEdgeOrder(a, b) {
function d3_geom_voronoiCircle (line 29938) | function d3_geom_voronoiCircle() {
function d3_geom_voronoiAttachCircle (line 29942) | function d3_geom_voronoiAttachCircle(arc) {
function d3_geom_voronoiDetachCircle (line 29975) | function d3_geom_voronoiDetachCircle(arc) {
function d3_geom_voronoiClipEdges (line 29985) | function d3_geom_voronoiClipEdges(extent) {
function d3_geom_voronoiConnectEdge (line 29995) | function d3_geom_voronoiConnectEdge(edge, extent) {
function d3_geom_voronoiEdge (line 30069) | function d3_geom_voronoiEdge(lSite, rSite) {
function d3_geom_voronoiCreateEdge (line 30074) | function d3_geom_voronoiCreateEdge(lSite, rSite, va, vb) {
function d3_geom_voronoiCreateBorderEdge (line 30083) | function d3_geom_voronoiCreateBorderEdge(lSite, va, vb) {
function d3_geom_voronoiSetEdgeEnd (line 30090) | function d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, vertex) {
function d3_geom_voronoiHalfEdge (line 30101) | function d3_geom_voronoiHalfEdge(edge, lSite, rSite) {
function d3_geom_voronoiRedBlackTree (line 30115) | function d3_geom_voronoiRedBlackTree() {
function d3_geom_voronoiRedBlackNode (line 30118) | function d3_geom_voronoiRedBlackNode(node) {
function d3_geom_voronoiRedBlackRotateLeft (line 30281) | function d3_geom_voronoiRedBlackRotateLeft(tree, node) {
function d3_geom_voronoiRedBlackRotateRight (line 30294) | function d3_geom_voronoiRedBlackRotateRight(tree, node) {
function d3_geom_voronoiRedBlackFirst (line 30307) | function d3_geom_voronoiRedBlackFirst(node) {
function d3_geom_voronoi (line 30311) | function d3_geom_voronoi(sites, bbox) {
function d3_geom_voronoiVertexOrder (line 30340) | function d3_geom_voronoiVertexOrder(a, b) {
function voronoi (line 30346) | function voronoi(data) {
function sites (line 30357) | function sites(data) {
function d3_geom_voronoiTriangleArea (line 30410) | function d3_geom_voronoiTriangleArea(a, b, c) {
function quadtree (line 30428) | function quadtree(data) {
function d3_geom_quadtreeCompatX (line 30523) | function d3_geom_quadtreeCompatX(d) {
function d3_geom_quadtreeCompatY (line 30526) | function d3_geom_quadtreeCompatY(d) {
function d3_geom_quadtreeNode (line 30529) | function d3_geom_quadtreeNode() {
function d3_geom_quadtreeVisit (line 30538) | function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) {
function d3_geom_quadtreeFind (line 30547) | function d3_geom_quadtreeFind(root, x, y, x0, y0, x3, y3) {
function d3_interpolateRgb (line 30584) | function d3_interpolateRgb(a, b) {
function d3_interpolateObject (line 30593) | function d3_interpolateObject(a, b) {
function d3_interpolateNumber (line 30613) | function d3_interpolateNumber(a, b) {
function d3_interpolateString (line 30620) | function d3_interpolateString(a, b) {
function d3_interpolate (line 30654) | function d3_interpolate(a, b) {
function d3_interpolateArray (line 30664) | function d3_interpolateArray(a, b) {
function d3_ease_clamp (line 30715) | function d3_ease_clamp(f) {
function d3_ease_reverse (line 30720) | function d3_ease_reverse(f) {
function d3_ease_reflect (line 30725) | function d3_ease_reflect(f) {
function d3_ease_quad (line 30730) | function d3_ease_quad(t) {
function d3_ease_cubic (line 30733) | function d3_ease_cubic(t) {
function d3_ease_cubicInOut (line 30736) | function d3_ease_cubicInOut(t) {
function d3_ease_poly (line 30742) | function d3_ease_poly(e) {
function d3_ease_sin (line 30747) | function d3_ease_sin(t) {
function d3_ease_exp (line 30750) | function d3_ease_exp(t) {
function d3_ease_circle (line 30753) | function d3_ease_circle(t) {
function d3_ease_elastic (line 30756) | function d3_ease_elastic(a, p) {
function d3_ease_back (line 30764) | function d3_ease_back(s) {
function d3_ease_bounce (line 30770) | function d3_ease_bounce(t) {
function d3_interpolateHcl (line 30774) | function d3_interpolateHcl(a, b) {
function d3_interpolateHsl (line 30785) | function d3_interpolateHsl(a, b) {
function d3_interpolateLab (line 30796) | function d3_interpolateLab(a, b) {
function d3_interpolateRound (line 30805) | function d3_interpolateRound(a, b) {
function d3_transform (line 30821) | function d3_transform(m) {
function d3_transformDot (line 30837) | function d3_transformDot(a, b) {
function d3_transformNormalize (line 30840) | function d3_transformNormalize(a) {
function d3_transformCombine (line 30848) | function d3_transformCombine(a, b, k) {
function d3_interpolateTransformPop (line 30862) | function d3_interpolateTransformPop(s) {
function d3_interpolateTranslate (line 30865) | function d3_interpolateTranslate(ta, tb, s, q) {
function d3_interpolateRotate (line 30879) | function d3_interpolateRotate(ra, rb, s, q) {
function d3_interpolateSkew (line 30890) | function d3_interpolateSkew(wa, wb, s, q) {
function d3_interpolateScale (line 30900) | function d3_interpolateScale(ka, kb, s, q) {
function d3_interpolateTransform (line 30914) | function d3_interpolateTransform(a, b) {
function d3_uninterpolateNumber (line 30928) | function d3_uninterpolateNumber(a, b) {
function d3_uninterpolateClamp (line 30934) | function d3_uninterpolateClamp(a, b) {
function d3_layout_bundlePath (line 30948) | function d3_layout_bundlePath(link) {
function d3_layout_bundleAncestors (line 30961) | function d3_layout_bundleAncestors(node) {
function d3_layout_bundleLeastCommonAncestor (line 30971) | function d3_layout_bundleLeastCommonAncestor(a, b) {
function relayout (line 30983) | function relayout() {
function resort (line 31049) | function resort() {
function repulse (line 31096) | function repulse(node) {
function position (line 31277) | function position(dimension, size) {
function dragmove (line 31306) | function dragmove(d) {
function d3_layout_forceDragstart (line 31312) | function d3_layout_forceDragstart(d) {
function d3_layout_forceDragend (line 31315) | function d3_layout_forceDragend(d) {
function d3_layout_forceMouseover (line 31318) | function d3_layout_forceMouseover(d) {
function d3_layout_forceMouseout (line 31322) | function d3_layout_forceMouseout(d) {
function d3_layout_forceAccumulate (line 31325) | function d3_layout_forceAccumulate(quad, alpha, charges) {
function hierarchy (line 31355) | function hierarchy(root) {
function d3_layout_hierarchyRebind (line 31411) | function d3_layout_hierarchyRebind(object, hierarchy) {
function d3_layout_hierarchyVisitBefore (line 31417) | function d3_layout_hierarchyVisitBefore(node, callback) {
function d3_layout_hierarchyVisitAfter (line 31427) | function d3_layout_hierarchyVisitAfter(node, callback) {
function d3_layout_hierarchyChildren (line 31440) | function d3_layout_hierarchyChildren(d) {
function d3_layout_hierarchyValue (line 31443) | function d3_layout_hierarchyValue(d) {
function d3_layout_hierarchySort (line 31446) | function d3_layout_hierarchySort(a, b) {
function d3_layout_hierarchyLinks (line 31449) | function d3_layout_hierarchyLinks(nodes) {
function position (line 31461) | function position(node, x, dx, dy) {
function depth (line 31476) | function depth(node) {
function partition (line 31484) | function partition(d, i) {
function pie (line 31498) | function pie(data) {
function stack (line 31548) | function stack(data, index) {
function d3_layout_stackX (line 31603) | function d3_layout_stackX(d) {
function d3_layout_stackY (line 31606) | function d3_layout_stackY(d) {
function d3_layout_stackOut (line 31609) | function d3_layout_stackOut(d, y0, y) {
function d3_layout_stackOrderDefault (line 31676) | function d3_layout_stackOrderDefault(data) {
function d3_layout_stackOffsetZero (line 31679) | function d3_layout_stackOffsetZero(data) {
function d3_layout_stackMaxIndex (line 31684) | function d3_layout_stackMaxIndex(array) {
function d3_layout_stackReduceSum (line 31694) | function d3_layout_stackReduceSum(d) {
function d3_layout_stackSum (line 31697) | function d3_layout_stackSum(p, d) {
function histogram (line 31702) | function histogram(data, i) {
function d3_layout_histogramBinSturges (line 31746) | function d3_layout_histogramBinSturges(range, values) {
function d3_layout_histogramBinFixed (line 31749) | function d3_layout_histogramBinFixed(range, n) {
function d3_layout_histogramRange (line 31754) | function d3_layout_histogramRange(values) {
function pack (line 31759) | function pack(d, i) {
function d3_layout_packSort (line 31798) | function d3_layout_packSort(a, b) {
function d3_layout_packInsert (line 31801) | function d3_layout_packInsert(a, b) {
function d3_layout_packSplice (line 31808) | function d3_layout_packSplice(a, b) {
function d3_layout_packIntersects (line 31812) | function d3_layout_packIntersects(a, b) {
function d3_layout_packSiblings (line 31816) | function d3_layout_packSiblings(node) {
function d3_layout_packLink (line 31880) | function d3_layout_packLink(node) {
function d3_layout_packUnlink (line 31883) | function d3_layout_packUnlink(node) {
function d3_layout_packTransform (line 31887) | function d3_layout_packTransform(node, x, y, k) {
function d3_layout_packPlace (line 31897) | function d3_layout_packPlace(a, b, c) {
function tree (line 31913) | function tree(d, i) {
function wrapTree (line 31932) | function wrapTree(root0) {
function firstWalk (line 31956) | function firstWalk(v) {
function secondWalk (line 31972) | function secondWalk(v) {
function apportion (line 31976) | function apportion(v, w, ancestor) {
function sizeNode (line 32006) | function sizeNode(node) {
function d3_layout_treeSeparation (line 32027) | function d3_layout_treeSeparation(a, b) {
function d3_layout_treeLeft (line 32030) | function d3_layout_treeLeft(v) {
function d3_layout_treeRight (line 32034) | function d3_layout_treeRight(v) {
function d3_layout_treeMove (line 32038) | function d3_layout_treeMove(wm, wp, shift) {
function d3_layout_treeShift (line 32046) | function d3_layout_treeShift(v) {
function d3_layout_treeAncestor (line 32055) | function d3_layout_treeAncestor(vim, v, ancestor) {
function cluster (line 32060) | function cluster(d, i) {
function d3_layout_clusterY (line 32100) | function d3_layout_clusterY(children) {
function d3_layout_clusterX (line 32105) | function d3_layout_clusterX(children) {
function d3_layout_clusterLeft (line 32110) | function d3_layout_clusterLeft(node) {
function d3_layout_clusterRight (line 32114) | function d3_layout_clusterRight(node) {
function scale (line 32120) | function scale(children, k) {
function squarify (line 32127) | function squarify(node) {
function stickify (line 32154) | function stickify(node) {
function worst (line 32171) | function worst(row, u) {
function position (line 32182) | function position(row, u, rect, flush) {
function treemap (line 32212) | function treemap(d) {
function padFunction (line 32229) | function padFunction(node) {
function padConstant (line 32233) | function padConstant(node) {
function d3_layout_treemapPadNull (line 32264) | function d3_layout_treemapPadNull(node) {
function d3_layout_treemapPad (line 32272) | function d3_layout_treemapPad(node, padding) {
function d3_scaleExtent (line 32324) | function d3_scaleExtent(domain) {
function d3_scaleRange (line 32328) | function d3_scaleRange(scale) {
function d3_scale_bilinear (line 32331) | function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
function d3_scale_nice (line 32337) | function d3_scale_nice(domain, nice) {
function d3_scale_niceStep (line 32347) | function d3_scale_niceStep(step) {
function d3_scale_polylinear (line 32361) | function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
function d3_scale_linear (line 32379) | function d3_scale_linear(domain, range, interpolate, clamp) {
function d3_scale_linearRebind (line 32431) | function d3_scale_linearRebind(scale, linear) {
function d3_scale_linearNice (line 32434) | function d3_scale_linearNice(domain, m) {
function d3_scale_linearTickRange (line 32439) | function d3_scale_linearTickRange(domain, m) {
function d3_scale_linearTicks (line 32448) | function d3_scale_linearTicks(domain, m) {
function d3_scale_linearTickFormat (line 32451) | function d3_scale_linearTickFormat(domain, m, format) {
function d3_scale_linearPrecision (line 32479) | function d3_scale_linearPrecision(value) {
function d3_scale_linearFormatPrecision (line 32482) | function d3_scale_linearFormatPrecision(type, range) {
function d3_scale_log (line 32489) | function d3_scale_log(linear, base, positive, domain) {
function d3_scale_pow (line 32562) | function d3_scale_pow(linear, exponent, domain) {
function d3_scale_powPow (line 32596) | function d3_scale_powPow(e) {
function d3_scale_ordinal (line 32610) | function d3_scale_ordinal(domain, ranger) {
function d3_scale_quantile (line 32718) | function d3_scale_quantile(domain, range) {
function d3_scale_quantize (line 32754) | function d3_scale_quantize(x0, x1, range) {
function d3_scale_threshold (line 32788) | function d3_scale_threshold(domain, range) {
function d3_scale_identity (line 32814) | function d3_scale_identity(domain) {
function d3_zero (line 32836) | function d3_zero() {
function arc (line 32841) | function arc() {
function circleSegment (line 32919) | function circleSegment(r1, cw) {
function d3_svg_arcInnerRadius (line 32964) | function d3_svg_arcInnerRadius(d) {
function d3_svg_arcOuterRadius (line 32967) | function d3_svg_arcOuterRadius(d) {
function d3_svg_arcStartAngle (line 32970) | function d3_svg_arcStartAngle(d) {
function d3_svg_arcEndAngle (line 32973) | function d3_svg_arcEndAngle(d) {
function d3_svg_arcPadAngle (line 32976) | function d3_svg_arcPadAngle(d) {
function d3_svg_arcSweep (line 32979) | function d3_svg_arcSweep(x0, y0, x1, y1) {
function d3_svg_arcCornerTangents (line 32982) | function d3_svg_arcCornerTangents(p0, p1, r1, rc, cw) {
function d3_svg_line (line 32987) | function d3_svg_line(projection) {
function d3_svg_lineLinear (line 33054) | function d3_svg_lineLinear(points) {
function d3_svg_lineLinearClosed (line 33057) | function d3_svg_lineLinearClosed(points) {
function d3_svg_lineStep (line 33060) | function d3_svg_lineStep(points) {
function d3_svg_lineStepBefore (line 33066) | function d3_svg_lineStepBefore(points) {
function d3_svg_lineStepAfter (line 33071) | function d3_svg_lineStepAfter(points) {
function d3_svg_lineCardinalOpen (line 33076) | function d3_svg_lineCardinalOpen(points, tension) {
function d3_svg_lineCardinalClosed (line 33079) | function d3_svg_lineCardinalClosed(points, tension) {
function d3_svg_lineCardinal (line 33083) | function d3_svg_lineCardinal(points, tension) {
function d3_svg_lineHermite (line 33086) | function d3_svg_lineHermite(points, tangents) {
function d3_svg_lineCardinalTangents (line 33113) | function d3_svg_lineCardinalTangents(points, tension) {
function d3_svg_lineBasis (line 33123) | function d3_svg_lineBasis(points) {
function d3_svg_lineBasisOpen (line 33139) | function d3_svg_lineBasisOpen(points) {
function d3_svg_lineBasisClosed (line 33159) | function d3_svg_lineBasisClosed(points) {
function d3_svg_lineBundle (line 33178) | function d3_svg_lineBundle(points, tension) {
function d3_svg_lineDot4 (line 33191) | function d3_svg_lineDot4(a, b) {
function d3_svg_lineBasisBezier (line 33195) | function d3_svg_lineBasisBezier(path, x, y) {
function d3_svg_lineSlope (line 33198) | function d3_svg_lineSlope(p0, p1) {
function d3_svg_lineFiniteDifferences (line 33201) | function d3_svg_lineFiniteDifferences(points) {
function d3_svg_lineMonotoneTangents (line 33209) | function d3_svg_lineMonotoneTangents(points) {
function d3_svg_lineMonotone (line 33233) | function d3_svg_lineMonotone(points) {
function d3_svg_lineRadial (line 33242) | function d3_svg_lineRadial(points) {
function d3_svg_area (line 33253) | function d3_svg_area(projection) {
function chord (line 33343) | function chord(d, i) {
function subgroup (line 33347) | function subgroup(self, f, d, i) {
function equals (line 33357) | function equals(a, b) {
function arc (line 33360) | function arc(r, p, a) {
function curve (line 33363) | function curve(r0, p0, r1, p1) {
function d3_svg_chordRadius (line 33393) | function d3_svg_chordRadius(d) {
function diagonal (line 33398) | function diagonal(d, i) {
function d3_svg_diagonalProjection (line 33426) | function d3_svg_diagonalProjection(d) {
function d3_svg_diagonalRadialProjection (line 33436) | function d3_svg_diagonalRadialProjection(projection) {
function symbol (line 33444) | function symbol(d, i) {
function d3_svg_symbolSize (line 33459) | function d3_svg_symbolSize() {
function d3_svg_symbolType (line 33462) | function d3_svg_symbolType() {
function d3_svg_symbolCircle (line 33465) | function d3_svg_symbolCircle(size) {
function d3_selection_interruptNS (line 33514) | function d3_selection_interruptNS(ns) {
function d3_transition (line 33526) | function d3_transition(groups, ns, id) {
function d3_transition_tween (line 33598) | function d3_transition_tween(groups, name, value, tween) {
function attrNull (line 33612) | function attrNull() {
function attrNullNS (line 33615) | function attrNullNS() {
function attrTween (line 33618) | function attrTween(b) {
function attrTweenNS (line 33626) | function attrTweenNS(b) {
function attrTween (line 33638) | function attrTween(d, i) {
function attrTweenNS (line 33644) | function attrTweenNS(d, i) {
function styleNull (line 33662) | function styleNull() {
function styleString (line 33665) | function styleString(b) {
function styleTween (line 33677) | function styleTween(d, i) {
function d3_transition_text (line 33688) | function d3_transition_text(b) {
function d3_transitionNamespace (line 33768) | function d3_transitionNamespace(name) {
function d3_transitionNode (line 33771) | function d3_transitionNode(node, i, ns, id, inherit) {
function axis (line 33848) | function axis(g) {
function d3_svg_axisX (line 33943) | function d3_svg_axisX(selection, x0, x1) {
function d3_svg_axisY (line 33949) | function d3_svg_axisY(selection, y0, y1) {
function brush (line 33957) | function brush(g) {
function redraw (line 34043) | function redraw(g) {
function redrawX (line 34048) | function redrawX(g) {
function redrawY (line 34052) | function redrawY(g) {
function brushstart (line 34056) | function brushstart() {
function d3_time_formatIsoNative (line 34249) | function d3_time_formatIsoNative(date) {
function d3_time_scale (line 34296) | function d3_time_scale(linear, methods, format) {
function d3_time_scaleDate (line 34346) | function d3_time_scaleDate(t) {
function d3_json (line 34405) | function d3_json(request) {
function d3_html (line 34411) | function d3_html(request) {
function LiftedPoint (line 34436) | function LiftedPoint(p, i) {
function compareLifted (line 34441) | function compareLifted(a, b) {
function triangulate1D (line 34454) | function triangulate1D(n, points, includePointAtInfinity) {
function triangulate (line 34482) | function triangulate(points, includePointAtInfinity) {
function kerning (line 34603) | function kerning (family, o) {
function createPairs (line 34642) | function createPairs (range) {
function toDoubleLE (line 34672) | function toDoubleLE(lo, hi) {
function lowUintLE (line 34678) | function lowUintLE(n) {
function highUintLE (line 34683) | function highUintLE(n) {
function toDoubleBE (line 34694) | function toDoubleBE(lo, hi) {
function lowUintBE (line 34700) | function lowUintBE(n) {
function highUintBE (line 34705) | function highUintBE(n) {
function toDouble (line 34720) | function toDouble(lo, hi) {
function lowUint (line 34726) | function lowUint(n) {
function highUint (line 34731) | function highUint(n) {
function dupe_array (line 34817) | function dupe_array(count, value, i) {
function dupe_number (line 34835) | function dupe_number(count, value) {
function dupe (line 34844) | function dupe(count, value) {
function edgeToAdjacency (line 34871) | function edgeToAdjacency(edges, numVertices) {
function unblock (line 34910) | function unblock(u) {
function circuit (line 34920) | function circuit(v) {
function output (line 34959) | function output(start, stack) {
function subgraph (line 34964) | function subgraph(minId) {
function adjacencyStructureSCC (line 34974) | function adjacencyStructureSCC(from) {
function objectOrFunction (line 36007) | function objectOrFunction(x) {
function isFunction (line 36011) | function isFunction(x) {
function setScheduler (line 36046) | function setScheduler(scheduleFn) {
function setAsap (line 36050) | function setAsap(asapFn) {
function useNextTick (line 36063) | function useNextTick() {
function useVertxTimer (line 36072) | function useVertxTimer() {
function useMutationObserver (line 36078) | function useMutationObserver() {
function useMessageChannel (line 36090) | function useMessageChannel() {
function useSetTimeout (line 36098) | function useSetTimeout() {
function flush (line 36108) | function flush() {
function attemptVertx (line 36122) | function attemptVertx() {
function then (line 36147) | function then(onFulfillment, onRejection) {
function resolve (line 36205) | function resolve(object) {
function noop (line 36220) | function noop() {}
function selfFulfillment (line 36228) | function selfFulfillment() {
function cannotReturnOwn (line 36232) | function cannotReturnOwn() {
function getThen (line 36236) | function getThen(promise) {
function tryThen (line 36245) | function tryThen(then, value, fulfillmentHandler, rejectionHandler) {
function handleForeignThenable (line 36253) | function handleForeignThenable(promise, thenable, then) {
function handleOwnThenable (line 36282) | function handleOwnThenable(promise, thenable) {
function handleMaybeThenable (line 36296) | function handleMaybeThenable(promise, maybeThenable, then$$) {
function _resolve (line 36312) | function _resolve(promise, value) {
function publishRejection (line 36322) | function publishRejection(promise) {
function fulfill (line 36330) | function fulfill(promise, value) {
function _reject (line 36343) | function _reject(promise, reason) {
function subscribe (line 36353) | function subscribe(parent, child, onFulfillment, onRejection) {
function publish (line 36368) | function publish(promise) {
function ErrorObject (line 36394) | function ErrorObject() {
function tryCatch (line 36400) | function tryCatch(callback, detail) {
function invokeCallback (line 36409) | function invokeCallback(settled, promise, callback, detail) {
function initializePromise (line 36449) | function initializePromise(promise, resolver) {
function nextId (line 36462) | function nextId() {
function makePromise (line 36466) | function makePromise(promise) {
function Enumerator (line 36473) | function Enumerator(Constructor, input) {
function validationError (line 36502) | function validationError() {
function all (line 36616) | function all(entries) {
function race (line 36685) | function race(entries) {
function reject (line 36737) | function reject(reason) {
function needsResolver (line 36745) | function needsResolver() {
function needsNew (line 36749) | function needsNew() {
function Promise (line 36856) | function Promise(resolver) {
function polyfill (line 37105) | function polyfill() {
function extractPlanes (line 37318) | function extractPlanes(M, zNear, zFar) {
function clamp (line 37364) | function clamp(lo, hi, x) {
function FilteredVector (line 37368) | function FilteredVector(state0, velocity0, t0) {
function getZero (line 37615) | function getZero(d) {
function createFilteredVector (line 37623) | function createFilteredVector(initState, initVelocity, initTime) {
function flattenVertexData (line 37655) | function flattenVertexData (data, output, offset) {
function atlas (line 37717) | function atlas(options) {
function measure (line 37776) | function measure (font, o) {
function applyOrigin (line 37925) | function applyOrigin(obj, origin) {
function firstTop (line 37935) | function firstTop(iData) {
function firstBottom (line 37945) | function firstBottom(iData) {
function RBNode (line 37963) | function RBNode(color, key, value, left, right, count) {
function cloneNode (line 37972) | function cloneNode(node) {
function repaint (line 37976) | function repaint(color, node) {
function recount (line 37980) | function recount(node) {
function RedBlackTree (line 37984) | function RedBlackTree(compare, root) {
function doVisitFull (line 38188) | function doVisitFull(visit, node) {
function doVisitHalf (line 38201) | function doVisitHalf(lo, compare, visit, node) {
function doVisit (line 38217) | function doVisit(lo, hi, compare, visit, node) {
function RedBlackTreeIterator (line 38449) | function RedBlackTreeIterator(tree, stack) {
function swapNode (line 38480) | function swapNode(n, v) {
function fixDoubleBlack (line 38490) | function fixDoubleBlack(stack) {
function defaultCompare (line 38938) | function defaultCompare(a, b) {
function createRBTree (line 38949) | function createRBTree(compare) {
function lngamma (line 38989) | function lngamma(z) {
function getCanvasContext (line 39023) | function getCanvasContext (type, opts) {
function copyVec3 (line 39078) | function copyVec3(a, b) {
function Axes (line 39085) | function Axes(gl) {
function parseOption (line 39154) | function parseOption(nest, cons, name) {
function OffsetInfo (line 39321) | function OffsetInfo() {
function computeLineOffset (line 39330) | function computeLineOffset(result, i, bounds, cubeEdges, cubeAxis) {
function alignTo (line 39540) | function alignTo(i) {
function solveTickAlignments (line 39545) | function solveTickAlignments(i, minor, major) {
function createAxes (line 39663) | function createAxes(gl, options) {
function BackgroundCube (line 39678) | function BackgroundCube(gl, buffer, vao, shader) {
function createBackgroundCube (line 39723) | function createBackgroundCube(gl) {
function transformHg (line 39806) | function transformHg(result, x, mat) {
function polygonArea (line 39824) | function polygonArea(p) {
function getCubeEdges (line 39864) | function getCubeEdges(model, view, projection, bounds, ortho) {
function zeroVec (line 40039) | function zeroVec(a) {
function copyVec (line 40044) | function copyVec(a,b) {
function Lines (line 40051) | function Lines(gl, vertBuffer, vao, shader, tickCount, tickOffset, gridC...
function createLines (line 40179) | function createLines(gl, bounds, ticks) {
function TextSprites (line 40287) | function TextSprites(
function addItem (line 40326) | function addItem(t, text, font, size, lineSpacing, styletags) {
function tryVectorizeText (line 40445) | function tryVectorizeText(text, options) {
function createTextSprites (line 40457) | function createTextSprites(
function prettyPrint (line 40493) | function prettyPrint(spacing, i) {
function defaultTicks (line 40529) | function defaultTicks(bounds, tickSpacing) {
function ticksEqual (line 40545) | function ticksEqual(ticksA, ticksB) {
function AxesRange3D (line 40589) | function AxesRange3D(lo, hi, pixelsPerDataUnit) {
function gradient (line 40598) | function gradient(result, M, v, width, height) {
function axesProperties (line 40635) | function axesProperties(axes, camera, width, height, params) {
function GLBuffer (line 40729) | function GLBuffer(gl, type, handle, length, usage) {
function updateTypeArray (line 40751) | function updateTypeArray(gl, type, len, usage, data, offset) {
function makeScratchTypeArray (line 40764) | function makeScratchTypeArray(array, dtype) {
function isPacked (line 40773) | function isPacked(shape, stride) {
function createBuffer (line 40849) | function createBuffer(gl, data, type, usage) {
function SimplicialMesh (line 41165) | function SimplicialMesh(gl
function genColormap (line 41276) | function genColormap(param) {
function unpackIntensity (line 41295) | function unpackIntensity(cells, numVerts, cellIntensity) {
function takeZComponent (line 41310) | function takeZComponent(array) {
function createMeshShader (line 41925) | function createMeshShader(gl) {
function createPickShader (line 41937) | function createPickShader(gl) {
function createSimplicialMesh (line 41947) | function createSimplicialMesh(gl, params) {
function ErrorBars (line 42438) | function ErrorBars(gl, buffer, vao, shader) {
function updateBounds (line 42496) | function updateBounds(bounds, point) {
function emitFace (line 42521) | function emitFace(verts, x, c, d) {
function createErrorBars (line 42638) | function createErrorBars(options) {
function saveFBOState (line 42705) | function saveFBOState(gl) {
function restoreFBOState (line 42712) | function restoreFBOState(gl, data) {
function lazyInitColorAttachments (line 42718) | function lazyInitColorAttachments(gl, ext) {
function throwFBOError (line 42734) | function throwFBOError(status) {
function initTexture (line 42750) | function initTexture(gl, width, height, type, format, attachment) {
function initRenderBuffer (line 42764) | function initRenderBuffer(gl, width, height, component, attachment) {
function rebuildFBO (line 42773) | function rebuildFBO(fbo) {
function Framebuffer (line 42866) | function Framebuffer(gl, width, height, colorType, numColors, useDepth, ...
function reshapeFBO (line 42917) | function reshapeFBO(fbo, w, h) {
function createFBO (line 43069) | function createFBO(gl, width, height, options) {
function formatCompilerError (line 43168) | function formatCompilerError(errLog, src, type) {
function GLHeatmap2D (line 43227) | function GLHeatmap2D (
function createHeatmap2D (line 43506) | function createHeatmap2D (plot, options) {
function distance (line 43591) | function distance (a, b) {
function filterClipBounds (line 43600) | function filterClipBounds (bounds) {
function PickResult (line 43609) | function PickResult (tau, position, index, dataCoordinate) {
function LinePlot (line 43616) | function LinePlot (gl, shader, pickShader, buffer, vao, texture) {
function createLinePlot (line 43896) | function createLinePlot (options) {
function invert (line 43973) | function invert(out, a) {
function invert (line 44002) | function invert(out, a) {
function clone (line 44039) | function clone(a) {
function create (line 44067) | function create() {
function determinant (line 44096) | function determinant(a) {
function fromQuat (line 44128) | function fromQuat(out, q) {
function fromRotationTranslation (line 44184) | function fromRotationTranslation(out, q, v) {
function identity (line 44229) | function identity(out) {
function invert (line 44258) | function invert(out, a) {
function lookAt (line 44318) | function lookAt(out, eye, center, up) {
function multiply (line 44406) | function multiply(out, a, b) {
function ortho (line 44453) | function ortho(out, left, right, bottom, top, near, far) {
function perspective (line 44488) | function perspective(out, fovy, aspect, near, far) {
function rotate (line 44521) | function rotate(out, a, rad, axis) {
function rotateX (line 44585) | function rotateX(out, a, rad) {
function rotateY (line 44630) | function rotateY(out, a, rad) {
function rotateZ (line 44675) | function rotateZ(out, a, rad) {
function scale (line 44720) | function scale(out, a, v) {
function translate (line 44752) | function translate(out, a, v) {
function transpose (line 44790) | function transpose(out, a) {
function invert (line 44839) | function invert(out, M) {
function xformMatrix (line 44869) | function xformMatrix(m, v) {
function projectVertex (line 44879) | function projectVertex(v, model, view, projection, resolution) {
function barycentricCoord (line 44889) | function barycentricCoord(simplex, point) {
function interpolate (line 44911) | function interpolate(simplex, weights) {
function closestPointToPickLocation (line 44923) | function closestPointToPickLocation(simplex, pixelCoord, model, view, pr...
function SimplicialMesh (line 45062) | function SimplicialMesh(gl
function getOpacityFromScale (line 45177) | function getOpacityFromScale(ratio, opacityscale) {
function genColormap (line 45194) | function genColormap(param, opacityscale) {
function unpackIntensity (line 45217) | function unpackIntensity(cells, numVerts, cellIntensity) {
function takeZComponent (line 45232) | function takeZComponent(array) {
function createMeshShader (line 45924) | function createMeshShader(gl) {
function createWireShader (line 45933) | function createWireShader(gl) {
function createPointShader (line 45941) | function createPointShader(gl) {
function createPickShader (line 45950) | function createPickShader(gl) {
function createPointPickShader (line 45957) | function createPointPickShader(gl) {
function createContourShader (line 45965) | function createContourShader(gl) {
function createSimplicialMesh (line 45971) | function createSimplicialMesh(gl, params) {
function Boxes (line 46129) | function Boxes(plot, vbo, shader) {
function createBoxes (line 46171) | function createBoxes(plot) {
function Grid (line 46192) | function Grid(plot, vbo, shader, tickShader) {
function compareTickNum (line 46200) | function compareTickNum(a, b) {
function createGrid (line 46420) | function createGrid(plot) {
function Lines (line 46439) | function Lines(plot, vbo, shader) {
function createLines (line 46482) | function createLines(plot) {
function TextElements (line 46523) | function TextElements(plot, vbo, shader) {
function createTextElements (line 46782) | function createTextElements(plot) {
function GLPlot2D (line 46804) | function GLPlot2D(gl, pickBuffer) {
function lerp (line 46897) | function lerp(a, b, t) {
function deepClone (line 47140) | function deepClone(array) {
function compareTicks (line 47148) | function compareTicks(a, b) {
function createGLPlot2D (line 47362) | function createGLPlot2D(options) {
function createCamera (line 47387) | function createCamera(element, options) {
function MouseSelect (line 47695) | function MouseSelect() {
function getContext (line 47706) | function getContext(canvas, options) {
function roundUpPow10 (line 47719) | function roundUpPow10(x) {
function defaultBool (line 47731) | function defaultBool(x) {
function createScene (line 47738) | function createScene(options) {
function Pointcloud2D (line 48506) | function Pointcloud2D(plot, offsetBuffer, pickBuffer, shader, pickShader) {
function dflt (line 48540) | function dflt(opt, value) {
function count (line 48595) | function count(points, dataBox) {
function createPointcloud2D (line 48698) | function createPointcloud2D(plot, options) {
function slerp (line 48726) | function slerp (out, a, b, t) {
function getGlyph (line 48783) | function getGlyph(symbol, font, pixelRatio) {
function createShader (line 48891) | function createShader(gl, src) {
function transformMat4 (line 48939) | function transformMat4(x, m) {
function project (line 48951) | function project(p, v, m, x) {
function ScatterPlotPickResult (line 48957) | function ScatterPlotPickResult(index, position) {
function fixOpacity (line 48962) | function fixOpacity(a) {
function PointCloud (line 48968) | function PointCloud(
function zeroVec (line 49073) | function zeroVec(a) {
function augment (line 49078) | function augment(hg, af) {
function setComponent (line 49086) | function setComponent(out, v, i, x) {
function getClipBounds (line 49094) | function getClipBounds(bounds) {
function drawProject (line 49104) | function drawProject(shader, points, camera, pixelRatio) {
function drawFull (line 49223) | function drawFull(shader, pshader, points, camera, pixelRatio, transpare...
function get_glyphData (line 49320) | function get_glyphData(glyphs, index, font, pixelRatio) {
function createPointCloud (line 49735) | function createPointCloud(options) {
function SelectBox (line 49810) | function SelectBox(plot, boxBuffer, boxShader) {
function createSelectBox (line 49912) | function createSelectBox(plot, options) {
function SelectResult (line 49939) | function SelectResult(x, y, id, value, distance) {
function SelectBuffer (line 49946) | function SelectBuffer(gl, fbo, buffer) {
function createSelectBuffer (line 50075) | function createSelectBuffer(gl, shape) {
function Shader (line 50092) | function Shader(gl) {
function compareAttributes (line 50162) | function compareAttributes(a, b) {
function relink (line 50284) | function relink() {
function createShader (line 50327) | function createShader(
function GLError (line 50348) | function GLError (rawError, shortMessage, longMessage) {
function ShaderAttribute (line 50369) | function ShaderAttribute(
function addVectorAttribute (line 50424) | function addVectorAttribute(
function addMatrixAttribute (line 50472) | function addMatrixAttribute(
function createAttributeWrapper (line 50563) | function createAttributeWrapper(
function identity (line 50636) | function identity(x) {
function makeVector (line 50641) | function makeVector(length, fill) {
function createUniformWrapper (line 50650) | function createUniformWrapper(gl, wrapper, uniforms, locations) {
function makeReflectTypes (line 50830) | function makeReflectTypes(uniforms, useIndex) {
function getType (line 50906) | function getType(gl, type) {
function runtimeUniforms (line 50918) | function runtimeUniforms(gl, program) {
function runtimeAttributes (line 50943) | function runtimeAttributes(gl, program) {
function ShaderReference (line 50972) | function ShaderReference(id, src, type, shader, programs, count, cache) {
function ContextCache (line 51003) | function ContextCache(gl) {
function compileShader (line 51011) | function compileShader(gl, type, src) {
function linkProgram (line 51048) | function linkProgram(gl, vshader, fshader, attribs, locations) {
function getCache (line 51079) | function getCache(gl) {
function getShaderReference (line 51088) | function getShaderReference(gl, type, src) {
function createProgram (line 51092) | function createProgram(gl, vref, fref, attribs, locations) {
function GLSpikes2D (line 51101) | function GLSpikes2D(plot) {
function createSpikes2D (line 51177) | function createSpikes2D(plot, options) {
function AxisSpikes (line 51215) | function AxisSpikes(gl, buffer, vao, shader) {
function createSpikes (line 51327) | function createSpikes(gl, options) {
function SimplicialMesh (line 51454) | function SimplicialMesh(gl
function genColormap (line 51563) | function genColormap(param) {
function unpackIntensity (line 51582) | function unpackIntensity(cells, numVerts, cellIntensity) {
function takeZComponent (line 51597) | function takeZComponent(array) {
function createMeshShader (line 52210) | function createMeshShader(gl) {
function createPickShader (line 52220) | function createPickShader(gl) {
function createSimplicialMesh (line 52229) | function createSimplicialMesh(gl, params) {
function SurfacePickResult (line 52970) | function SurfacePickResult (position, index, uv, level, dataCoordinate) {
function genColormap (line 52980) | function genColormap (name) {
function SurfacePlot (line 52992) | function SurfacePlot (
function computeProjectionData (line 53125) | function computeProjectionData (camera, obj) {
function drawCore (line 53199) | function drawCore (params, transparent) {
function handleArray (line 53604) | function handleArray (param, ctor) {
function toColor (line 53611) | function toColor (x) {
function handleColor (line 53621) | function handleColor (param) {
function createSurfacePlot (line 54189) | function createSurfacePlot (params) {
function isRegl (line 54992) | function isRegl (o) {
function lazyInitLinearTypes (line 55122) | function lazyInitLinearTypes(gl) {
function acceptTextureDOM (line 55144) | function acceptTextureDOM (obj) {
function reshapeTexture (line 55156) | function reshapeTexture(tex, w, h) {
function Texture2D (line 55169) | function Texture2D(gl, handle, width, height, format, type) {
function isPacked (line 55439) | function isPacked(shape, stride) {
function texSubImageArray (line 55449) | function texSubImageArray(gl, x_off, y_off, mip_level, cformat, ctype, m...
function initTexture (line 55546) | function initTexture(gl) {
function createTextureShape (line 55556) | function createTextureShape(gl, width, height, format, type) {
function createTextureDOM (line 55569) | function createTextureDOM(gl, directData, width, height, format, type) {
function createTextureArray (line 55576) | function createTextureArray(gl, array) {
function createTexture2D (line 55647) | function createTexture2D(gl) {
function resize (line 55763) | function resize (o) {
function isCanvas (line 55777) | function isCanvas (e) {
function isElement (line 55783) | function isElement (e) {
function isContext (line 55789) | function isContext (e) {
function createCanvas (line 55794) | function createCanvas () {
function doBind (line 55807) | function doBind(gl, elements, attributes) {
function VAOEmulated (line 55864) | function VAOEmulated(gl) {
function createVAOEmulated (line 55894) | function createVAOEmulated(gl) {
function VertexAttribute (line 55904) | function VertexAttribute(location, dimension, a, b, c, d) {
function VAONative (line 55930) | function VAONative(gl, ext, handle) {
function createVAONative (line 55982) | function createVAONative(gl, ext) {
function ExtensionShim (line 55993) | function ExtensionShim (gl) {
function createVAO (line 55999) | function createVAO(gl, attributes, elements, elementsType) {
function add (line 56027) | function add(out, a, b) {
function angle (line 56046) | function angle(a, b) {
function ceil (line 56072) | function ceil(out, a) {
function clone (line 56088) | function clone(a) {
function copy (line 56105) | function copy(out, a) {
function create (line 56119) | function create() {
function cross (line 56137) | function cross(out, a, b) {
function distance (line 56159) | function distance(a, b) {
function divide (line 56179) | function divide(out, a, b) {
function dot (line 56195) | function dot(a, b) {
function equals (line 56213) | function equals(a, b) {
function exactEquals (line 56235) | function exactEquals(a, b) {
function floor (line 56249) | function floor(out, a) {
function forEach (line 56273) | function forEach(a, stride, offset, count, fn, arg) {
function fromValues (line 56312) | function fromValues(x, y, z) {
function inverse (line 56378) | function inverse(out, a) {
function length (line 56396) | function length(a) {
function lerp (line 56414) | function lerp(out, a, b, t) {
function max (line 56434) | function max(out, a, b) {
function min (line 56451) | function min(out, a, b) {
function multiply (line 56471) | function multiply(out, a, b) {
function negate (line 56487) | function negate(out, a) {
function normalize (line 56503) | function normalize(out, a) {
function random (line 56527) | function random(out, scale) {
function rotateX (line 56550) | function rotateX(out, a, b, c){
function rotateY (line 56580) | function rotateY(out, a, b, c){
function rotateZ (line 56610) | function rotateZ(out, a, b, c){
function round (line 56639) | function round(out, a) {
function scale (line 56657) | function scale(out, a, b) {
function scaleAndAdd (line 56675) | function scaleAndAdd(out, a, b, scale) {
function set (line 56693) | function set(out, x, y, z) {
function squaredDistance (line 56715) | function squaredDistance(a, b) {
function squaredLength (line 56730) | function squaredLength(a) {
function subtract (line 56750) | function subtract(out, a, b) {
function transformMat3 (line 56767) | function transformMat3(out, a, m) {
function transformMat4 (line 56786) | function transformMat4(out, a, m) {
function transformQuat (line 56806) | function transformQuat(out, a, q) {
function add (line 56835) | function add (out, a, b) {
function clone (line 56852) | function clone (a) {
function copy (line 56871) | function copy (out, a) {
function create (line 56887) | function create () {
function distance (line 56906) | function distance (a, b) {
function divide (line 56925) | function divide (out, a, b) {
function dot (line 56943) | function dot (a, b) {
function fromValues (line 56959) | function fromValues (x, y, z, w) {
function inverse (line 57007) | function inverse (out, a) {
function length (line 57024) | function length (a) {
function lerp (line 57044) | function lerp (out, a, b, t) {
function max (line 57067) | function max (out, a, b) {
function min (line 57086) | function min (out, a, b) {
function multiply (line 57105) | function multiply (out, a, b) {
function negate (line 57123) | function negate (out, a) {
function normalize (line 57141) | function normalize (out, a) {
function random (line 57170) | function random (out, scale) {
function scale (line 57194) | function scale (out, a, b) {
function scaleAndAdd (line 57214) | function scaleAndAdd (out, a, b, scale) {
function set (line 57235) | function set (out, x, y, z, w) {
function squaredDistance (line 57253) | function squaredDistance (a, b) {
function squaredLength (line 57270) | function squaredLength (a) {
function subtract (line 57289) | function subtract (out, a, b) {
function transformMat4 (line 57308) | function transformMat4 (out, a, m) {
function transformQuat (line 57328) | function transformQuat (out, a, q) {
function decodeFloat (line 57352) | function decodeFloat(x, y, z, w) {
function getName (line 57366) | function getName(src) {
function tokenize (line 57424) | function tokenize(opt) {
function tokenizeString (line 58211) | function tokenizeString(str, opt) {
function detect (line 58255) | function detect() {
function compareInt (line 58374) | function compareInt(a, b) {
function Simplex (line 58378) | function Simplex(vertices, adjacent, boundary) {
function GlueFacet (line 58394) | function GlueFacet(vertices, cell, index) {
function compareGlue (line 58400) | function compareGlue(a, b) {
function bakeOrient (line 58404) | function bakeOrient(d) {
function Triangulation (line 58423) | function Triangulation(dimension, vertices, simplices) {
function incrementalConvexHull (line 58734) | function incrementalConvexHull(points, randomSearch) {
function IntervalTreeNode (line 58820) | function IntervalTreeNode(mid, left, right, leftPoints, rightPoints) {
function copy (line 58831) | function copy(a, b) {
function rebuild (line 58840) | function rebuild(node, intervals) {
function rebuildWithInterval (line 58850) | function rebuildWithInterval(node, interval) {
function rebuildWithoutInterval (line 58856) | function rebuildWithoutInterval(node, interval) {
function reportLeftRange (line 59001) | function reportLeftRange(arr, hi, cb) {
function reportRightRange (line 59008) | function reportRightRange(arr, lo, cb) {
function reportRange (line 59015) | function reportRange(arr, cb) {
function compareNumbers (line 59058) | function compareNumbers(a, b) {
function compareBegin (line 59062) | function compareBegin(a, b) {
function compareEnd (line 59068) | function compareEnd(a, b) {
function createIntervalTree (line 59074) | function createIntervalTree(intervals) {
function IntervalTree (line 59114) | function IntervalTree(root) {
function createWrapper (line 59169) | function createWrapper(intervals) {
function invertPermutation (line 59179) | function invertPermutation(pi, result) {
function iota (line 59191) | function iota(n) {
function isBuffer (line 59216) | function isBuffer (obj) {
function isSlowBuffer (line 59221) | function isSlowBuffer (obj) {
function isMobile (line 59240) | function isMobile (opts) {
function lerp (line 59322) | function lerp(v0, v1, t) {
function define (line 59339) | function define(_, chunk) {
function e (line 59355) | function e(t,e){return t(e={exports:{}},e.exports),e.exports}
function n (line 59355) | function n(t,e,r,n){this.cx=3*t,this.bx=3*(r-t)-this.cx,this.ax=1-this.c...
function a (line 59355) | function a(t,e){this.x=t,this.y=e;}
function o (line 59355) | function o(t,e){if(Array.isArray(t)){if(!Array.isArray(e)||t.length!==e....
function s (line 59355) | function s(t,e,n,i){var a=new r(t,e,n,i);return function(t){return a.sol...
function l (line 59355) | function l(t,e,r){return Math.min(r,Math.max(e,t))}
function p (line 59355) | function p(t,e,r){var n=r-e,i=((t-e)%n+n)%n+e;return i===e?r:i}
function c (line 59355) | function c(t){for(var e=[],r=arguments.length-1;r-- >0;)e[r]=arguments[r...
function f (line 59355) | function f(){return h++}
function y (line 59355) | function y(){return function t(e){return e?(e^16*Math.random()>>e/4).toS...
function d (line 59355) | function d(t){return !!t&&/^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab...
function m (line 59355) | function m(t,e){t.forEach(function(t){e[t]&&(e[t]=e[t].bind(e));});}
function v (line 59355) | function v(t,e){return -1!==t.indexOf(e,t.length-e.length)}
function g (line 59355) | function g(t,e,r){var n={};for(var i in t)n[i]=e.call(r||this,t[i],i,t);...
function x (line 59355) | function x(t,e,r){var n={};for(var i in t)e.call(r||this,t[i],i,t)&&(n[i...
function b (line 59355) | function b(t){return Array.isArray(t)?t.map(b):"object"==typeof t&&t?g(t...
function w (line 59355) | function w(t){_[t]||("undefined"!=typeof console&&console.warn(t),_[t]=!...
function A (line 59355) | function A(t,e,r){return (r.y-t.y)*(e.x-t.x)>(e.y-t.y)*(r.x-t.x)}
function S (line 59355) | function S(t){for(var e=0,r=0,n=t.length,i=n-1,a=void 0,o=void 0;r<n;i=r...
function k (line 59355) | function k(t){var e={};if(t.replace(/(?:^|(?:\s*\,\s*))([^\x00-\x20\(\)<...
function z (line 59355) | function z(t){try{var e=self[t];return e.setItem("_mapbox_test_",1),e.re...
method devicePixelRatio (line 59355) | get devicePixelRatio(){return self.devicePixelRatio}
method EVENTS_URL (line 59355) | get EVENTS_URL(){return this.API_URL?0===this.API_URL.indexOf("https://a...
function O (line 59355) | function O(t){var e=t.createTexture();t.bindTexture(t.TEXTURE_2D,e);try{...
function q (line 59355) | function q(t,e){var r=rt(V.API_URL);if(t.protocol=r.protocol,t.authority...
function N (line 59355) | function N(t){return 0===t.indexOf("mapbox:")}
function K (line 59355) | function K(t){return Z.test(t)}
function rt (line 59355) | function rt(t){var e=t.match(et);if(!e)throw new Error("Unable to parse ...
function nt (line 59355) | function nt(t){var e=t.params.length?"?"+t.params.join("&"):"";return t....
function it (line 59355) | function it(t){if(!t)return null;var e,r=t.split(".");if(!r||3!==r.lengt...
function e (line 59355) | function e(){t.call(this,"map.load"),this.success={},this.skuToken="";}
function e (line 59355) | function e(){t.call(this,"appUserTurnstile");}
function mt (line 59355) | function mt(t,e,r){if(self.caches){var n={status:e.status,statusText:e.s...
function vt (line 59355) | function vt(t){var e=t.indexOf("?");return e<0?t:t.slice(0,e)}
function gt (line 59355) | function gt(t,e){if(!self.caches)return e(null);var r=vt(
Copy disabled (too large)
Download .json
Condensed preview — 602 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (11,592K chars).
[
{
"path": ".clang-format",
"chars": 3280,
"preview": "---\nLanguage: Cpp\n# BasedOnStyle: LLVM\nAccessModifierOffset: -4\nAlignAfterOpenBracket: Align\nAlignConsecutiveAss"
},
{
"path": ".gitignore",
"chars": 283,
"preview": "/nbproject/\n/build/\n/install/\n*.cmake\n/CMakeFiles/\n/CMakeScripts/\nCMakeCache.txt\n/Release/\n/Debug/\n/Yacas.build/\n/Yacas."
},
{
"path": ".vscode/launch.json",
"chars": 2944,
"preview": "{\n \"version\": \"0.2.0\",\n \"configurations\": [\n {\n \"name\": \"(gdb) Launch yacas\",\n \"type\""
},
{
"path": ".vscode/settings.json",
"chars": 2986,
"preview": "{\n \"C_Cpp.intelliSenseEngine\": \"Default\",\n \"editor.insertSpaces\": true,\n \"editor.tabSize\": 4,\n \"editor.detec"
},
{
"path": "AUTHORS",
"chars": 6449,
"preview": "************\nCredits [*]_\n************\n\nOriginal/primary authors \n========================\nAyal Pinkus "
},
{
"path": "CMakeLists.txt",
"chars": 9318,
"preview": "cmake_minimum_required (VERSION 3.10)\n\nforeach (p CMP0048 CMP0054 CMP0071 CMP0135)\n if (POLICY ${p})\n cmake_po"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 3215,
"preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, w"
},
{
"path": "COPYING",
"chars": 26530,
"preview": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 2.1, February 1999\n\n Copyright (C) 19"
},
{
"path": "ChangeLog",
"chars": 42,
"preview": "\nChanges are none, there is only the now.\n"
},
{
"path": "README.rst",
"chars": 3156,
"preview": "=====\nyacas\n=====\n\n.. image:: https://img.shields.io/badge/license-LGPL--2.1%2B-blue.svg\n :target: ./COPYING\n\n.. imag"
},
{
"path": "TODO",
"chars": 28368,
"preview": "TODO:\n- Manual titles do not correspond with the manual you go to.\n\n- Ceil, Round and Floor, also try to force to a numb"
},
{
"path": "appveyor.yml",
"chars": 3218,
"preview": "branches:\n only:\n - master\n - develop\n\nskip_tags: true\n\nplatform:\n - x64\n\nconfiguration:\n - Release\n\nenvironmen"
},
{
"path": "build.xml",
"chars": 2867,
"preview": "<project name=\"jyacas\" default=\"jar\" basedir=\".\">\n <description>\n jyacas build file\n </description>\n <property nam"
},
{
"path": "cyacas/CMakeLists.txt",
"chars": 1906,
"preview": "\nif (APPLE)\n set(CMAKE_MACOSX_RPATH 1)\n set(CMAKE_INSTALL_FRAMEWORK_PREFIX \"/Library/Frameworks\" CACHE STRING \"Directo"
},
{
"path": "cyacas/libyacas/CMakeLists.txt",
"chars": 4238,
"preview": "configure_file (\n \"config/yacas/yacas_version.h.in\"\n \"${CMAKE_CURRENT_BINARY_DIR}/config/yacas/yacas_version.h\"\n )\n\ns"
},
{
"path": "cyacas/libyacas/config/yacas/yacas_version.h.in",
"chars": 229,
"preview": "#ifndef YACAS_VERSION\n\n#define YACAS_VERSION_MAJOR @PROJECT_VERSION_MAJOR@\n#define YACAS_VERSION_MINOR @PROJECT_VERSION_"
},
{
"path": "cyacas/libyacas/include/yacas/GPL_stuff.h",
"chars": 932,
"preview": "#ifndef YACAS_GPL_STUFF_H\n#define YACAS_GPL_STUFF_H\n\n#define GPL_base_text \\\n\"Yacas is Free Software--Free as in Freedom"
},
{
"path": "cyacas/libyacas/include/yacas/anumber.h",
"chars": 3524,
"preview": "#ifndef YACAS_ANUMBER_H\n#define YACAS_ANUMBER_H\n\n#include <cassert>\n#include <cctype>\n#include <string>\n#include <vector"
},
{
"path": "cyacas/libyacas/include/yacas/anumber.inl",
"chars": 11030,
"preview": "\n#include \"anumber.h\"\n\n\n/* BaseTimesInt : multiply a with one digit in the range 0..(aBase-1)\n */\ntemplate<class T>\ninli"
},
{
"path": "cyacas/libyacas/include/yacas/arggetter.h",
"chars": 229,
"preview": "#ifndef YACAS_ARGGETTER_H\n#define YACAS_ARGGETTER_H\n\n#include \"lispenvironment.h\"\n\n/// Get an argument that should be a "
},
{
"path": "cyacas/libyacas/include/yacas/arrayclass.h",
"chars": 1097,
"preview": "#ifndef YACAS_ARRAYCLASS_H\n#define YACAS_ARRAYCLASS_H\n\n#include \"lispobject.h\"\n#include \"genericobject.h\"\n\n#include <vec"
},
{
"path": "cyacas/libyacas/include/yacas/associationclass.h",
"chars": 2743,
"preview": "/*\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the terms"
},
{
"path": "cyacas/libyacas/include/yacas/corefunctions.h",
"chars": 20708,
"preview": "//\n// declare the core functions that have special syntax\n//\n\nOPERATOR(bodied,KMaxPrecedence,While)\nOPERATOR(bodied,KMax"
},
{
"path": "cyacas/libyacas/include/yacas/deffile.h",
"chars": 1465,
"preview": "/** \\file deffile.h deffiles, which speed up loading.\n * This module adds support for loading files which specify\n * w"
},
{
"path": "cyacas/libyacas/include/yacas/errors.h",
"chars": 738,
"preview": "#ifndef YACAS_ERRORS_H\n#define YACAS_ERRORS_H\n\n#include \"lispenvironment.h\"\n\nvoid CheckArg(bool pred, int arg_idx, LispE"
},
{
"path": "cyacas/libyacas/include/yacas/evalfunc.h",
"chars": 365,
"preview": "#ifndef YACAS_EVALFUNCBASE_H\n#define YACAS_EVALFUNCBASE_H\n\n// class EvalFuncBase defines the interface to 'something tha"
},
{
"path": "cyacas/libyacas/include/yacas/genericobject.h",
"chars": 423,
"preview": "#ifndef YACAS_GENERICOBJECT_H\n#define YACAS_GENERICOBJECT_H\n\n/// Abstract class which can be put inside a LispGenericCla"
},
{
"path": "cyacas/libyacas/include/yacas/infixparser.h",
"chars": 2667,
"preview": "/** \\file infixparser.h\n * parsing and printing in the infix style.\n *\n */\n\n#ifndef YACAS_INFIXPARSER_H\n#define YACAS_I"
},
{
"path": "cyacas/libyacas/include/yacas/lispatom.h",
"chars": 4666,
"preview": "/** \\file lispatom.h\n * implementation of the standard lisp elements: atom and sublist.\n *\n * class LispAtom. This clas"
},
{
"path": "cyacas/libyacas/include/yacas/lispenvironment.h",
"chars": 11656,
"preview": "/** \\file lispenvironment.h\n * General environment access.\n *\n */\n\n#ifndef YACAS_LISPENVIRONMENT_H\n#define YACAS_LISPEN"
},
{
"path": "cyacas/libyacas/include/yacas/lisperror.h",
"chars": 5082,
"preview": "#ifndef YACAS_LISPERROR_H\n#define YACAS_LISPERROR_H\n\n#include <string>\n\nclass LispError {\npublic:\n LispError(const st"
},
{
"path": "cyacas/libyacas/include/yacas/lispeval.h",
"chars": 5502,
"preview": "/** \\file lispeval.h\n * Evaluation of expressions.\n *\n */\n\n#ifndef YACAS_LISPEVAL_H\n#define YACAS_LISPEVAL_H\n\n#include "
},
{
"path": "cyacas/libyacas/include/yacas/lispevalhash.h",
"chars": 1176,
"preview": "/** \\file lispevalhash.h\n * Storage of executable commands\n *\n */\n\n#ifndef YACAS_LISPEVALHASH_H\n#define YACAS_LISPEVALH"
},
{
"path": "cyacas/libyacas/include/yacas/lispglobals.h",
"chars": 1342,
"preview": "\n/** \\file lispglobals.h\n * Storage of globals in a associated hash\n *\n */\n\n#ifndef YACAS_LISPGLOBALS_H\n#define YACAS_L"
},
{
"path": "cyacas/libyacas/include/yacas/lisphash.h",
"chars": 817,
"preview": "/** \\file lisphash.h\n * hashing of strings. Each string will exist only once in the\n * hash table, and have an unique i"
},
{
"path": "cyacas/libyacas/include/yacas/lispio.h",
"chars": 1643,
"preview": "/** \\file lispio.h\n * definitions of pure input output classes.\n */\n\n\n#ifndef YACAS_LISPIO_H\n#define YACAS_LISPIO_H\n\n#in"
},
{
"path": "cyacas/libyacas/include/yacas/lispobject.h",
"chars": 6613,
"preview": "/** \\file lispobject.h\n * Implementation of basic LispObject, which is the base class for\n * anything that can be put "
},
{
"path": "cyacas/libyacas/include/yacas/lispoperator.h",
"chars": 1780,
"preview": "/*\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the terms"
},
{
"path": "cyacas/libyacas/include/yacas/lispparser.h",
"chars": 1101,
"preview": "/** \\file lispparser.h\n * parsing and printing in the old-fashioned lisp style\n *\n */\n\n#ifndef YACAS_LISPPARSER_H\n#defi"
},
{
"path": "cyacas/libyacas/include/yacas/lispstring.h",
"chars": 533,
"preview": "/** \\file lispstring.h\n * Defining a string class.\n */\n\n\n#ifndef YACAS_LISPSTRING_H\n#define YACAS_LISPSTRING_H\n\n#includ"
},
{
"path": "cyacas/libyacas/include/yacas/lispuserfunc.h",
"chars": 3809,
"preview": "#ifndef YACAS_LISPUSERFUNC_H\n#define YACAS_LISPUSERFUNC_H\n\n#include \"lispobject.h\"\n#include \"evalfunc.h\"\n\n#include <vect"
},
{
"path": "cyacas/libyacas/include/yacas/mathcommands.h",
"chars": 655,
"preview": "#ifndef YACAS_MATHCOMMANDS_H\n#define YACAS_MATHCOMMANDS_H\n\n#include \"lispenvironment.h\"\n#include \"lispevalhash.h\"\n#inclu"
},
{
"path": "cyacas/libyacas/include/yacas/mathuserfunc.h",
"chars": 7020,
"preview": "#ifndef YACAS_MATHUSERFUNC_H\n#define YACAS_MATHUSERFUNC_H\n\n#include \"lispuserfunc.h\"\n#include \"patternclass.h\"\n#include "
},
{
"path": "cyacas/libyacas/include/yacas/mempool.h",
"chars": 808,
"preview": "#ifndef YACAS_MEMPOOL_H\n#define YACAS_MEMPOOL_H\n\n#include \"noncopyable.h\"\n\n#include <cstddef>\n#include <cstdint>\n\nclass "
},
{
"path": "cyacas/libyacas/include/yacas/noncopyable.h",
"chars": 318,
"preview": "#ifndef YACAS_NONCOPYABLE_H\n#define YACAS_NONCOPYABLE_H\n\nclass NonCopyable {\nprotected:\n#ifndef YACAS_NO_CONSTEXPR\n c"
},
{
"path": "cyacas/libyacas/include/yacas/numbers.h",
"chars": 4450,
"preview": "#ifndef YACAS_NUMBERS_H\n#define YACAS_NUMBERS_H\n\n#include \"lispenvironment.h\"\n#include \"anumber.h\"\n#include \"refcount.h\""
},
{
"path": "cyacas/libyacas/include/yacas/patcher.h",
"chars": 195,
"preview": "#ifndef YACAS_PATCHER_H\n#define YACAS_PATCHER_H\n\n#include <string>\n#include <ostream>\n\n#include \"lispenvironment.h\"\n\nvoi"
},
{
"path": "cyacas/libyacas/include/yacas/patternclass.h",
"chars": 733,
"preview": "#ifndef YACAS_PATTERNCLASS_H\n#define YACAS_PATTERNCLASS_H\n\n#include \"lispobject.h\"\n#include \"genericobject.h\"\n#include \""
},
{
"path": "cyacas/libyacas/include/yacas/patterns.h",
"chars": 8382,
"preview": "#ifndef YACAS_PATTERNS_H\n#define YACAS_PATTERNS_H\n\n/// \\file\n/// Pattern matching code.\n///\n/// General idea: have a cla"
},
{
"path": "cyacas/libyacas/include/yacas/platfileio.h",
"chars": 1234,
"preview": "#ifndef YACAS_PLATFILEIO_H\n#define YACAS_PLATFILEIO_H\n\n#include \"lispenvironment.h\"\n#include \"noncopyable.h\"\n\n#include <"
},
{
"path": "cyacas/libyacas/include/yacas/platmath.h",
"chars": 938,
"preview": "#ifndef YACAS_PLATMATH_H\n#define YACAS_PLATMATH_H\n\n#include \"lispenvironment.h\"\n\n// // Beware the use of these functions"
},
{
"path": "cyacas/libyacas/include/yacas/refcount.h",
"chars": 2263,
"preview": "#ifndef YACAS_REFCOUNT_H\r\n#define YACAS_REFCOUNT_H\r\n\r\n#include <cassert>\r\n\r\n//------------------------------------------"
},
{
"path": "cyacas/libyacas/include/yacas/standard.h",
"chars": 3293,
"preview": "#ifndef YACAS_STANDARD_H\n#define YACAS_STANDARD_H\n\n#include \"lispobject.h\"\n#include \"lispenvironment.h\"\n#include \"lispha"
},
{
"path": "cyacas/libyacas/include/yacas/standard.inl",
"chars": 1407,
"preview": "\n\n\ninline LispPtr& Argument(LispPtr& cur, int n)\n{\n assert(n>=0);\n\n LispPtr* loop = &cur;\n while(n--) loop = &("
},
{
"path": "cyacas/libyacas/include/yacas/string_utils.h",
"chars": 638,
"preview": "#ifndef STRING_UTILS_H\n#define STRING_UTILS_H\n\n#include <algorithm>\n#include <functional>\n#include <cctype>\n#include <lo"
},
{
"path": "cyacas/libyacas/include/yacas/stringio.h",
"chars": 596,
"preview": "/** \\file stringio.h\n * definitions of input output classes that read and write from string.\n */\n\n#ifndef YACAS_STRINGIO"
},
{
"path": "cyacas/libyacas/include/yacas/substitute.h",
"chars": 2124,
"preview": "#ifndef YACAS_SUBSTITUTE_H\n#define YACAS_SUBSTITUTE_H\n\n#include \"lispobject.h\"\n#include \"lispenvironment.h\"\n\n#include <v"
},
{
"path": "cyacas/libyacas/include/yacas/tokenizer.h",
"chars": 689,
"preview": "/** \\file tokenizer.h\n * definitions of input output classes that read and write from string.\n */\n\n\n#ifndef YACAS_TOKENI"
},
{
"path": "cyacas/libyacas/include/yacas/utf8/checked.h",
"chars": 12957,
"preview": "// Copyright 2006-2016 Nemanja Trifunovic\n\n/*\nPermission is hereby granted, free of charge, to any person or organizatio"
},
{
"path": "cyacas/libyacas/include/yacas/utf8/core.h",
"chars": 17922,
"preview": "// Copyright 2006 Nemanja Trifunovic\n\n/*\nPermission is hereby granted, free of charge, to any person or organization\nobt"
},
{
"path": "cyacas/libyacas/include/yacas/utf8/cpp11.h",
"chars": 2398,
"preview": "// Copyright 2018 Nemanja Trifunovic\n\n/*\nPermission is hereby granted, free of charge, to any person or organization\nobt"
},
{
"path": "cyacas/libyacas/include/yacas/utf8/cpp17.h",
"chars": 3182,
"preview": "// Copyright 2018 Nemanja Trifunovic\n\n/*\nPermission is hereby granted, free of charge, to any person or organization\nobt"
},
{
"path": "cyacas/libyacas/include/yacas/utf8/cpp20.h",
"chars": 4015,
"preview": "// Copyright 2022 Nemanja Trifunovic\n\n/*\nPermission is hereby granted, free of charge, to any person or organization\nobt"
},
{
"path": "cyacas/libyacas/include/yacas/utf8/unchecked.h",
"chars": 11061,
"preview": "// Copyright 2006 Nemanja Trifunovic\n\n/*\nPermission is hereby granted, free of charge, to any person or organization\nobt"
},
{
"path": "cyacas/libyacas/include/yacas/utf8.h",
"chars": 1988,
"preview": "// Copyright 2006 Nemanja Trifunovic\n\n/*\nPermission is hereby granted, free of charge, to any person or organization\nobt"
},
{
"path": "cyacas/libyacas/include/yacas/xmltokenizer.h",
"chars": 304,
"preview": "\n#ifndef _xmltokenizer_h_\n#define _xmltokenizer_h_\n\n#include \"tokenizer.h\"\n\nclass XmlTokenizer final: public LispTokeniz"
},
{
"path": "cyacas/libyacas/include/yacas/yacas.h",
"chars": 2843,
"preview": "/// \\file\n/// Definitions of DefaultYacasEnvironment and CYacas.\n\n#ifndef YACAS_YACAS_H\n#define YACAS_YACAS_H\n\n#include "
},
{
"path": "cyacas/libyacas/src/anumber.cpp",
"chars": 33639,
"preview": "\n\n/* Arbitrary precision arithmetic classes. These are NOT designed\n * to be bleeding fast, just reaonably fast, but ver"
},
{
"path": "cyacas/libyacas/src/arggetter.cpp",
"chars": 794,
"preview": "\n#include \"yacas/arggetter.h\"\n#include \"yacas/errors.h\"\n#include \"yacas/lispenvironment.h\"\n#include \"yacas/lispeval.h\"\n#"
},
{
"path": "cyacas/libyacas/src/associationclass.cpp",
"chars": 2002,
"preview": "/*\n * Copyright (C) 2016 Grzegorz Mazur.\n *\n * Yacas is free software; you can redistribute it and/or\n * modify it under"
},
{
"path": "cyacas/libyacas/src/deffile.cpp",
"chars": 2505,
"preview": "#include \"yacas/deffile.h\"\n\n#include \"yacas/lispenvironment.h\"\n#include \"yacas/lisperror.h\"\n#include \"yacas/lispio.h\"\n#i"
},
{
"path": "cyacas/libyacas/src/errors.cpp",
"chars": 3096,
"preview": "#include \"yacas/errors.h\"\n#include \"yacas/infixparser.h\"\n#include \"yacas/lispenvironment.h\"\n#include \"yacas/lispeval.h\"\n"
},
{
"path": "cyacas/libyacas/src/infixparser.cpp",
"chars": 16443,
"preview": "\n#include \"yacas/infixparser.h\"\n#include \"yacas/arrayclass.h\"\n#include \"yacas/associationclass.h\"\n#include \"yacas/errors"
},
{
"path": "cyacas/libyacas/src/lispatom.cpp",
"chars": 4194,
"preview": "\n#include \"yacas/lispatom.h\"\n#include \"yacas/lisperror.h\"\n#include \"yacas/numbers.h\"\n#include \"yacas/standard.h\"\n\n#inclu"
},
{
"path": "cyacas/libyacas/src/lispenvironment.cpp",
"chars": 15177,
"preview": "\n#include \"yacas/lispenvironment.h\"\n#include \"yacas/errors.h\"\n#include \"yacas/lispatom.h\"\n#include \"yacas/lispeval.h\"\n#i"
},
{
"path": "cyacas/libyacas/src/lisperror.cpp",
"chars": 530,
"preview": "#include \"yacas/lisperror.h\"\n#include \"yacas/lispenvironment.h\"\n#include \"yacas/standard.h\"\n\nvoid HandleError(const Lisp"
},
{
"path": "cyacas/libyacas/src/lispeval.cpp",
"chars": 12339,
"preview": "\n#include \"yacas/lispeval.h\"\n#include \"yacas/lispuserfunc.h\"\n#include \"yacas/standard.h\"\n\n#include \"yacas/errors.h\"\n#inc"
},
{
"path": "cyacas/libyacas/src/lispevalhash.cpp",
"chars": 2021,
"preview": "\n\n#include \"yacas/lispevalhash.h\"\n#include \"yacas/errors.h\"\n#include \"yacas/lispatom.h\"\n#include \"yacas/lispenvironment."
},
{
"path": "cyacas/libyacas/src/lisphash.cpp",
"chars": 537,
"preview": "#include \"yacas/lisphash.h\"\n\nconst LispString* LispHashTable::LookUp(const std::string& s)\n{\n std::unordered_map<std:"
},
{
"path": "cyacas/libyacas/src/lispio.cpp",
"chars": 289,
"preview": "\n#include \"yacas/lispio.h\"\n\nvoid InputStatus::SetTo(const std::string& aFileName)\n{\n iFileName = aFileName;\n iLine"
},
{
"path": "cyacas/libyacas/src/lispobject.cpp",
"chars": 659,
"preview": "\n#include \"yacas/lispobject.h\"\n\nint LispObject::Equal(LispObject& aOther)\n{\n // next line handles the fact that eithe"
},
{
"path": "cyacas/libyacas/src/lispparser.cpp",
"chars": 3501,
"preview": "\n#include \"yacas/lispparser.h\"\n#include \"yacas/lispatom.h\"\n#include \"yacas/lispenvironment.h\"\n#include \"yacas/lisperror."
},
{
"path": "cyacas/libyacas/src/lispuserfunc.cpp",
"chars": 1686,
"preview": "\n#include \"yacas/lispuserfunc.h\"\n#include \"yacas/standard.h\"\n\nLispUserFunction* LispMultiUserFunction::UserFunc(int aAri"
},
{
"path": "cyacas/libyacas/src/mathcommands.cpp",
"chars": 62130,
"preview": "\n#include \"yacas/arggetter.h\"\n#include \"yacas/arrayclass.h\"\n#include \"yacas/associationclass.h\"\n#include \"yacas/errors.h"
},
{
"path": "cyacas/libyacas/src/mathcommands2.cpp",
"chars": 2744,
"preview": "#include \"yacas/arrayclass.h\"\n#include \"yacas/errors.h\"\n#include \"yacas/infixparser.h\"\n#include \"yacas/lispatom.h\"\n#incl"
},
{
"path": "cyacas/libyacas/src/mathcommands3.cpp",
"chars": 28756,
"preview": "#include \"yacas/arrayclass.h\"\n#include \"yacas/errors.h\"\n#include \"yacas/infixparser.h\"\n#include \"yacas/lispatom.h\"\n#incl"
},
{
"path": "cyacas/libyacas/src/mathuserfunc.cpp",
"chars": 13100,
"preview": "#include \"yacas/mathuserfunc.h\"\n#include \"yacas/lispeval.h\"\n#include \"yacas/lispobject.h\"\n#include \"yacas/patternclass.h"
},
{
"path": "cyacas/libyacas/src/mempool.cpp",
"chars": 1722,
"preview": "#include \"yacas/mempool.h\"\n\n#include <algorithm>\n#include <cassert>\n\nMemPool::MemPool(unsigned block_size, unsigned no_b"
},
{
"path": "cyacas/libyacas/src/numbers.cpp",
"chars": 3014,
"preview": "#include \"yacas/numbers.h\"\n#include \"yacas/errors.h\"\n#include \"yacas/standard.h\"\n\n#include <cmath>\n#include <sstream>\n\n/"
},
{
"path": "cyacas/libyacas/src/patcher.cpp",
"chars": 1211,
"preview": "#include \"yacas/patcher.h\"\n\n#include \"yacas/lisperror.h\"\n#include \"yacas/lispio.h\"\n#include \"yacas/standard.h\"\n\n#include"
},
{
"path": "cyacas/libyacas/src/patternclass.cpp",
"chars": 636,
"preview": "#include \"yacas/patternclass.h\"\n\nPatternClass::PatternClass(YacasPatternPredicateBase* aPatternMatcher) :\n iPatternMa"
},
{
"path": "cyacas/libyacas/src/patterns.cpp",
"chars": 8539,
"preview": "#include \"yacas/patterns.h\"\n#include \"yacas/lispeval.h\"\n#include \"yacas/lispobject.h\"\n#include \"yacas/mathuserfunc.h\"\n#i"
},
{
"path": "cyacas/libyacas/src/platmath.cpp",
"chars": 2643,
"preview": "/* Math using the standard library, if the precision is less than 13 */\n#include \"yacas/platmath.h\"\n#include \"yacas/erro"
},
{
"path": "cyacas/libyacas/src/standard.cpp",
"chars": 15137,
"preview": "// \\file standard.cpp\n// Implementation of some standard lisp operations\n//\n#include \"yacas/standard.h\"\n#include \"yacas/"
},
{
"path": "cyacas/libyacas/src/stdfileio.cpp",
"chars": 3186,
"preview": "#include \"yacas/platfileio.h\"\n\n#include <memory>\n\n#ifdef _WIN32\n# define MAP_TO_WIN32_PATH_SEPARATOR\n#endif // WIN32\n"
},
{
"path": "cyacas/libyacas/src/stringio.cpp",
"chars": 1014,
"preview": "#include \"yacas/stringio.h\"\n\nStringInput::StringInput(const std::string& aString, InputStatus& aStatus) :\n LispInput("
},
{
"path": "cyacas/libyacas/src/substitute.cpp",
"chars": 3236,
"preview": "#include \"yacas/substitute.h\"\n#include \"yacas/lispatom.h\"\n#include \"yacas/lispeval.h\"\n#include \"yacas/standard.h\"\n\n// Su"
},
{
"path": "cyacas/libyacas/src/tokenizer.cpp",
"chars": 40859,
"preview": "#include \"yacas/tokenizer.h\"\n\n#include \"yacas/lisperror.h\"\n\n#include \"yacas/utf8.h\"\n\n#include <unordered_set>\n\nnamespace"
},
{
"path": "cyacas/libyacas/src/xmltokenizer.cpp",
"chars": 826,
"preview": "#include \"yacas/xmltokenizer.h\"\n#include \"yacas/lisperror.h\"\n\n#include <cctype>\n#include <iostream>\n\nstd::string XmlToke"
},
{
"path": "cyacas/libyacas/src/yacasapi.cpp",
"chars": 3635,
"preview": "\n#include \"yacas/mathcommands.h\"\n#include \"yacas/standard.h\"\n#include \"yacas/yacas.h\"\n\n#define OPERATOR(kind, prec, name"
},
{
"path": "cyacas/libyacas/src/yacasnumbers.cpp",
"chars": 23342,
"preview": "/* Implementation of the number classes (the functionality used\n * by yacas any way\n */\n\n#include \"yacas/errors.h\"\n#incl"
},
{
"path": "cyacas/libyacas_mp/CMakeLists.txt",
"chars": 2431,
"preview": "#\n#\n# This file is part of yacas.\n# Yacas is free software: you can redistribute it and/or modify\n# it under the terms o"
},
{
"path": "cyacas/libyacas_mp/benchmark/CMakeLists.txt",
"chars": 1005,
"preview": "#\n#\n# This file is part of yacas.\n# Yacas is free software: you can redistribute it and/or modify\n# it under the terms o"
},
{
"path": "cyacas/libyacas_mp/benchmark/src/nn_benchmark.cpp",
"chars": 4842,
"preview": "/*\n *\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the te"
},
{
"path": "cyacas/libyacas_mp/include/yacas/mp/limbs_vector.hpp",
"chars": 9298,
"preview": "/*\n *\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the te"
},
{
"path": "cyacas/libyacas_mp/include/yacas/mp/nn.hpp",
"chars": 14062,
"preview": "/*\n *\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the te"
},
{
"path": "cyacas/libyacas_mp/include/yacas/mp/rr.hpp",
"chars": 748,
"preview": "/*\n *\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the te"
},
{
"path": "cyacas/libyacas_mp/include/yacas/mp/zz.hpp",
"chars": 11395,
"preview": "/*\n *\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the te"
},
{
"path": "cyacas/libyacas_mp/src/limbs_vector.cpp",
"chars": 9416,
"preview": "#include \"yacas/mp/limbs_vector.hpp\"\n\n#include <algorithm>\n#include <cassert>\n\nnamespace yacas::mp {\n LimbsVector::Li"
},
{
"path": "cyacas/libyacas_mp/src/nn.cpp",
"chars": 19414,
"preview": "/*\n *\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the te"
},
{
"path": "cyacas/libyacas_mp/src/rr.cpp",
"chars": 693,
"preview": "/*\n *\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the te"
},
{
"path": "cyacas/libyacas_mp/src/zz.cpp",
"chars": 1832,
"preview": "/*\n *\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the te"
},
{
"path": "cyacas/libyacas_mp/test/CMakeLists.txt",
"chars": 942,
"preview": "#\n# Copyright (C) 2017 Grzegorz Mazur <teoretyk@gmail.com>\n#\n# This file is part of yacas.\n# Yacas is free software: you"
},
{
"path": "cyacas/libyacas_mp/test/src/nn_test.cpp",
"chars": 16525,
"preview": "/*\n *\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the te"
},
{
"path": "cyacas/libyacas_mp/test/src/zz_test.cpp",
"chars": 13875,
"preview": "/*\n *\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the te"
},
{
"path": "cyacas/packaging/deb/changelog",
"chars": 422,
"preview": "yacas (1.9.2-1) UNRELEASED; urgency=low\n\n * New upstream release\n\n -- Grzegorz Mazur <teoretyk@gmail.com> Tue, 4 Aug "
},
{
"path": "cyacas/packaging/deb/compat",
"chars": 4,
"preview": "12\n\n"
},
{
"path": "cyacas/packaging/deb/control",
"chars": 5487,
"preview": "Source: yacas\nMaintainer: Grzegorz Mazur <teoretyk@gmail.com>\nSection: contrib/math\nPriority: optional\nStandards-Version"
},
{
"path": "cyacas/packaging/deb/copyright",
"chars": 1374,
"preview": "Debian packaging of yacas originally created in 1998 by:\n John Lapeyre <lapeyre@physics.arizona.edu>\nand since 2010 im"
},
{
"path": "cyacas/packaging/deb/missing-sources/jquery-ui.js",
"chars": 520714,
"preview": "/*! jQuery UI - v1.12.1 - 2016-09-14\n* http://jqueryui.com\n* Includes: widget.js, position.js, data.js, disable-selectio"
},
{
"path": "cyacas/packaging/deb/missing-sources/jquery.autosize.js",
"chars": 8278,
"preview": "/*!\n\tAutosize 1.18.13\n\tlicense: MIT\n\thttp://www.jacklmoore.com/autosize\n*/\n(function ($) {\n\tvar\n\tdefaults = {\n\t\tclassNam"
},
{
"path": "cyacas/packaging/deb/missing-sources/jquery.js",
"chars": 280364,
"preview": "/*!\n * jQuery JavaScript Library v3.4.1\n * https://jquery.com/\n *\n * Includes Sizzle.js\n * https://sizzlejs.com/\n *\n * C"
},
{
"path": "cyacas/packaging/deb/missing-sources/jquery.ui-contextmenu.js",
"chars": 19926,
"preview": "/*******************************************************************************\n * jquery.ui-contextmenu.js plugin.\n *\n"
},
{
"path": "cyacas/packaging/deb/missing-sources/plotly-1.49.0.js",
"chars": 7032891,
"preview": "/**\n* plotly.js v1.49.0\n* Copyright 2012-2019, Plotly, Inc.\n* All rights reserved.\n* Licensed under the MIT license\n*/\n("
},
{
"path": "cyacas/packaging/deb/rules",
"chars": 4875,
"preview": "#!/usr/bin/make -f\n# Sample debian/rules that uses debhelper.\n# GNU copyright 1997 to 1999 by Joey Hess.\n\n# Uncomment th"
},
{
"path": "cyacas/packaging/deb/source/format",
"chars": 12,
"preview": "3.0 (quilt)\n"
},
{
"path": "cyacas/packaging/deb/source/include-binaries",
"chars": 2209,
"preview": "debian/yacas/usr/share/doc/yacas/singlehtml/objects.inv\ndebian/yacas/usr/share/doc/yacas/singlehtml/_static/yacaslogo_w2"
},
{
"path": "cyacas/packaging/deb/yacas.1",
"chars": 1815,
"preview": ".\\\" Man page generated from reStructuredText.\n.\n.TH YACAS 1 \"\" \"\" \"\"\n.SH NAME\nyacas \\- Yet Another Computer Algebra Syst"
},
{
"path": "cyacas/packaging/ebuild/yacas.ebuild",
"chars": 1181,
"preview": "# Copyright 1999-2017 Gentoo Foundation\n# Distributed under the terms of the GNU General Public License v2\n# $Id$\n\nEAPI="
},
{
"path": "cyacas/packaging/flatpak/org.yacas.yacas-gui.appdata.xml",
"chars": 1976,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<component type=\"desktop\">\n <id>org.yacas.yacas-gui</id>\n <metadata_license"
},
{
"path": "cyacas/packaging/flatpak/org.yacas.yacas-gui.json",
"chars": 3904,
"preview": "{\n \"app-id\": \"org.yacas.yacas-gui\",\n \"branch\": \"1.9\",\n \"runtime\": \"org.freedesktop.Platform\",\n \"runtime-vers"
},
{
"path": "cyacas/packaging/flatpak/org.yacas.yacas.json",
"chars": 1061,
"preview": "{\n \"app-id\": \"org.yacas.yacas\",\n \"branch\": \"1.9\",\n \"runtime\": \"org.freedesktop.Platform\",\n \"runtime-version\""
},
{
"path": "cyacas/packaging/nsis/COPYING",
"chars": 26530,
"preview": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 2.1, February 1999\n\n Copyright (C) 19"
},
{
"path": "cyacas/packaging/nsis/yacas-win64.nsi",
"chars": 4350,
"preview": "!include \"MUI2.nsh\"\n\n!define APPNAME \"Yacas\"\n!define DESCRIPTION \"Yet Another Computer Algebra System\"\n!define VERSIONMA"
},
{
"path": "cyacas/packaging/pkg/distribution.xml",
"chars": 801,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<installer-gui-script minSpecVersion=\"1\">\n <title>Yacas</title"
},
{
"path": "cyacas/packaging/pkg/license.txt",
"chars": 26530,
"preview": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 2.1, February 1999\n\n Copyright (C) 19"
},
{
"path": "cyacas/packaging/pkg/readme.html",
"chars": 813,
"preview": "<html>\n <body>\n <p>\n Yacas (Yet Another Computer Algebra System) is a small and highly flexible gen"
},
{
"path": "cyacas/packaging/rpm/yacas.spec",
"chars": 6755,
"preview": "# -*- rpm-spec -*-\n#\n# This file and all modifications and additions to the pristine\n# package are under the same licens"
},
{
"path": "cyacas/packaging/snap/snap/gui/yacas.gui.desktop",
"chars": 179,
"preview": "[Desktop Entry]\nName=yacas-gui\nComment=Yacas GUI\nExec=yacas.gui\nIcon=/snap/yacas/current/meta/gui/yacas-gui.png\nTerminal"
},
{
"path": "cyacas/packaging/snap/snapcraft.yaml",
"chars": 2729,
"preview": "name: yacas\nversion: 1.9.2-snap1\ngrade: stable\nbase: core18\nsummary: Yet Another Computer Algebra System\ndescription: |\n"
},
{
"path": "cyacas/xeus-yacas/CMakeLists.txt",
"chars": 430,
"preview": "find_package(xeus REQUIRED)\nfind_package(xeus-zmq REQUIRED)\nfind_package(Threads)\n\nfind_package (Boost REQUIRED filesyst"
},
{
"path": "cyacas/xeus-yacas/include/xeus-yacas/xeus-yacas.hpp",
"chars": 1308,
"preview": "#ifndef XEUS_YACAS_HPP\n#define XEUS_YACAS_HPP\n\n#include <memory>\n#include <sstream>\n#include <string>\n\n#include <xeus/xi"
},
{
"path": "cyacas/xeus-yacas/src/interpreter.cpp",
"chars": 6648,
"preview": "#include \"xeus-yacas/xeus-yacas.hpp\"\n\n#include <regex>\n#include <set>\n\n#include <xeus/xhelper.hpp>\n#include <xtl/xbase64"
},
{
"path": "cyacas/xeus-yacas/src/main.cpp",
"chars": 3021,
"preview": "#include <cstdlib>\n#include <filesystem>\n#include <fstream>\n#include <iostream>\n#include <memory>\n\n#include <boost/dll/r"
},
{
"path": "cyacas/yacas/CMakeLists.txt",
"chars": 1277,
"preview": "include_directories(\n \"include\"\n )\n\n\nset (YACAS_COMMON_SOURCES src/yacasmain.cpp src/commandline.cpp src/stdcommandlin"
},
{
"path": "cyacas/yacas/include/commandline.h",
"chars": 3471,
"preview": "\n/** \\file commandline.h\n * Implementation of a platform-independent command line with history.\n *\n * The class CComma"
},
{
"path": "cyacas/yacas/include/core_yacasmain.h",
"chars": 709,
"preview": "CORE_KERNEL_FUNCTION(\"Exit\",LispExit,0,YacasEvaluator::Function | YacasEvaluator::Fixed)\nCORE_KERNEL_FUNCTION(\"IsExitReq"
},
{
"path": "cyacas/yacas/include/stdcommandline.h",
"chars": 530,
"preview": "#ifndef YACAS_STDCOMMANDLINE_H\n#define YACAS_STDCOMMANDLINE_H\n\n#include \"commandline.h\"\n/** Simple no-frills implementat"
},
{
"path": "cyacas/yacas/include/unixcommandline.h",
"chars": 729,
"preview": "#ifndef YACAS_UNIXCOMMANDLINE_H\n#define YACAS_UNIXCOMMANDLINE_H\n\n#include \"commandline.h\"\n\n#include <termios.h>\n\n\n/** Un"
},
{
"path": "cyacas/yacas/include/win32commandline.h",
"chars": 617,
"preview": "#ifndef YACAS_WIN32COMMANDLINE_H\n#define YACAS_WIN32COMMANDLINE_H\n\n#include <windows.h>\n\n#include \"commandline.h\"\n\nclass"
},
{
"path": "cyacas/yacas/res/yacas.rc",
"chars": 821,
"preview": "#include \"winver.h\"\n#include \"yacas/yacas_version.h\"\n\nVS_VERSION_INFO VERSIONINFO\nFILEVERSION YACAS_VERSION_MAJOR, Y"
},
{
"path": "cyacas/yacas/src/commandline.cpp",
"chars": 8330,
"preview": "#include \"commandline.h\"\n\n#include <algorithm>\n#include <cstdint>\n\nnamespace {\n struct IsPrefix {\n\n explicit I"
},
{
"path": "cyacas/yacas/src/js_interface.cpp",
"chars": 3434,
"preview": "/*\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the terms"
},
{
"path": "cyacas/yacas/src/stdcommandline.cpp",
"chars": 599,
"preview": "#include \"stdcommandline.h\"\n\n#include <iostream>\n\nvoid CStdCommandLine::NewLine() {}\n\nvoid CStdCommandLine::Pause() {}\n\n"
},
{
"path": "cyacas/yacas/src/unixcommandline.cpp",
"chars": 5697,
"preview": "#include \"unixcommandline.h\"\n\n#include <sys/ioctl.h>\n\n#include <fstream>\n#include <iostream>\n#include <stdexcept>\n\nvoid "
},
{
"path": "cyacas/yacas/src/win32commandline.cpp",
"chars": 5461,
"preview": "#include \"win32commandline.h\"\n\n#include <fstream>\n#include <string>\n\n#include <conio.h>\n\n#include <shlobj.h>\n#include <s"
},
{
"path": "cyacas/yacas/src/yacasmain.cpp",
"chars": 20791,
"preview": "\n/*\n * Example terminal client for the yacas Computer Algebra library.\n * It is heavily tailored to Unix (Linux), but yo"
},
{
"path": "cyacas/yacas-gui/CMakeLists.txt",
"chars": 7177,
"preview": "set (CMAKE_INCLUDE_CURRENT_DIR ON)\nset (CMAKE_AUTOMOC ON)\n\n\nif (APPLE)\n set(OS_BUNDLE MACOSX_BUNDLE)\nelseif(WIN32)\n "
},
{
"path": "cyacas/yacas-gui/img.qrc",
"chars": 1414,
"preview": "<RCC>\n <qresource prefix=\"/\">\n <file>resources/img/icon.png</file>\n <file>resources/img/splash.png</fil"
},
{
"path": "cyacas/yacas-gui/include/cellproxy.h",
"chars": 628,
"preview": "#ifndef CELLPROXY_H\n#define\tCELLPROXY_H\n\n#include <QtCore/QObject>\n#include <QtWebEngineWidgets/QWebEnginePage>\n\n#includ"
},
{
"path": "cyacas/yacas-gui/include/mainwindow.h",
"chars": 2685,
"preview": "#ifndef MAINWINDOW_H\n#define MAINWINDOW_H\n\n#include <QtCore/QMap>\n#include <QtCore/QVariant>\n\n#include <QtGui/QCloseEven"
},
{
"path": "cyacas/yacas-gui/include/preferences.h",
"chars": 1108,
"preview": "#ifndef PREFERENCES_H\n#define\tPREFERENCES_H\n\n#include <QtCore/QSettings>\n#include <QtWidgets/QApplication>\n\nclass Prefer"
},
{
"path": "cyacas/yacas-gui/include/preferences_dialog.h",
"chars": 526,
"preview": "#ifndef PREFERENCES_DIALOG_H\n#define\tPREFERENCES_DIALOG_H\n\n#include <QtWidgets/QDialog>\n\n#include \"ui_preferences_dialog"
},
{
"path": "cyacas/yacas-gui/include/yacasengine.h",
"chars": 949,
"preview": "#ifndef YACASENGINE_H\n#define YACASENGINE_H\n\n#include <QtCore/QObject>\n\n#include <QtCore/QMutex>\n#include <QtCore/QQueue"
},
{
"path": "cyacas/yacas-gui/include/yacasrequest.h",
"chars": 885,
"preview": "#ifndef YACASREQUEST_H\n#define YACASREQUEST_H\n\n#include <QObject>\n\nclass YacasRequest : public QObject\n{\n Q_OBJECT\npu"
},
{
"path": "cyacas/yacas-gui/include/yacasserver.h",
"chars": 593,
"preview": "#ifndef YACASSERVER_H\n#define YACASSERVER_H\n\n#include <QObject>\n#include <QThread>\n\n#include \"yacasengine.h\"\n\nclass Yaca"
},
{
"path": "cyacas/yacas-gui/resources/CMakeLists.txt",
"chars": 5321,
"preview": "include (ExternalProject)\n\nExternalProject_Add (yacas-gui_vis\n PREFIX external_packages\n URL file://${CMAKE_SOURCE"
},
{
"path": "cyacas/yacas-gui/resources/jquery/jquery.jeditable.autogrow.js",
"chars": 2604,
"preview": "/*\n * Autosize textarea for Jeditable dedicated for YAGY\n *\n *\n */\n \n$.editable.addInputType( 'autogrow', {\n element "
},
{
"path": "cyacas/yacas-gui/resources/jquery/jquery.jeditable.js",
"chars": 24814,
"preview": "/*\n * Jeditable - jQuery in place edit plugin\n *\n * Copyright (c) 2006-2009 Mika Tuupola, Dylan Verheul\n *\n * Licensed u"
},
{
"path": "cyacas/yacas-gui/resources/mathbar/functions.json",
"chars": 6442,
"preview": "{\n \"categories\": {\n \"number\": [\n \"Sqrt\",\n \"Exp\",\n \"Ln\"\n ],\n \"fu"
},
{
"path": "cyacas/yacas-gui/resources/mathbar/functions_parser.js",
"chars": 2222,
"preview": "\"use strict\";\n\nfunction SquareRootParser(outputValue, parameters) {\n return \"Sqrt(\" + outputValue + \")\";\n}\n\n\n\nfunctio"
},
{
"path": "cyacas/yacas-gui/resources/mathbar/mathBar.js",
"chars": 17351,
"preview": "\"use strict\";\n\nMathBar.selectMoreText = \"more\";\nMathBar.functions;\nMathBar.categories;\n\n//VIF - Very Importatnt Function"
},
{
"path": "cyacas/yacas-gui/resources/mathbar/mathbar.css",
"chars": 5112,
"preview": "\n.outside {\n position: relative;\n}\n\n.inside {\n position: absolute;\n right: 2px;\n bottom: 2px;\n}\n\n.radio_grou"
},
{
"path": "cyacas/yacas-gui/resources/webchannel/qwebchannel.js",
"chars": 15657,
"preview": "/****************************************************************************\n**\n** Copyright (C) 2016 The Qt Company Lt"
},
{
"path": "cyacas/yacas-gui/resources/yacas-online.html",
"chars": 21577,
"preview": "<!DOCTYPE html >\n\n<html>\n <head>\n <meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\" />\n "
},
{
"path": "cyacas/yacas-gui/resources/yacas_gui/attic/intput.editable.js",
"chars": 3734,
"preview": "var bluredEditable = null;\n\n\nfunction editableLoad(){\n $( window ).on( 'blur', function(){ if ( bluredEditable !== nu"
},
{
"path": "cyacas/yacas-gui/resources/yacas_gui/yacas_gui.css",
"chars": 1628,
"preview": "body {\n margin: 0;\n overflow-y: scroll;\n}\n\n#Elements {\n border-collapse: collapse;\n width: 100%;\n table-l"
},
{
"path": "cyacas/yacas-gui/resources/yacas_gui/yacas_gui.js",
"chars": 18521,
"preview": "/* global CodeMirror, MathBar, MathJax, Plotly, vis, yacas */\n\n\"use strict\";\n\nvar currentExpression = 1;\nvar numberOfLin"
},
{
"path": "cyacas/yacas-gui/resources/yacas_gui.html",
"chars": 3522,
"preview": "<!DOCTYPE html >\n\n<html>\n <head>\n <meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\" />\n\n "
},
{
"path": "cyacas/yacas-gui/src/cellproxy.cpp",
"chars": 9552,
"preview": "#include \"cellproxy.h\"\n\n#include <QtCore/QJsonDocument>\n#include <QtCore/QVariant>\n\nCellProxy::CellProxy(QWebEnginePage*"
},
{
"path": "cyacas/yacas-gui/src/main.cpp",
"chars": 1410,
"preview": "#include \"mainwindow.h\"\n\n#include <QtCore/QTimer>\n#include <QtGui/QBitmap>\n#include <QtGui/QPixmap>\n#include <QtWidgets/"
},
{
"path": "cyacas/yacas-gui/src/mainwindow.cpp",
"chars": 14138,
"preview": "#include \"mainwindow.h\"\n#include \"cellproxy.h\"\n#include \"preferences_dialog.h\"\n#include \"ui_mainwindow.h\"\n\n#include <QtC"
},
{
"path": "cyacas/yacas-gui/src/preferences.cpp",
"chars": 3208,
"preview": "#include \"preferences.h\"\n\n#include <QtCore/QDir>\n\nPreferences::Preferences(const QApplication& app)\n{\n QDir dir(app.a"
},
{
"path": "cyacas/yacas-gui/src/preferences_dialog.cpp",
"chars": 2507,
"preview": "#include \"preferences_dialog.h\"\n\n#include <QtWidgets/QFileDialog>\n#include <QtWidgets/QMessageBox>\n\nPreferencesDialog::P"
},
{
"path": "cyacas/yacas-gui/src/yacasengine.cpp",
"chars": 5328,
"preview": "#include \"yacasengine.h\"\n\n#include <string>\n\n#include <QtCore/QFile>\n#include <QtCore/QMutexLocker>\n#include <QtCore/QSe"
},
{
"path": "cyacas/yacas-gui/src/yacasrequest.cpp",
"chars": 878,
"preview": "#include \"yacasrequest.h\"\n\nYacasRequest::YacasRequest(QString expr, QObject* parent) :\n QObject(parent),\n _expr(ex"
},
{
"path": "cyacas/yacas-gui/src/yacasserver.cpp",
"chars": 1106,
"preview": "#include \"yacasserver.h\"\n\n#include <QDebug>\n#include <QMutexLocker>\n\nYacasServer::YacasServer(const QString& scripts_pat"
},
{
"path": "cyacas/yacas-gui/ui/mainwindow.ui",
"chars": 14840,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<ui version=\"4.0\">\n <class>MainWindow</class>\n <widget class=\"QMainWindow\" name=\""
},
{
"path": "cyacas/yacas-gui/ui/preferences_dialog.ui",
"chars": 7681,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<ui version=\"4.0\">\n <class>PreferencesDialog</class>\n <widget class=\"QDialog\" nam"
},
{
"path": "cyacas/yacas-gui/winres/yacas_gui.rc",
"chars": 796,
"preview": "#include \"winver.h\"\n#include \"yacas/yacas_version.h\"\n\nVS_VERSION_INFO VERSIONINFO\nFILEVERSION YACAS_VERSION_MAJOR, Y"
},
{
"path": "cyacas/yacas-gui/yacas-gui.desktop",
"chars": 135,
"preview": "[Desktop Entry]\nName=yacas-gui\nComment=Yacas GUI\nExec=yacas-gui\nIcon=yacas-gui\nTerminal=false\nType=Application\nCategorie"
},
{
"path": "cyacas/yacas-kernel/CMakeLists.txt",
"chars": 2046,
"preview": "#\n#\n# This file is part of yacas.\n# Yacas is free software: you can redistribute it and/or modify\n# it under the terms o"
},
{
"path": "cyacas/yacas-kernel/include/base64.hpp",
"chars": 828,
"preview": "/*\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the terms"
},
{
"path": "cyacas/yacas-kernel/include/hmac_sha256.hpp",
"chars": 1188,
"preview": "/*\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the terms"
},
{
"path": "cyacas/yacas-kernel/include/yacas_engine.hpp",
"chars": 1649,
"preview": "/*\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the terms"
},
{
"path": "cyacas/yacas-kernel/include/yacas_kernel.hpp",
"chars": 2793,
"preview": "/*\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the terms"
},
{
"path": "cyacas/yacas-kernel/src/base64.cpp",
"chars": 1699,
"preview": "/*\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the terms"
},
{
"path": "cyacas/yacas-kernel/src/hmac_sha256.cpp",
"chars": 2737,
"preview": "/*\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the terms"
},
{
"path": "cyacas/yacas-kernel/src/main.cpp",
"chars": 1705,
"preview": "/*\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the terms"
},
{
"path": "cyacas/yacas-kernel/src/yacas_engine.cpp",
"chars": 3665,
"preview": "/*\n * This file is part of yacas.\n * Yacas is free software: you can redistribute it and/or modify\n * it under the terms"
}
]
// ... and 402 more files (download for full content)
About this extraction
This page contains the full source code of the grzegorzmazur/yacas GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 602 files (10.5 MB), approximately 2.8M tokens, and a symbol index with 5811 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.