QuantumSheet - A user friendly mathematics worksheet and solver
Home Page: https://stefnotch.github.io/quantum-sheet/
License: GNU General Public License v3.0
QuantumSheet - A user friendly mathematics worksheet and solver
I would really love to develop this project much further and am looking for collaborators. If you want to give it a shot, just respond here #14
npm installnpm run download:pyodidenpm run devCheck out CONTRIBUTING.md for more
If we want to run user-supplied code, we have a few different options to explore
Some interesting stuff regarding name resolution and scopes
https://github.com/github/stack-graphs
https://pl.ewi.tudelft.nl/research/projects/scope-graphs/
We have to wait for the next compute-engine version https://cortexjs.io/docs/compute-engine/#(ParseLatexOptions%3Atype)
Compute-engine: parser should recognize unknown functions (like silly())
so, basically
From Gitter
@stefnotch you can provide a parse function for xrightarrow that would parse for valid functions in the "above" argument.
Arno Gourdol
@arnog
12:16
For recursive functions, you have two options I can think of: use the parseUnknownToken option in the LatexSyntax parser to recognize foo as a function token.
The second option would be for the definition of the := operator to create a scope (using ce.pushScope()) with a custom definition for the foo symbol. This gives you more flexibility (such as defining a domain, an argument list, etc...) in defining the symbol.
I want a flexible approach for working with stuff like arrays, tables, and piecewise functions. Instead of following a set procedure, the user gives constraints and possible solutions are returned. This issue's just on arrays and iteration.
The Fibonacci numbers would usually be created iteratively like this:
Fib=[]
Fib[0]=0
Fib[1]=1
for (i=2;i<5;i++){
Fib[i]=Fib[i-1]+Fib[i-2]
}
Instead I’m proposing something like this (these are all equations in a system, order does not matter):
Fib[0]=0
Fib[1]=1
Fib[i]=Fib[i-1]+Fib[i-2]
2<=i<5
Which can then be solved:
Fib=[0,1,1,2,3]
This allows you to use any piece of information. For example if you want to make something following the rules of Fibonacci numbers but the 5th element is 6 instead, you would just do:
Fib[0]=0
Fib[4]=6
Fib[i]=Fib[i-1]+Fib[i-2]
2<=i<5
This would return:
Fib=[0,3,3,6]
This would be useful for engineering applications, where what is known and unknown varies from case to case. For example, the total pressure from soil layers is determined by adding the weight from each layer:
SoilLayers
p=rho*g*h
p_cum[i+1]=p_cum[i]+p[i]
If instead you wanted to find the depth required to get to a certain pressure with two soil layers, for example, you could do:
SoilLayers
rho=[1200,1700]
g=9.8
h=[15,depth-15]
p_cum[0]=0
p_cum[2]=20000
Basically, by building it around solving systems of equations, you are not constrained to a set of input or outputs as you would be using loops.
A similar approach could be used for piecewise functions and tables, which I could show in another issue.
I think the main challenge is to figure out exactly how the program should interpret arrays and how it should convert it to systems of equations.
When parsing or serializing an expression, we need to get all the currently defined variables and add them to the dictionary. That way, cat := 3 followed by cat = will work correctly
https://github.com/daybrush/moveable is an interesting library
I took a look at this and there are two quite reasonable options:
\\solve, \\factor, and \\expand to the dictionary like you suggested. If we do that, then we should also make it possible to call them like \\solve(3x+5==5, x)I would really love to develop this project much further and am looking for collaborators. If you want to give it a shot, just respond to this issue.
Discord server: https://discord.gg/xatHjgW
It'd be quite sweet if this site worked in offline mode as well.
It would be nice to periodically save a backup of the document in an indexeddb. That way, if something crashes or goes horribly wrong, not all is lost.
It'd be pretty useful if one could type text in quotes. Like "this function does a+b"
Ideally it would be possible to use QuantumSheet to take or write notes in realtime. I just saw some post about someone doing so with very different tools, but the general idea very much applies.
https://castel.dev/post/lecture-notes-3/
https://castel.dev/post/lecture-notes-1/
Basically, put a heavily compressed version into the URL. Heavily compressed probably also means serializing the mathematics as LaTeX instead of MathJSON.
Useful sources:
https://github.com/stefnotch/starboard-editor
https://github.com/qntm/base65536
https://github.com/KilledByAPixel/JSONCrush
This is an attempt to document and create a running list all the desired mathematical Functions, Constants, and Evaluations.
This issue is aimed at Sympy but the list should be compatible with or easily inclusive to competitive CASs.
https://en.wikipedia.org/wiki/Template:Areas_of_mathematics
https://en.wikipedia.org/wiki/Glossary_of_mathematical_symbols
https://cortexjs.io/compute-engine/guides/dictionaries/
| MathJSON | MathJSON -> Sympy | Sympy -> MathJSON |
|---|---|---|
| MathJSON name | Sympy function name | Sympy printer function/name |
| (checked if fully tested) | (checked if implemented) | (checked if implemented) |
| Arithmatic | ||
| ☒ Parentheses | ☒ | ☒ |
| ☒ Add | ☒ Sympy.Add | ☒ _print_Add |
| ☒ Subtract | ☒ Sympy.Add(x,sympy.mul(y,-1)) | ☒ |
| ☐ Negate (*-1) | ☒ | ☐ |
| ☒ Multiply | ☒ Sympy.Mul | ☒ |
| ☒ (Divide) | ☒ | ☒ |
| ☒ Power | ☒ Sympy.Pow | ☒ |
| ☐ Root | ☒ sympy.root | ☐ |
| ☐ Sqrt * | ☒ Sympy.sqrt | ☒ Sqrt (capital s?) |
| ☐ Square | ☐ | ☐ |
| ☐ Exp * | ☐ | ☐ exp |
| ☐ | ☐ | ☐ |
| Algebra | ||
| ☐ Log * | ☐ | ☒ ln |
| ☐ Log2 * | ☐ | ☒ log2 |
| ☐ Log10 * | ☐ | ☒ log10 |
| ☐ LogOnePlus | ☐ | ☒ log1p |
| ☐ Abs * | ☒ Sympy.Abs | ☐ |
| ☐ Ceil * | ☐ | ☒ ceiling |
| ☐ Chop | ☐ | ☐ |
| ☐ Floor * | ☐ | ☒ floor |
| ☐ Round | ☐ | ☐ |
| ☐ Factorial | ☒ sympy.factorial | ☒ factorial |
| ☐ | ☐ | ☐ |
| Trigonometry | ||
| ☒ Sin | ☒ sympy.sin | ☒ sin |
| ☒ Cos | ☒ sympy.cos | ☒ cos |
| ☒ Tan (defaults to tg?) | ☒ sympy.tan | ☒ tan |
| ☐ Sec | ☒ sympy.sec | ☒ sec |
| ☐ Csc | ☒ sympy.csc | ☒ csc |
| ☐ Cot | ☒ sympy.cot | ☒ cot |
| ☒ Arcsin** | ☒ Sympy.asin | ☒ asin |
| ☒ Arccos** | ☒ Sympy.acos | ☒ acos |
| ☒ Arctan** | ☒ Sympy.atan | ☒ atan |
| ☒ Arctan2** | ☒ sympy.atan2 | ☒ atan2 |
| ☐ Asec** | ☒ Sympy.asec | ☒ asec |
| ☐ Acsc** | ☒ Sympy.acsc | ☒ acsc |
| ☐ Acot** | ☒ Sympy.acot | ☒ acot |
| ☒ Sinh | ☒ Sympy.sinh | ☒ sinh |
| ☒ Cosh | ☒ Sympy.cosh | ☒ cosh |
| ☒ Tanh | ☒ Sympy.tanh | ☒ tanh |
| ☐ Sech** | ☒ Sympy.sech | ☒ sech |
| ☐ Csch** | ☒ Sympy.csch | ☒ csch |
| ☐ Coth** | ☒ Sympy.coth | ☒ coth |
| ☒ Arsinh** | ☒ Sympy.asinh | ☒ asinh |
| ☒ Arcosh** | ☒ Sympy.acosh | ☒ acosh |
| ☒ Artanh** | ☒ Sympy.atanh | ☒ atanh |
| ☐ Asech** | ☒ Sympy.asech | ☒ asech |
| ☐ Acsch** | ☒ Sympy.acsch | ☒ acsch |
| ☐ Arcoth** | ☒ Sympy.acoth | ☒ acoth |
| ☐ Degrees | ☐ | ☐ |
| ☐ FromPolarCoordinates | ☐ | ☐ |
| ☐ ToPolarCoordinates | ☐ | ☐ |
| ☐ Hypot ** | ☐ | ☐ |
| ☐ Haversine | ☐ | ☐ |
| ☐ InverseHaversine | ☐ | ☐ |
| ☐ | ☐ | ☐ |
| Calculus | ||
| ☐ Integrate * | ☐ | ☐ _print_Integral |
| ☐ Derivative/Prime (D, ') * | ☐ | ☐ _print_Derivative |
| ☐ (Partial Derivative) | ☐ | ☐ |
| ☐ (Limit - lim(f,x,a)?) | ☐ | ☐ _print_Limit |
| ☐ (SumSeries) | ☐ | ☐ _print_Sum |
| ☐ (Product of Sequence- CapitalPi) | ☐ | ☐ |
| ☐ | ☐ | ☐ |
| Linear Algebra | ||
| ☐ (System of Equations) | ☐ | ☐ |
| ☐ (EigenValues) | ☐ | ☐ |
| ☐ (EigenVectors) | ☐ | ☐ |
| ☐ (Matricies) | ☐ | ☐ |
| ☐ (Vectors) | ☐ | ☐ |
| Matrix Operations | ||
| ☐ (Matrix Define) | ☐ | ☐ |
| ☐ (Addition) | ☐ | ☐ |
| ☐ (Multiplication) | ☐ | ☐ _print_MatMul ? |
| ☐ (Transpose) | ☐ | ☐ _print_Transpose |
| ☐ (Multiplication) | ☐ | ☐ |
| ☐ (Power) | ☐ | ☐ _print_MatPow ? |
| ☐ (Normal) | ☐ | ☐ |
| Logic/Relational | ||
| ☐ True** | ☐ | ☐ _print_BooleanTrue |
| ☐ False** | ☐ | ☐ _print_BooleanFalse |
| ☐ Maybe** | ☐ | ☐ |
| ☐ And | ☐ | ☐ _print_And |
| ☐ Or | ☐ | ☐ _print_Or |
| ☐ (Xor) | ☐ | ☐ _print_Xor |
| ☐ Not | ☐ | ☐ _print_Not |
| ☐ Equivalent (\equiv) | ☐ | ☐ |
| ☐ Implies | ☐ | ☐ |
| ☐ Equal (taken) | ☐ | ☐ |
| ☐ NotEqual | ☐ | ☐ |
| ☐ GreaterEqual | ☐ sympy.GreaterThan | ☐ |
| ☐ LessEqual | ☐ sympy.LessThan | ☐ |
| ☐ Greater | ☐ sympy.GreaterThanStrict | ☐ |
| ☐ Less | ☐ sympy.LessThanStrict | ☐ |
| ☐ | ☐ | ☐ |
| Special | ||
| ☐ Gamma | ☒ sympy.gamma | ☒ gamma |
| ☐ LogGamma | ☒ sympy.loggamma | ☒ loggamma |
| ☐ Erf | ☒ sympy.erf | ☒ erf |
| ☐ Erfc | ☒ sympy.erfc | ☒ erfc |
| ☐ EulerGamma | ☒ Sympy.EulerGamma | ☒ _print_EulerGamma |
| ☐ | ☐ | ☐ |
| Misc | ||
| ☐ List | ☐ | ☐ _print_list |
| ☐ Set | ☐ | ☐ _print_set |
| ☐ Lambda | ☐ sympy.Lambda | ☐ _print_Lambda |
| ☐ InverseFunction | ☐ | ☐ _print_Inverse ? |
| ☐ Parse (Latex) | ☐ | ☐ |
| ☐ String | ☐ | ☐ |
| ☐ | ☐ | ☐ |
| ☐ | ☐ | ☐ |
* MathLive broken at the moment? Usually happens when the expression is converted to latex then parsed back.
** MathLive Unsupported
http://www.ebyte.it/library/educards/constants/ConstantsOfPhysicsAndMath.html
https://cortexjs.io/mathlive/reference/commands/
| MathJSON | MathJSON -> Sympy | Sympy -> MathJSON |
|---|---|---|
| Mathematical | ||
| ☒ Pi | ☒ Sympy.pi | ☒ _print_Pi |
| ☒ ImaginaryUnit (\imaginaryI) | ☒ Sympy.I | ☒ _print_ImaginaryUnit |
| ☒ ExponentialE (\exponentialE) | ☒ Sympy.E | ☒ _print_Exp1 |
| ☐ GoldenRatio | ☒ Sympy.GoldenRatio | ☒ _print_GoldenRatio |
| ☐ (Infinity) | ☐ | ☐ _print_Infinity |
| ☐ (-Infinity) | ☐ | ☐ _print_NegativeInfinity |
| ☐ | ☐ | ☐ _print_TribonacciConstant |
| ☐ (NaN) | ☐ | ☐ _print_NaN |
| ☐ | ☐ | ☐ |
Some examples: https://docs.sympy.org/latest/tutorial/simplification.html#simplification
This list is nowhere near complete.
Please comment with more expressions you wish to see supported
When a computation takes very long, it should be possible to stop it. I'd prefer to not have to .terminate() the web worker for that.
Relevant issues
This looks interesting https://asymptote.sourceforge.io/
Example:
>>> _HI = sympy.symbols('a')
>>> sympy.expand(sympy.Pow(sympy.Add(_HI,sympy.Float(1)),sympy.Float(2)))
(a + 1.0)**2.0
>>> sympy.expand(sympy.Pow(sympy.Add(_HI,sympy.Float(1)),sympy.Integer(2)))
a**2 + 2.0*a + 1.0
>>>
My approach is to use just equality, solve and substitute for algebraic manipulation. I think that would be sufficient and make it simple to use. as well as easy to build off of.
I know this is very different from the MathCAD approach, so we'll have to figure out what would work best.
Each block contains a system of equations. The user types stuff in on the left side and the result is shown on the right side. Farther right than that, it could potentially show numeric results if there are any.
For each line in the block, you can type an equation or the name of another block. In this way, you can create nested scopes, where in this case, Block2 has access to Block1 and Block3 has access to Block2 and Block1.
Numeric evaluation would occur automatically on the result side:
The equivalent of assignment can be performed as shown:
which is analogous to:
The equivalent of functions would be created as shown:
The advantage of this is that the "function" can consist of a system of equations and you could solve for any variable. I think this would be useful if we want to make libraries for engineering, where we would write the equations, and the user would choose how to combine them and what to solve for.
A list of non-browser based applications that use Sympy
Some functions are best implemented as actual, programmatic algorithms (warning: XSS and more applies here).
For example, a number parser function parse(0x34) would best be done with actual code. It'd be lovely if we eventually could support defining such functions.
Relevant sympy custom functions documentation:
https://docs.sympy.org/latest/modules/functions/index.html
There is this edge case where an expression first refers to an undefined variable (a bit like a unit).
Then, the variable gets defined.
And then we try to re-evaluate the expression by putting more = signs at the end
The place where it needs to be fixed is
// TODO: This can result in more getters existing
https://github.com/pyodide/pyodide/releases
eval_code now accepts separate globals and locals parameters
Added the pyodide.setInterruptBuffer API. This can be used to set a SharedArrayBuffer to be the keyboard interupt buffer. If Pyodide is running on a webworker, the main thread can signal to the webworker that it should raise a KeyboardInterrupt by writing to the interrupt buffer
I'd almost wait for worker modules to get implemented in Firefox
Mathlive's current approach to fonts is, uh, funky. Basically, this needs to get fixed arnog/mathlive#508
I've decided to useXY() to create anything ranging from a document to an expression element. This returns a state and some functions to modify it. Then, to keep a reference to it, I'm always using shallow references shallowRef or shallowReactive<Set>.
Focusing and selection have now also been refactored into their own, internal composition function.
To use this nested structure in the UI layer without mutating props, I'm only passing the element ID to the components and then looking up the element based on that ID.
https://graspablemath.com/learn/canvas-basics is pretty cute
It might be worthwhile to support something like
@graph to insert a graph
@text to insert a text-block
@latex to insert a latex-block, where the LaTeX will not be evaluated
and so on
This bug sympy/sympy#18584 is basically a blocker to the adoption of UnevaluatedExpr. So, using things like Add(2, 4, evaluate=False) is what I'm going to do.
pi := 3 should work and actually assign a different value to the variable named pi. That variable should then be useable in the document and should have the value 3.
One thing that we should eventually support in QuantumSheet https://www.wolframalpha.com/input/?i=Integrate%5BExp%5B-%28x%2B1%2F2%29%5E2%5D%2C%7Bx%2C-Infinity%2CInfinity%7D%5D
Is the
\when you pressEscintentional?
It switches between the normal mode and the command mode. Replace that with a Esc to escape command mode and Esc to escape the mathfield.
This might be a bit annoying.
When you want to make the:=and type[:] -> [something else] -> [Backspace] -> [=], it doesn't make it.
Yep, that's annoying. I'll have to fix that.
If you don't need the colon for anything else, you could make it like MathCAD does, so you only need to type
:.
Good idea. That would also make typing :=[Backspace] less annoying.
Other than that, it's just that when you type something, it's not at the position of the cursor, but rather quite a bit below.
Yeah, true
Brackets are broken
Uhhh, seems like it.
Typing
tandoesn't work. However, typinga*tanworks
Typing
\tanand then clicking somewhere else results doesn't work
Units would be great to include, and would make it much more useful for engineering.
Check out https://github.com/sharkdp/insect
I think requiring the user to import the units they want to use would be a bit annoying. Instead I think there should be a way for the user to indicate they are typing a unit; this would also avoid ambiguities.
Here's some possibilities:
If we have a result section on the right side, the units could be displayed with a separate color, similar to how SwiftCalcs shows units.
It should check whether the unit typed makes sense. If the user types in {m/s^2}:
It should also check for dimensional consistency of the equation (e.g. LHS and RHS have same dimensions, added values have same dimensions, exponents are dimensionless), and the output should have the proper dimensions. I have code for this, which produces and solves equations for dimensional consistency. I will need to modify it a bit to have it work for this project.
The user should be able to change the units of the output to one of the same dimension. SwiftCalcs has a nice interface for this.
For now, I think we could focus on Mass, Length, and Time units although we could extend to all seven basic quantities (Mass, Length, Time, Current, Luminosity, Temperature, and Amount).
We definitely should have SI units. Especially if we want to make this useful for engineering, we should also include important U.S. customary units.
Maybe something like this (inspired by MathCad, I think)
An element has 3 states: unselected, focused and selected
No selection, no editing
When editing the element
When explicitly selecting the element
The mathematics input should support the following features
3+4\xrightarrow{\begin{equation}cat \\ neko \\ lol\end{equation}}7)Maybe contributing to https://github.com/arnog/mathlive would get me closer to a decent editor
Or even real time collaboration: https://github.com/yousefed/SyncedStore which is based on https://github.com/yjs/yjs
Originally posted by @phcreery in #41 (comment)
Use SharedArrayBuffer + some form of locking to pass messages to web workers. That way, nothing has to be copied and everything is always available.
https://pyodide.org/en/stable/usage/api/js-api.html#PyProxy.getBuffer
The text input thingy should support
This issue is mostly to document which other interesting math editors are out there. Feel free to suggest or add more!
Website
Desktop
Much simpler
(Note: To keep the size reasonable, less-ideal or outdated editors will be purged)
Future optimizations would be knowing all the different Python functions that can get called and having "callbacks" for them instead of using pyodide.runPython. Basically, executing actual functions instead of eval-ing code.
Relevant
Module.hiwire_new_value and Module.__pyproxy_applyAnother potential optimization would be using bytes and buffer objects for larger values, as those don't have to be copied in memory.
Also, keep track of other projects like
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
Django
The Web framework for perfectionists with deadlines.
Laravel
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft
Open source projects and samples from Microsoft.
Google
Google ❤️ Open Source for everyone.
Alibaba
Alibaba Open Source for everyone
D3
Data-Driven Documents codes.
Tencent
China tencent open source team.