Before you continue, if you don't know what IMGUI is don't bother reading this post, just ignore it, don't write anything in comments section, etc. If you're curious about IMGUI see bottom of this post, otherwise continue whatever you were doing, this post it's not for you. Thanks!
If you know what IMGUI is, for context read following presentations and blog posts:
| # An example global gitignore file | |
| # | |
| # Place a copy if this at ~/.gitignore_global | |
| # Run `git config --global core.excludesfile ~/.gitignore_global` | |
| # Compiled source # | |
| ################### | |
| *.com | |
| *.class | |
| *.dll |
| ; syntax objects are true AST nodes, so they are an algebraic data type with data constructors and deconstructors: | |
| ; | |
| ; syntax = (syntax-null props) | (syntax-cons props syntax syntax) | (syntax-identifier props symbol) | (syntax-atom props datum) | |
| ; | |
| ; the constructors have dual deconstructors with names like syntax-car, syntax-cdr, syntax-identifier-symbol, | |
| ; and type predicates like syntax-null?, syntax-pair?, syntax-identifier?. | |
| ; | |
| ; props is just an open-ended plist of key-value pairs with optional information about things like source location | |
| ; and anything else you want to track. you can call syntax-props on any of the syntax variants to get the plist. | |
| ; as a convenience when calling the constructor functions, you can either pass in a props plist directly, or you can |
| typedef struct intern_t { | |
| intern_t *next; | |
| uint32_t length; // can be narrower if you want to limit internable string length, which is a good idea. | |
| char str[1]; | |
| } intern_t; | |
| hashtable_t string_table; | |
| const char *string_intern(const char *str, uint32_t length) { | |
| uint64_t key = string_hash(str, length); |
| // | |
| // Author: Jonathan Blow | |
| // Version: 1 | |
| // Date: 31 August, 2018 | |
| // | |
| // This code is released under the MIT license, which you can find at | |
| // | |
| // https://opensource.org/licenses/MIT | |
| // | |
| // |
| # Reverse-mode automatic differentiation | |
| import math | |
| # d(-x) = -dx | |
| def func_neg(x): | |
| return -x, [-1] | |
| # d(x + y) = dx + dy | |
| def func_add(x, y): |
As C programmers, most of us think of pointer arithmetic for multi-dimensional arrays in a nested way:
The address for a 1-dimensional array is base + x.
The address for a 2-dimensional array is base + x + y*x_size for row-major layout and base + y + x*y_size for column-major layout.
The address for a 3-dimensional array is base + x + (y + z*y_size)*x_size for row-column-major layout.
And so on.
I've been reading this much-publicized paper on neural ordinary differential equations:
https://arxiv.org/abs/1806.07366
I found their presentation of the costate/adjoint method to be lacking in intuition and notational clarity, so I decided to write up my own tutorial treatment. I'm familiar with this material from its original setting in optimal control theory.
You have a dynamical system described by an autonomous first-order ODE, x' = f(x), where the state x belongs to an n-dimensional vector space. There is a value function V(x) defined over the state space. Given a particular path t -> x(t) satisfying the ODE, we may evaluate it at the terminal time T to get the terminal state x(T) and the terminal value V(x(T)).
A quadratic space is a real vector space V with a quadratic form Q(x), e.g. V = R^n with Q as the squared length. The Clifford algebra Cl(V) of a quadratic space is the associative algebra that contains V and satisfies x^2 = Q(x) for all x in V. We're imposing by fiat that the square of a vector should be the quadratic form's value and seeing where it takes us. Treat x^2 = Q(x) as a symbolic rewriting rule that lets you replace x^2 or x x with Q(x) and vice versa whenever x is a vector. Beyond that Cl(V) satisfies the standard axioms of an algebra: it lets you multiply by scalars, it's associative and distributive, but not necessarily commutative.
Remarkably, this is all you need to derive everything about Clifford algebras.
Let me show you how easy it is to bootstrap the theory from nothing.
We know Cl(V) contains a copy of V. Since x^2 = Q(x) for all x, it must also contain a copy of some nonnegative reals.
| #include <time.h> // Robert Nystrom | |
| #include <stdio.h> // @munificentbob | |
| #include <stdlib.h> // for Ginny | |
| #define r return // 2008-2019 | |
| #define l(a, b, c, d) for (i y=a;y\ | |
| <b; y++) for (int x = c; x < d; x++) | |
| typedef int i;const i H=40;const i W | |
| =80;i m[40][80];i g(i x){r rand()%x; | |
| }void cave(i s){i w=g(10)+5;i h=g(6) | |
| +3;i t=g(W-w-2)+1;i u=g(H-h-2)+1;l(u |