I immediately found a few Unicode features I hoped were supported but aren’t.
Superscripts: firstly numerals, like 3² = 9, but ideally then letters as well, e.g. 3ⁱ = 3^i. Might be suitable to support superscripts to define nth roots, too, e.g. ⁵√. tan¯¹ can be a thing too.
Subscripts: same deal; log₂ 31 = log(31, 2).
Proper arithmetic operators: times (×), minus (−), division (÷). Also fraction slash (⁄), which can be preceded and succeeded either by normal numerals (e.g. 12⁄34) or by superscripts and subscripts (e.g. ⁵⁶⁄₇₈). (Full font support for fraction slash is weak, but generally tolerable even if imperfect.) Also the prebaked fractions like ½ and ⅜.
Also mixed fractions: I reckon 1 2/3 should be parsed as 1+2/3, not 12/3. Them Unicode fractions can join in here too, with 1⅔ (using a prebaked fraction) being 1+2/3, or 1²³⁄₄₅ (using superscript, fraction slash, subscript) being 1+23/45.
Cubic and quartic roots: ∛ and ∜.
At this point it’s worth just looking through the whole Symbol, Math Unicode category and implementing everything applicable. Hmm, set operations, lots of fun symbols there.
Lots of fun spaces too, e.g. where I wrote log₂ 31 earlier I wanted to use NARROW NO-BREAK SPACE after the ₂, but alas, HN normalises it to a plain old space. That space gets used as a number grouping separator especially, avoiding the whole ,/. localisation problem without being too wide.
kalk is a calculator that has syntax highlighting, automatically turns names into symbols (eg. sqrt to √), supports math-like syntax (eg. f(x) = x(2sinx + 3) , estimation of derivatives and integrals, complex numbers, and runs in the browser using WebAssembly.
Congrats! I write calculators myself from time to time, but this sounds very impressive :) How was your experience using webassembly? Any good guides that helped you with that part?
It was actually surprisingly seamless with Rust. "wasmpack" pretty much did it all for me. I added some attributes (well, whatever they're called in Rust) to function and struct declaration to show that bindings should be generated for these things, and from that wasmpack could generate JavaScript bindings! Unfortunately I was slightly limited by some libraries not working with WebAssembly, but I got around that fairly easily.
This looks extremely useful, even though currently makes quite a few mistakes, as noted by others. A few features that could be nice:
1) It handles 1 000 000 * 3 just fine, but returns 3000000. So it would be nice if it would format output as 3 000 000 as well for readability. At least as an optional setting (even though I have no idea why someone wouldn't want that).
2) Some way of referencing last result. Often you need to perform operations step by step, when, say, estimating something. So either 10 \n + 20 \n * 3 ..., or just referencing last output like some special variable. I though I could do it more verbosely by just x = 10; x = x + 20 ..., but that gives "Variable references itself."
3) Not sure about this one, since this is not something natural at all, and I don't know what to propose to make it natural (at least without proposing map/filter/reduce and some sort of multi-line inputs). Neither is it a real problem, but it's just something I probably use a calculator most often: simply adding up a dozen of numbers, copied from somewhere as a column. So currently I must first open vim, convert it to and expression bc will handle ( 15 + 21 + 32 ...), and then paste in to bc. With kalk it would be similar. Would be great if one could skip that step since this (I assume) would be a common use-case. But, yeah, I don't have an actual suggestion on how to naturally address that.
Yeah the name isn't very good. This wasn't actually supposed to become something, it was a quick thing I made when I was bored, that suddenly expanded into all this, haha. I like being able to type `kalk` in the terminal, but maybe something needs to be added to the name to make it more recognisable.
Well, that's not a segfault. It's more likely that it's being compiled with an incorrect/specific architecture (e.g. using AVX2 instructions). Though it really shouldn't be using such instructions for basic math. It is possible the instruction pointer is getting messed up too.
Hmm, that's very strange, considering I'm running a very similar setup (Arch and fish). I wonder if it could be an issue with the library I'm using for big floats..
`√2` works but `√-1` doesn't, which surprised me a bit. I'
expect unary `-` to bind tighter, but in this context it considers that it's a binary operator between `√` and `-1`. If you put parens it works of course.
In fairness, I still don’t know where “e” comes from in complex number notation. The transition from cos(angle) + i sin(angle) seems to become “e^i(angle), lol” and no one explains it further. Before I started doing signal processing, I too would have thought that e^i pi is something like 1.69 + 2.64, so it’s correct, in a certain sense. But perhaps not the common mathematical sense.
EDIT: Ah, I see the problem. I suspected that e^iπ was being turned into πe^i incorrectly, but when I typed the open parenthesis for e^() and put my cursor inside it, typing "i" resulted in e^i() rather than e^(i). So it was impossible to parenthesize correctly, and I assumed e^iπ had the usual meaning.
The derivation comes from Taylor series expansion of the exponential function e^x = 1 + x/1! + x^2/2! + x^3/3! + …
You can throw together a program that will show numerically that this both converges to e^x for real x and that e^ix converges to cos(x)+i*sin(x). You can also find proofs online I’m sure.
Why do it numerically? Show that e^ix converges, then you can reorder the sums, grouping the odd and even terms you get series expansions for cos(x) and i sin(x).
You actually have to understand calculus for that to actually prove it to you, but, you can show that it seems to work out numerically with a bit of programming knowledge, which I imagine is more common on Hacker News.
I don't think either the numerical or symbolic proofs really help build intuition though. This video [1] kinda helps, although it glosses over the critical fact "multiplying by i rotates counterclockwise 90°."
Hmm. This is the second time I've seen that "multiplying by i rotates counterclockwise 90 degrees."
I agree that this is one way to interpret the result. But is it literally equivalent to matrix multiplication by a 2D rotation matrix? Someone tried to say it was, which I felt skeptical about.
For the general case of rotation in the complex plane, multiplying by a complex number with an absolute value of 1 (i.e. on the unit circle) rotates by that number's angle from the positive reals. Normally you'd write such a number as e^iθ, but since that's what we're trying to get to, we can instead write it as cos θ + i sin θ.
[cos θ -sin θ] [x] = [x cos θ - y sin θ]
[sin θ cos θ] [y] = [x sin θ + y cos θ]
Compare to:
(cos θ + i sin θ) (x + iy)
= x cos θ + ix sin θ + iy cos θ + i²y sin θ
= (x cos θ - y sin θ) + i (x sin θ + y cos θ)
Maybe the cause of your skepticism is that it seems unintuitive that complex numbers, which are 2-dimensional in linear-algebra-speak, could be as powerful as 2×2 matrices, which are 4-dimensional. But keep in mind that 2×2 matrices can perform any linear transformation on 2-dimensional vectors using only matrix multiplication, whereas complex number multiplication can only scale and rotate, and you need to use complex addition to get translation, and I'm not sure off the top of my head if it's possible to get shear transformations using complex numbers.
I just wanted to say, thank you so much for explaining this so thoroughly. I feel much more comfortable using complex numbers now that I allowed myself to believe "it's literally equivalent to a rotation matrix."
(I'm a former gamedev, so rotation matrices are very intuitive. But for some reason, I never made the connection to complex numbers, except in an abstract math-y sort of way.)
Just to be pedantic, the Taylor series definition of the exponential converges absolutely, hence we can reorder the terms by odd/even powers without changing the sum.
That post proves the point: it jumps from "use cos(t) + i sin(t)" to "use e^it" with zero explanation about why it's related to 2.718281828...
The reason I posted my comment is because e^(i pi) is obviously supposed to be -1+0j. But I see now that I was using the calculator incorrectly (I was doing the equivalent of πe^i) but there was a bug in the parenthesis operator preventing me from typing it that way on mobile.
> it jumps from "use cos(t) + i sin(t)" to "use e^it" with zero explanation about why it's related to 2.718281828...
It really isn't, beyond the fact that exp(1) = 2.718…. Then, by definition exp(it) = exp(1)^(it) = e^it. It isn't much more than a notational artifact as far as I'm concerned. For that matter, raising any base b to a power is equivalently just scaling it by ln(b) and plugging it into exponential function, that is, b^it = cos(ln(b) * t) + i sin(ln(b) * t).
This is somewhat similar to my project at https://calcula.tech, although the usecase is a bit different. There are a few other calculators around that use Rust + WASM which is kind of interesting
Very cool, I'm building a similar project atm as well (not ready to share, but you could dig it up easily), the latex reprinting of input is an interesting twist that I'm sure many people will appreciate.
I am afraid this domain is a prime nerd-sniping range, because there are so many variations on building a better, more interactive calculator. No profits here besides learning and great fun!
The desktop program does technically have the capabilities of that, but lately I've been focusing a lot more on the web version, that unfortunately doesn't, so results are 64-bit at the moment. I have been waiting for a proper Rust library that can do this, so that it could work on the web version as well, but so far, that has not happened, so I'll probably do some work on properly supporting big numbers on the desktop program soon.
Nice work! And you beat me to the name "Kalk", I've had a private github repo with a calculator with that name for a while, though mine takes sort of the opposite approach, input and manipulation is very visual.
Any interest in adding more symbolic stuff? There often isn't really any reason to do derivatives numerically. While I was looking at the derivatives I noticed the word "quotinent" should be "quotient" in the readme.
I have thought about doing derivatives and such algebraically when possible. It should certainly be doable, and I already have a system for moving things around to achieve these kind of things. This may be a thing in the future.
There are also some algorithms for trying to deal with symbolic integrals but they're pretty intense compared to what you have to do for derivatives (which are very easy).
Yeah that makes sense. I won't be able to do it 100% of course, especially considering I so far have only learned high school maths, but even if it just manages to do it in some situations, that would still be fine as long as it falls back to (often quite accurate) numerical integration. I'll read some more about it!
Can you elaborate? I think I know what you mean, but when I clicked the link it already seemed to be a "more advanced bc" to me. What are you missing, big numbers (that's what came to my mind)?
Pity it's not in homebrew. I realize I can manually download a binary and manually install it and make a note somewhere where I got it from in case I forget and then periodically re-check manually if an update is out, or just never install any updates, but I'm trying to not do that if it can be helped.
Can you give an example of a quaternion computation that would be useful in a calculator? I would imagine that quaternions and GA are best suited to have a graphical output, ala https://enkimute.github.io/ganja.js/examples/coffeeshop.html ?
Superscripts: firstly numerals, like 3² = 9, but ideally then letters as well, e.g. 3ⁱ = 3^i. Might be suitable to support superscripts to define nth roots, too, e.g. ⁵√. tan¯¹ can be a thing too.
Subscripts: same deal; log₂ 31 = log(31, 2).
Proper arithmetic operators: times (×), minus (−), division (÷). Also fraction slash (⁄), which can be preceded and succeeded either by normal numerals (e.g. 12⁄34) or by superscripts and subscripts (e.g. ⁵⁶⁄₇₈). (Full font support for fraction slash is weak, but generally tolerable even if imperfect.) Also the prebaked fractions like ½ and ⅜.
Also mixed fractions: I reckon 1 2/3 should be parsed as 1+2/3, not 12/3. Them Unicode fractions can join in here too, with 1⅔ (using a prebaked fraction) being 1+2/3, or 1²³⁄₄₅ (using superscript, fraction slash, subscript) being 1+23/45.
Cubic and quartic roots: ∛ and ∜.
At this point it’s worth just looking through the whole Symbol, Math Unicode category and implementing everything applicable. Hmm, set operations, lots of fun symbols there.
Lots of fun spaces too, e.g. where I wrote log₂ 31 earlier I wanted to use NARROW NO-BREAK SPACE after the ₂, but alas, HN normalises it to a plain old space. That space gets used as a number grouping separator especially, avoiding the whole ,/. localisation problem without being too wide.