From 8ef26736271651902ff5d57429148be6510c06ad Mon Sep 17 00:00:00 2001 From: Bryan Newbold Date: Tue, 12 Feb 2019 22:29:56 -0800 Subject: old model thing notes from 2016-2017 --- 2016/background.txt | 97 +++++++++++ 2016/dae_libs.txt | 9 + 2016/julia_libs.txt | 34 ++++ 2016/jupyter_python_example.ipynb | 166 ++++++++++++++++++ 2016/list_of_examples.txt | 77 +++++++++ 2016/modelica33r1_grammar.txt | 347 ++++++++++++++++++++++++++++++++++++++ 2016/modelica_limitations.txt | 2 + 2016/parsing.txt | 8 + 2016/reading.txt | 21 +++ 2016/solve_for.txt | 58 +++++++ 2016/tangle_demo.txt | 31 ++++ 2016/webface.txt | 38 +++++ 12 files changed, 888 insertions(+) create mode 100644 2016/background.txt create mode 100644 2016/dae_libs.txt create mode 100644 2016/julia_libs.txt create mode 100644 2016/jupyter_python_example.ipynb create mode 100644 2016/list_of_examples.txt create mode 100644 2016/modelica33r1_grammar.txt create mode 100644 2016/modelica_limitations.txt create mode 100644 2016/parsing.txt create mode 100644 2016/reading.txt create mode 100644 2016/solve_for.txt create mode 100644 2016/tangle_demo.txt create mode 100644 2016/webface.txt diff --git a/2016/background.txt b/2016/background.txt new file mode 100644 index 0000000..72991e3 --- /dev/null +++ b/2016/background.txt @@ -0,0 +1,97 @@ + +### Previous Work + +"CellML Model Repository" +http://models.cellml.org/cellml + +OpenCell tool for CellML +https://www.cellml.org/tools/opencell + +NeuroML +https://en.wikipedia.org/wiki/NeuroML + +"BioModels Database" +http://www.ebi.ac.uk/biomodels-main/ + +http://www.tinkercell.com/ + +"Cornell Modeling and Simulation Project" +http://www.cs.cornell.edu/Info/Projects/SimLab/ + +Insight Maker +https://insightmaker.com/insight/56411/World3-Model-from-Open-Modelica-Implementation + +### Modeling Software/Languages + +Modelica Language +Simullink (also Scilab/Xcos) +Wolfram SystemModeler + +"Functional Mock-up Interface": C API and XML file format for "co-simulation" + +SysML ("Systems Modeling Language"): UML subset + +Systems Tool Kit +military-industrial 3D modeling... thing... +https://en.wikipedia.org/wiki/Systems_Tool_Kit + +Sims.jl +http://tshort.github.io/Sims.jl/design/ + +https://github.com/casadi/casadi/wiki + +EqWorld: http://eqworld.ipmnet.ru/ + +### Modelica Stuff + +EU spent 75 million on Modelica stuff in 2007-2015. + +"World3 in Modelica: Creating System Dynamics Models in the Modelica Framework" +(2008) + +modelicac: a C compiler for modelica. Implemented in Ocaml. +http://manpages.ubuntu.com/manpages/precise/man1/modelicac.1.html + +Integration into Scilab + +OpenModelica + +PySimulator +https://github.com/PySimulator/PySimulator/ + +Some internal and implementation details are discussed in: +"Introduction to the Dynamic Modelling of Thermo-Fluid Systems using Modelica" +http://staff.polito.it/roberto.zanino/sub1/teach_files/modelica_minicourse/index_modelica.html + +'Flat' vs. 'Object Oriented' modelica modeling +"Consistent terminology: Modeling, DAE, ODE" +http://stackoverflow.com/questions/37354272/consistent-terminology-modeling-dae-ode + +The "Replaceable Submodels" aspect of modelica seems relevant. + +modelica -> C (FMI) -> Javascript (via enscripten) workflow +https://github.com/tshort/openmodelica-javascript + +parsers: + ocaml: https://opam.ocaml.org/packages/modelica_ml/modelica_ml.0.1.1/ + haskell: https://hackage.haskell.org/package/modelicaparser + python: http://kdavies4.github.io/ModelicaRes/ + js: https://www.npmjs.com/package/modelica-parser + js: https://github.com/omuses/moijs + +### GUI/UI For Models + +GME: genric web "box-and-wire" + https://webgme.org/ + +Luna Lang + so far, vaporware + http://www.luna-lang.org/ + +### Other + +"HOW TO SIMULATE THE UNIVERSE IN 134 EASY STEPS" +Nicky Case, 2016 +http://ncase.me/OVC2016/ + +also: http://blog.ncase.me/evolution-not-revolution/ diff --git a/2016/dae_libs.txt b/2016/dae_libs.txt new file mode 100644 index 0000000..762d21b --- /dev/null +++ b/2016/dae_libs.txt @@ -0,0 +1,9 @@ + +##### Solvers/"Codes" + +SUNDIALS + http://computation.llnl.gov/projects/sundials + +DAEPACK + http://yoric.mit.edu/DAEPACK + diff --git a/2016/julia_libs.txt b/2016/julia_libs.txt new file mode 100644 index 0000000..3ab17c8 --- /dev/null +++ b/2016/julia_libs.txt @@ -0,0 +1,34 @@ + +##### Julia Web Framework + +Morsel.jl + Classic web framework paradigm. Use this for the wiki. + http://juliawebstack.org/ + +Escher.jl + Sort of PHP-like single-file UIs. + Might be good for exploration/visualization? + + +##### Julia Markdown Rendering + +Try using the Julia built-in stuff, which seems to support basic LaTeX +rendering. +If that isn't powerful enough, or seems to "custom", switch to pandoc as an +external tool. + + +##### Julia Computer Algebra Stuff + +Use Sims.jl for flattening, etc! Otherwise this will be really hard. + +##### Julia Parser Framework (eg, parser generator) + +Parsimonious.jl + Fairly close to BNF? Good tutorial. Start with this. + +PEGParser.jl + Also pretty BNF-like + +ParserCombinator.jl + More Haskell-like. Meh. diff --git a/2016/jupyter_python_example.ipynb b/2016/jupyter_python_example.ipynb new file mode 100644 index 0000000..b6fdb16 --- /dev/null +++ b/2016/jupyter_python_example.ipynb @@ -0,0 +1,166 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# modelthing + Jupyter Demo\n", + "\n", + "First pull down the compiled python model from the server and `exec()` it to bring the function into our namespace." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import requests\n", + "server = \"http://localhost:5000\"\n", + "model_path = \"examples/newtonian_gravity\"\n", + "req = requests.get(\"%s/m/%s/repr/?format=python\" % (server, model_path))\n", + "exec(req.content)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that `exec` doesn't return anything; it has already inserted a function named \"NewtonianGravitation\" into our current namespace:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1.483111111111111e-11" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "NewtonianGravitation(1,2,3)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function NewtonianGravitation in module __main__:\n", + "\n", + "NewtonianGravitation(m_1, m_2, r)\n", + " Simple/classical Inverse-square law force\n", + " \n", + " Args:\n", + " m_1\n", + " m_2\n", + " r\n", + " \n", + " Returns array of:\n", + " F\n", + "\n" + ] + } + ], + "source": [ + "help(NewtonianGravitation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's use it!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from pylab import *" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhwAAAF5CAYAAADUL/MIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQHYEHAAAIDsCDgAAkN03byJB8t85hwoAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m_pound = 2.2e3 # One pound (lb) in grams\n", + "m_earth = 5.972e24 # Mass of Earth\n", + "r_earth = 6.371e6 # Radius of Earth\n", + "r = frange(r_earth, r_earth*3, r_earth/1000)\n", + "plot(r - r_earth, [NewtonianGravitation(m_pound, m_earth, x) for x in r])\n", + "xlabel(\"Distance from Surface of Earth (meters)\")\n", + "ylabel(\"Gravitational Force\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/2016/list_of_examples.txt b/2016/list_of_examples.txt new file mode 100644 index 0000000..4793a24 --- /dev/null +++ b/2016/list_of_examples.txt @@ -0,0 +1,77 @@ + +- https://en.wikipedia.org/wiki/Solow%E2%80%93Swan_model +- e = mc2 +- carnot's theorem ( W <= Q_H ( 1 - Tc/Th) +- maxwell's equations +- Riemann zeta function +- NOWAK'S EVOLVABILITY +- ISLAND BIOGEOGRAPHY +- compound interest +- nyquist frequency / limit +- shannon capacity +- tupper's self-referential formula + + +Newer list: +- https://en.wikipedia.org/wiki/Radioactive_decay#One-decay_process +- https://en.wikipedia.org/wiki/Hodgkin%E2%80%93Huxley_model +- logistic function +- Black–Scholes +- https://en.wikipedia.org/wiki/Sethi_model +- von Bertalanffy growth equation + +### Models + +Simple, equation based: +- classic predator-prey (Lotka–Volterra) +- attractors +- that vegan paper +- whatever Fe is the minimal of (function of protons/neutrons? discrete) +- urban subsidized housing (thinking in systems) +- Pulse Tube Cooler +- Hodgkin–Huxley model for neurons +x Uranium Critical Mass (meh, too complicated) +- black body (thermal emission) +- compton scattering +- Schwarzschild Radius +- three-body, eg + http://nbviewer.jupyter.org/github/pjpmarques/Julia-Modeling-the-World/blob/master/Three-Body%20Problem.ipynb + +Not-Time-Oriented +- high-precision model for water (enthalpy, etc) + +Economics: +- rent control +- supply/demand curve +- World3 +- https://en.wikipedia.org/wiki/Category:Economics_models + +Harder, Time/State Based: +- Schmitt trigger (hysteresis) + +Environment/Energy: +- pretty much everything from Sustainable w/o Hot Air + +### Non-Model (?) Equations +- logistic function +- statistical distributions +- volume or surface area of platonic solids + +http://equator.memeschemes.com/equation/ +https://en.wikipedia.org/wiki/Category:Equations + +### Constants + + + +https://www.wikidata.org/wiki/Q173227 (physical constant) + +### Units + +https://www.wikidata.org/wiki/Q15088658 (measured value) + +### Existing / Import +- World3 (from limits to growth report) +- Tennessee Eastman Process Control Challenge Problem + http://yoric.mit.edu/DAEPACK/Examples/Eastman +- OpenWorm (in NeuroML) diff --git a/2016/modelica33r1_grammar.txt b/2016/modelica33r1_grammar.txt new file mode 100644 index 0000000..2df42dd --- /dev/null +++ b/2016/modelica33r1_grammar.txt @@ -0,0 +1,347 @@ +# These come directly the Modelica 3.3 Spec, Appendix B + +## B.1 Lexical Convetions + +IDENT = NONDIGIT { DIGIT | NONDIGIT } | Q-IDENT +Q-IDENT = "’" ( Q-CHAR | S-ESCAPE ) { Q-CHAR | S-ESCAPE } "’" +NONDIGIT = "_" | letters "a" to "z" | letters "A" to "Z" +STRING = """ { S-CHAR | S-ESCAPE } """ +S-CHAR = any member of the Unicode character set (http://www.unicode.org; see Section 13.2.2 for storing as UTF-8 on files) except double-quote """, and backslash "\" +Q-CHAR = NONDIGIT | DIGIT | "!" | "#" | "$" | "%" | "&" | "(" | ")" | "*" | "+" | "," | "-" | "." | "/" | ":" | ";" | "<" | ">" | "=" | "?" | "@" | "[" | "]" | "^" | "{" | "}" | "|" | "~" | " " +S-ESCAPE = "\’" | "\"" | "\?" | "\\" | "\a" | "\b" | "\f" | "\n" | "\r" | "\t" | "\v" +DIGIT = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" +UNSIGNED_INTEGER = DIGIT { DIGIT } +UNSIGNED_NUMBER = UNSIGNED_INTEGER [ "." [ UNSIGNED_INTEGER ] ] [ ( "e" | "E" ) [ "+" | "-" ] UNSIGNED_INTEGER ] + +## B.2 Grammar + +### B.2.1 + +stored_definition: + [ within [ name ] ";" ] + { [ final ] class_definition ";" } + +### B.2.2 Class Definition + +class_definition : + [ encapsulated ] class_prefixes + class_specifier + +class_prefixes : + [ partial ] + ( class | model | [ operator ] record | block | [ expandable ] connector | type | + package | [ ( pure | impure ) ] [ operator ] function | operator ) + +class_specifier : + long_class_specifier | short_class_specifier | der_class_specifier + +long_class_specifier : + IDENT string_comment composition end IDENT + | extends IDENT [ class_modification ] string_comment composition + end IDENT + +short_class_specifier : + IDENT "=" base_prefix name [ array_subscripts ] + [ class_modification ] comment + | IDENT "=" enumeration "(" ( [enum_list] | ":" ) ")" comment + +der_class_specifier : + IDENT "=" der "(" name "," IDENT { "," IDENT } ")" comment + +base_prefix : + type_prefix + +enum_list : + enumeration_literal { "," enumeration_literal} + +enumeration_literal : + IDENT comment + +composition : + element_list + { public element_list | + protected element_list | + equation_section | + algorithm_section + } + [ external [ language_specification ] + [ external_function_call ] [ annotation ] ";" ] + [ annotation ";" ] + +language_specification : + STRING + +external_function_call : + [ component_reference "=" ] + IDENT "(" [ expression_list ] ")" + +element_list : + { element ";" } + +element : + import_clause | + extends_clause | + [ redeclare ] + [ final ] + [ inner ] [ outer ] + ( ( class_definition | component_clause) | + replaceable ( class_definition | component_clause) + [constraining_clause comment]) + +import_clause : + import ( IDENT "=" name | name ["." ( "*" | "{" import_list "}" ) ] ) comment + +import_list : + IDENT { "," IDENT } + +### B.2.3 Extends + +extends_clause : + extends name [ class_modification ] [annotation] + +constraining_clause : + constrainedby name [ class_modification ] + +### B.2.4 Component Clause + +component_clause: + type_prefix type_specifier [ array_subscripts ] component_list + type_prefix : + [ flow | stream ] + [ discrete | parameter | constant ] [ input | output ] + +type_specifier : + name + +component_list : + component_declaration { "," component_declaration } + +component_declaration : + declaration [ condition_attribute ] comment + +condition_attribute: + if expression + +declaration : + IDENT [ array_subscripts ] [ modification ] + +### B.2.5 Modification + +modification : + class_modification [ "=" expression ] + | "=" expression + | ":=" expression + +class_modification : + "(" [ argument_list ] ")" + +argument_list : + argument { "," argument } + +argument : + element_modification_or_replaceable + | element_redeclaration + element_modification_or_replaceable: + [ each ] [ final ] ( element_modification | element_replaceable) + +element_modification : + name [ modification ] string_comment + +element_redeclaration : + redeclare [ each ] [ final ] + ( ( short_class_definition | component_clause1) | element_replaceable ) + +element_replaceable: + replaceable ( short_class_definition | component_clause1) + [constraining_clause] + +component_clause1 : + type_prefix type_specifier component_declaration1 + +component_declaration1 : + declaration comment + +short_class_definition : + class_prefixes short_class_specifier + +### B.2.6 Equations + +equation_section : + [ initial ] equation { equation ";" } + +algorithm_section : + [ initial ] algorithm { statement ";" } + +equation : + ( simple_expression "=" expression + | if_equation + | for_equation + | connect_clause + | when_equation + | name function_call_args ) + comment + +statement : + ( component_reference ( ":=" expression | function_call_args ) + | "(" output_expression_list ")" ":=" component_reference function_call_args + | break + | return + | if_statement + | for_statement + | while_statement + | when_statement ) + comment + +if_equation : + if expression then + { equation ";" } + { elseif expression then + { equation ";" } + } + [ else + { equation ";" } + ] + end if + +if_statement : + if expression then + { statement ";" } + { elseif expression then + { statement ";" } + } + [ else + { statement ";" } + ] + end if + +for_equation : + for for_indices loop + { equation ";" } + end for + +for_statement : + for for_indices loop + { statement ";" } + end for + +for_indices : + for_index {"," for_index} + +for_index: + IDENT [ in expression ] + while_statement : + while expression loop + { statement ";" } + end while + +when_equation : + when expression then + { equation ";" } + { elsewhen expression then + { equation ";" } } + end when + +when_statement : + when expression then + { statement ";" } + { elsewhen expression then + { statement ";" } } + end when + +connect_clause : + connect "(" component_reference "," component_reference ")" + +### B.2.7 Expressions + +expression : + simple_expression + | if expression then expression { elseif expression then expression } + else expression + +simple_expression : + logical_expression [ ":" logical_expression [ ":" logical_expression ] ] + +logical_expression : + logical_term { or logical_term } + +logical_term : + logical_factor { and logical_factor } + +logical_factor : + [ not ] relation + +relation : + arithmetic_expression [ rel_op arithmetic_expression ] + +rel_op : + "<" | "<=" | ">" | ">=" | "==" | "<>" + +arithmetic_expression : + [ add_op ] term { add_op term } + +add_op : + "+" | "-" | ".+" | ".-" + +term : + factor { mul_op factor } + +mul_op : + "*" | "/" | ".*" | "./" + +factor : + primary [ ("^" | ".^") primary ] + +primary : + UNSIGNED_NUMBER + | STRING + | false + | true + | ( name | der | initial ) function_call_args + | component_reference + | "(" output_expression_list ")" + | "[" expression_list { ";" expression_list } "]" + | "{" function_arguments "}" + | end + +name : + [ "." ] IDENT { "." IDENT } + +component_reference : + [ "." ] IDENT [ array_subscripts ] { "." IDENT [ array_subscripts ] } + +function_call_args : + "(" [ function_arguments ] ")" + function_arguments : + function_argument [ "," function_arguments | for for_indices ] + | named_arguments + +named_arguments: + named_argument [ "," named_arguments ] + +named_argument: + IDENT "=" function_argument + +function_argument : + function name "(" [ named_arguments ] ")" | expression + +output_expression_list: + [ expression ] { "," [ expression ] } + +expression_list : + expression { "," expression } + +array_subscripts : + "[" subscript { "," subscript } "]" + +subscript : + ":" | expression + +comment : + string_comment [ annotation ] + +string_comment : + [ STRING { "+" STRING } ] + +annotation : + annotation class_modification + diff --git a/2016/modelica_limitations.txt b/2016/modelica_limitations.txt new file mode 100644 index 0000000..5c4294d --- /dev/null +++ b/2016/modelica_limitations.txt @@ -0,0 +1,2 @@ +Double derivative (eg, "der(der(x)) = a") is not allowed. +Partial derivatives are not allowed. diff --git a/2016/parsing.txt b/2016/parsing.txt new file mode 100644 index 0000000..a3c29ef --- /dev/null +++ b/2016/parsing.txt @@ -0,0 +1,8 @@ + +Parser Refs: +http://notes.willcrichton.net/parsing-strategies-in-rust/ +http://smallcultfollowing.com/babysteps/blog/2015/09/14/lalrpop/ +https://github.com/nikomatsakis/lalrpop/ + + +libsyntax: rust lib for parsing rust itself diff --git a/2016/reading.txt b/2016/reading.txt new file mode 100644 index 0000000..87dec4c --- /dev/null +++ b/2016/reading.txt @@ -0,0 +1,21 @@ + +"Meta-Languages and Semantics for Equation-Based Modeling and Simulation" + David Broman + "Modeling Kernel Language" thesis, also a bunch of Modelica + +"Modelyze: a Gradually Typed Host Language for Embedding Equation-Based Modeling Languages" + David Broman and Jeremy G. Siek + modelyze tool is successor to MKL + +Modelica Spec + PDF or http://modelica.readthedocs.io/ + +µ-Modelica Language Specification + +"Modelica by Example" + http://book.xogeny.com/ + +"Introduction to the Dynamic Modelling of Thermo-Fluid Systems using Modelica" + "minicourse" + http://staff.polito.it/roberto.zanino/sub1/teach_files/modelica_minicourse/index_modelica.html + eg, "Properties of Differential-Algebraic Equation Systems (DAE)" (slides) diff --git a/2016/solve_for.txt b/2016/solve_for.txt new file mode 100644 index 0000000..b1cf81d --- /dev/null +++ b/2016/solve_for.txt @@ -0,0 +1,58 @@ + + x = a*y + c + y = 4 * c + + solve for [c] in terms of [a, x] + first solve for other unknowns: [y] + + x = a*(4*c) + c + + x = c * (1 + 4*a) + c = (1 + 4*a) / x + +N equations in M unknowns, P constants + + 0 = x + y + 0 = y*2 + 1 - x + +----------------------------------- + +solve_for(self, P: Vec, M: Vec, Q: HashMap) + + +returns a ModelicaModel with fixed components; equations are LHS identifier, in + correct order, no extends, no connections, name suffixed " (rewritten)", + components as Parameter (w/ val), Input, or Output + + +V variables +Q constants (become kwargs) +P bound vars (independent, inputs/passed, become like constants) +M unknowns (dependent, outputs) +N' total equations +N equations with unknowns + + V = Q + P + M + check: each Q is Integer or Float UnderSpecifiedConstant + filter N' to get N OverConstrained if extra equations + check: N >= M UnderConstrained + +while len(eqns) > 0: + 1. find first eqn with single unknown, and pop it + 2. rebalance to get unknown on LHS + 3. remove unknown from unknown list + +return: sort equations to match order + +solve_for(var) impl for SimpleEquation => Result + check: var only on one side VariableNotFound or NaiveImplementation + put var on LHS + recursively apply rules to symmetrically unwrap LHS onto RHS + if try to unwrap Abs: NaiveImplementation + +----------------------------------- +systems of differential equations: + will be N equations of N variables, in terms of implied time + +should be no unknowns; odex thing is just varying initial equations +have JS boxes to show ranges of initial conditions diff --git a/2016/tangle_demo.txt b/2016/tangle_demo.txt new file mode 100644 index 0000000..463abe1 --- /dev/null +++ b/2016/tangle_demo.txt @@ -0,0 +1,31 @@ + + +/experiments/%model/tangle.html +/experiments/%model/tangle-model.js + + + +this part in body's onLoad; after live script has downloaded. +var table = new Tangle (document.getElementById("MODELNAME"), { + initialize: function () { + this.CONSTANT = INIT; + this.IN_VAR = INIT; + }, + update: function () { + var vals = model(); + this.OUT_VAR = vals[0]; + this.OUT_VAR = vals[1]; + [...] + }, +}); + +

