recent notes and CAS thoughts

4 files changed, 170 insertions, 0 deletions

diff --git a/2021/08/homes_and_funding.md b/2021/08/homes_and_funding.md
new file mode 100644
index 0000000..c7154b3
--- /dev/null
+++ b/2021/08/homes_and_funding.md
@@ -0,0 +1,37 @@
+
+## Academia
+
+
+## Research Institutions
+
+NIST
+
+Simons Foundation (NYC)
+
+
+## Large Funders
+
+(whoever funds Julia)
+
+
+## Indie Support
+
+Mozilla Science Labs (and other fellowships/grants)
+
+Recurse Center
+
+Code for Science and Society
+
+
+## Companies
+
+hash.ai
+
+
+## Adjacent Projects
+
+Julia modeling project
+
+biomedical symbolic modeling
+
+modelica
diff --git a/2021/08/models_to_model.md b/2021/08/models_to_model.md
new file mode 100644
index 0000000..44038e0
--- /dev/null
+++ b/2021/08/models_to_model.md
@@ -0,0 +1,7 @@
+
+ride share driver economics vs. taxi economics
+=> with adjustments, etc
+=> "can uber ever deiver" blog series https://www.nakedcapitalism.com/2016/11/can-uber-ever-deliver-part-one-understanding-ubers-bleak-operating-economics.html
+
+
+COVID-19 epi models? at country level?
diff --git a/2021/09/2021-09-11_reading.md b/2021/09/2021-09-11_reading.md
new file mode 100644
index 0000000..5359dce
--- /dev/null
+++ b/2021/09/2021-09-11_reading.md
@@ -0,0 +1,88 @@
+
+## "Computer Algebra Systems" section of wpi.edu History of Calculus
+
+This is the clearest short overview of CAS implementation I have seen. It is a
+bit out of date, and doesn't go very deep, but mentions what appear to be the
+fundamentals: multiple representations (eg, expressions vs. polynomials),
+canonical forms, and term re-writing.
+
+References "Computer Algebra: Systems and Algorithms for Algebraic
+Computations" (1988) by Davenport several times.
+
+Didn't learn anything new, but good reference and resource.
+
+
+## SciML Julia Project
+
+<https://sciml.ai/>
+
+Bunch of folks doing things around ML and modeling using Julia. Julia Computing
+(the company) has a "JuliaSim" product; bunch of pharma folks using these
+tools; etc.
+
+Related stuff:
+
+- https://juliasymbolics.org/ and Symbolics.jl
+- https://github.com/SciML/DataDrivenDiffEq.jl
+- https://discourse.julialang.org/c/domain/models/21
+- https://www.reddit.com/r/SciML/
+- https://sebastiancallh.github.io/post/neural-ode-weather-forecast/
+- https://sciml.ai/news/2021/08/16/juliacon2021/
+- https://juliacomputing.com/products/juliasim/
+- https://sciml.ai/news/2021/08/26/expansion/
+- https://sciml.ai/roadmap/
+- https://sciml.ai/showcase/
+- https://github.com/ModiaSim/Modia.jl
+
+## "Computer Algebra" (1988) by Davenport
+
+"Computer Algebra: Systems and Algorithms for Algebraic Computations"
+
+Copy on IA: <https://archive.org/details/computeralgebras0000dave>
+
+A bit old at this point, but from the table of contents seems to go reasonably
+deep. I think this is basically an overview of how to implement a system like
+Macsyma; not sure how Macsyma-specific it is. Maybe goes a bit deeper and more
+implementation specific than the Cohn books? Eg, more specifics about
+canonicalization and term sorting.
+
+## Cohn Book
+
+Continues to be pretty good. Will probably want to flip/skim through the paired
+book as well.
+
+
+## Other Notes
+
+### Sage Math Symbolics
+
+Sage used to use Maxima, but the external call overhead was too high. Ended up
+switching to GiNaC, which is a C++ library CAS implementation. They actually
+forked as Pynac, a bit confusingly; they want to keep numeric execution
+internal to Sage/python.
+
+### Optimization Model Languages (eg, AMPL)
+
+In the world of optimization problems (eg, in business modeling), there are
+langages like AMPL ("A Mathematical Programming Language") to describe models.
+Not too disimilar from Modelica etc.
+
+The term for these seems to be "Algebraic modeling language", for use in
+mathematical optimization.
+
+<https://en.wikipedia.org/wiki/AMPL#A_sample_model>
+
+### NineML Modeling Languages
+
+For neuroscience: <http://incf.github.io/nineml-spec/>
+
+### Macsyma / Maxima Stuff
+
+"Macsyma’s General Simplifier: Philosophy and Operation" (1979, Richard Fateman)
+
+Maxima can output Fortran, LaTeX, and MathML. The fortan output is very crude
+though, just single expressions, and supports very little.
+
+### insect.sh
+
+Web-based scientific calculator. Syntax/grammar might be interesting to study.
diff --git a/2021/09/learning_cas.md b/2021/09/learning_cas.md
new file mode 100644
index 0000000..a482be5
--- /dev/null
+++ b/2021/09/learning_cas.md
@@ -0,0 +1,38 @@
+
+Started reading "Computer Algebra and Symbolic Computation: Elementary
+Algorithms" by Joel Cohen (2002). This is the somewhat more applied/language
+oriented of two books in a series (the other, "Mathematical Methods",
+apparently dives deeper in to some simplification and manipulation processes).
+
+Currently thinking that implementing a basic schema/s-expr computer algebra
+system would be a good learning exersize, building knowledge and familiarity
+with expression manipulation.
+
+Found [expreduce](https://github.com/corywalker/expreduce), a simple golang
+computer algebra system. Also [mmaclone](https://github.com/jyh1/mmaclone).
+[Blog post](https://corywalker.me/2018/06/03/introduction-to-computer-algebra.html)
+about expreduce, and some documentation of functions which have been
+implemented. Uses syntax, and I assume conventions, of Mathematica.
+
+Via expreduce, found the 'Rubi' integration rule corpus (and basic CAS system)
+by Albert Rich (<http://www.apmaths.uwo.ca/~arich/>). Rich previously worked on
+the CAS built-in to TI-83 calculators!
+
+-----
+
+Specific things learned from CASC:EA book so far:
+
+Internal representations of expressions often involve a stage of simplification
+after parsing an expression. For example, in product expressions, can simplify
+with constraint that none of the members are themselves product expressions,
+and that there is only one rational number member, and it is the first member.
+Division and subtraction are substituded for product-and-negative-power and
+sum-and-negative-product. Presumably additional data structures can be used for
+polynomials, etc.
+
+This initial simplification stage, as part of evaluation, reminds me a bit of
+the tokenization vs. grammar parsing stages of compilation. Eg, where does
+tokenization end and parsing begin.
+
+The 'procedure' definition blocks seem similar to Modelica: Input, Output,
+Local Variables, Begin End.