| codatatype Stream = Cons(head: nat, tail: Stream) | |
| function Upwards(n: nat): Stream { | |
| Cons(n, Upwards (n + 1)) | |
| } | |
| function Nats() : Stream { | |
| Upwards(0) | |
| } |
| using CausalInference | |
| V = [:U, :T, :P, :O] | |
| g = digraph([1=>3, 2=>3, 3=>4, 2=>4, 1=>4]) | |
| # Can estimate total effect T=>O without observing U? | |
| u = 2 | |
| v = 4 | |
| ∅ = Set{Int}() | |
| observed = 2:4 | |
| collect(list_covariate_adjustment(g, u, v, ∅, observed)) |
| using CausalInference, Graphs | |
| V = [:U, :T, :P, :O] | |
| ι = Dict(v=>i for (i,v) in enumerate(V)) | |
| g = digraph([1=>3, 2=>3, 3=>4, 2=>4, 1=>4]) | |
| # Can estimate total effect T=>O without observing U? | |
| u = ι[:T] | |
| v = ι[:O] | |
| ∅ = Set{Int}() |
| // A nano dependent type-checker featuring inductive types via self encodings. | |
| // All computation rules are justified by interaction combinator semantics, | |
| // resulting in major simplifications and improvements over old Kind-Core. | |
| // Specifically, computable annotations (ANNs) and their counterpart (ANN | |
| // binders) and a new self encoding based on equality (rather than dependent | |
| // motives) greatly reduce code size. A more complete file, including | |
| // superpositions (for optimal unification) is available on the | |
| // Interaction-Type-Theory repository. | |
| // Credits also to Franchu and T6 for insights. |
| #!/usr/bin/env fish | |
| # Needs rg: `brew install ripgrep` | |
| set -xg visitedLibs | |
| function libdeps -a bin depth -d "Finds all dylibs that a binary depends on recursively and prints them on separate lines, sorted alphabetically" | |
| if test -z "$depth" | |
| set depth 0 | |
| end |
| infixr 5 ~> -- Morphism of indexed functors | |
| infixr 5 ~~> -- Morphism of graphs/doubly-indexed functors | |
| infixr 5 :~> -- Morphism of multi-graphs | |
| infixr 5 :~:> -- Morphism of poly-graphs | |
| namespace Fix1 | |
| -- Objects are Types | |
| -- Morphisms are functions between types (->) |
| from einops import rearrange | |
| from torch import Tensor | |
| import torch | |
| def kronecker_decompose( | |
| A: Tensor, m: int, n: int, *, k: int = 1, niter: int = 10 | |
| ) -> tuple[Tensor, Tensor]: | |
| """Frobenius-optimal decomposition of `A` into a sum of `k` Kronecker products. |
| ;; based on code from https://www.baeldung.com/java-uuid | |
| ;; translated to Clojure by ChatGPT, minus the hex numbers which I evaluated in jshell | |
| (defn get-64-least-significant-bits-for-version1 [] | |
| (let [random (java.util.Random.) | |
| random-63-bit-long (bit-and (.nextLong random) 4611686018427387903) | |
| variant-3-bit-flag -9223372036854775808] | |
| (bit-or random-63-bit-long variant-3-bit-flag))) | |
| (defn get-64-most-significant-bits-for-version1 [] |
| MONGODB_URL=mongodb://localhost:27017 | |
| HF_ACCESS_TOKEN=<REDACTED> | |
| # 'name', 'userMessageToken', 'assistantMessageToken' are required | |
| MODELS=`[ | |
| { | |
| "endpoints": [{"url": "http://localhost:8081"}], | |
| "name": "WizardLM/WizardLM-70B-V1.0", | |
| "description": "WizardLM: Empowering Large Pre-Trained Language Models to Follow Complex Instructions", | |
| "websiteUrl": "https://huggingface.co/WizardLM/WizardLM-70B-V1.0", |
Not only Mojo is great for writing high-performance code, but it also allows us to leverage huge Python ecosystem of libraries and tools. With seamless Python interoperability, Mojo can use Python for what it's good at, especially GUIs, without sacrificing performance in critical code. Let's take the classic Mandelbrot set algorithm and implement it in Mojo.
We'll introduce a Complex type and use it in our implementation.