+ + +When the parameters are for VARSLUG, [...], + and the variables are + for VAR, then you get for OUTVAR + + + diff --git a/2016/webface.txt b/2016/webface.txt new file mode 100644 index 0000000..78306bd --- /dev/null +++ b/2016/webface.txt @@ -0,0 +1,38 @@ + +### Basic Viewing and Editing +- pencil.rs for basic framework? +- tera for jinja2 (or just use pencil's handlebars default) +- generic style: http://bootswatch.com/simplex/ + +editing markdown etc: +- https://github.com/benweet/stackedit: markdown, very fancy +- https://ace.c9.io: simple code-oriented +- http://dillinger.io/ +- https://github.com/benweet/stackedit +- vue.js + +### Dynamic Essay + +http://worrydream.com/Tangle/guide.html +hyperphysics + +#### Charting/Rendering + +plotly.js: d3.js and stack.gl + https://plot.ly/javascript/ + https://github.com/plotly/plotly.js + + +##### GUI Demos + +numeric.js + Has an ODE solver. Use with Elm? + +Tangle.js + Brett's JS widget-y thing. Very simple. + How did he do plots/graphs for those demos? + http://worrydream.com/Tangle/guide.html + +KaTeX LaTeX rendering + Faster than mathjax? + https://github.com/Khan/KaTeX -- cgit v1.2.3