Compilable Lightweight Markup Language for Linear Algebra
iheartla.github.io
iheartla.github.io
For normal text my new hope is Djot, a lighweight markup language by the creator of Pandoc.
I for one would love to see us evolving past ASCII
A_ij = { 1 if (i,j) ∈ E
0 otherwise
where
A ∈ ℝ^(n × n)
E ∈ { ℤ × ℤ }
n ∈ ℤAnother thing I find confusing are the braces around ℤ × ℤ. They seem to be unnecessary (it wouldn’t make much sense for ∈ to have higher precedence than ×), and/or would imply a singleton set containing the set ℤ × ℤ as its only element.
A_ij = { 1 if (i,j) ∈ E
{ 0 otherwise
where
A ∈ ℝ^(n × n)
E ∈ { ℤ × ℤ }
n ∈ ℤ A_ij = ⎰ 1 if (i,j) ∈ E
⎱ 0 otherwise
where
A ∈ ℝ^(n × n)
E ∈ { ℤ × ℤ }
n ∈ ℤWe do support the Unicode ⎡|⎦ symbols for matrices. The grammar is that a matrix starts with either [ or ⎡ and ends with either ] or ⎦. Rows can be optionally surrounded by |. I find this too cumbersome to use myself.
A_ij = | 1 if (i,j) ∈ E
| 0 otherwise
where
A ∈ ℝ^(n × n)
E ∈ { ℤ × ℤ }
n ∈ ℤIt would be useful if there was something like a help button in the IDE that opened this table in a modal, rather than just a link.
[1]: https://github.com/iheartla/iheartla/wiki/Keywords-And-Speci...
When I bring up the context menu for the compiled result on <https://iheartla.github.io/iheartla/>, my preferred renderer MathML is missing. I noticed right away that something is wrong because the result objectively looks bad, the bracket parts are of differing width, various surrounding elements do not align with the contained content, and also the text has terrible kerning. <https://files.catbox.moe/wp2r0t.webp>
Compare with e.g. <https://codimd.web.cern.ch/features#MathJax> which has much more options to choose from as renderer and its output as MathML is exceedingly pleasing to look at.
What it is is a language for executable mathematics, using Unicode characters heavily so that the source form looks generally much more similar to customary writing styles than the likes of TeX’s ASCII-based $…$ syntax, but which for most people is completely impossible to type in a general-purpose text editor—thereby pairing something mildly similar in concept to Markdown (though not novel to Markdown) with the absolute antithesis of Markdown (which is firmly designed for ease of entry). (Yes, it has ASCII alternatives, see https://github.com/iheartla/iheartla/wiki/Keywords-And-Speci..., but is clearly aiming for you to use the Unicode.)
(I make no comment about I Heart LA beyond this. I am only criticising the mention of Markdown, nothing else.)
It is fairly easy to type if you have configured a Compose key. Usually this can be done system-wide, but Vim for example also supports digraphs, which work similarly. For example Ctrl+K (- gives you ∈, Ctrl+K +Z gives you ∑, Ctrl+K In gives you ∫, Ctrl+K 00 gives you ∞, and so on. You can freely redefine the digraphs to suit your choice of mnemonics. I’m sure Emacs has something similar.
Learning the Compose or digraph key sequences is not much different from learning LaTeX commands. The trade-off is that you can’t infer from the result how it was typed, but in return it is more readable and more compact.
In my opinion, use of such Unicode characters should become more common, because the general method of how to type them is not difficult to learn. It would be nice if operating systems had it preconfigured — maybe we’ll get to that state someday. We have to start somehow.
In any case, I applaud the language for taking that approach.
One of them on macOS is dragging-and-dropping a Text Substitutions.plist (in the extras/ folder on GitHub) into the substitutions panel in System Preferences.
I also found it confusing, just trying to see why they would internally say markdown and it would make it out to a post.
Our follow-up project HeartDown (linked) explores embedding I Heart LA in markdown documents.
[0] https://en.wikipedia.org/wiki/Lightweight_markup_language
(Submitted title was "Compilable Markdown for Linear Algebra")
I would say that this is false.
> The overriding design goal for Markdown’s formatting syntax is to make it as readable as possible.[1]
E.g. indented code blocks are nice to read (and you don’t have to think about escaping) but fenced code blocks are easier to type.
Symbols that map directly to the domain seems like a readability win to me.
That's possible albeit limited.
julia> x=[1,2]
2-element Array{Int64,1}:
1
2
julia> 2x
2-element Array{Int64,1}:
2
4
julia> 2(x+x)
2-element Array{Int64,1}:
4
8
julia> x=2
2
julia> [1,2]x
2-element Array{Int64,1}:
2
4