Skip to content

Instantly share code, notes, and snippets.

@rilerez
rilerez / rels.clj
Last active May 3, 2021
a few clojure core.logic relations
View rels.clj
(ns logic-data-transform.core
(:use [clojure.core.logic])
(:require [clojure.test :as test])
(:require [clojure.core.match :refer [match]]))
(defn assoco
([base & args]
(let [out (last args)
bindings (partition 2 (butlast args))]
(apply conjo base (conj (vec bindings) out)))))
@rilerez
rilerez / FN.hpp
Last active Apr 8, 2021
A silly macro for a shorthand for lambdas
View FN.hpp
namespace FN_impl {
template<class T>
constexpr auto depend_id(auto x) {
return x;
}
struct fake {
template<class T>
operator T() {
View minmax_elt.cpp
template<class T, class Less = std::less<>>
constexpr auto minmax(T&& x, T&& y, Less less = {})
BODX(less(y, x) ? std::forward_as_tuple(y, x) : std::forward_as_tuple(x, y))
// s is for stable
template<class T, class Less = std::less<>>
constexpr auto smin(T&& x, T&& y, Less less = {})
BODX(std::get<0>(minmax(x, y, less)))
template<class T, class Less = std::less<>>
View methods.lisp
(defgeneric add (x y))
;;; assume we already defined vector and integer classes
(defmethod add ((x vector) (y vector))
....)
(defmethod add ((x integer) (y integer))
(+ x y))
@rilerez
rilerez / no_deducing_this_macro.hpp
Created Jul 6, 2020
Deducing this, i wish: my current approach just uses a macro to stamp out all the required overloads. The quadruplication is code-generated.
View no_deducing_this_macro.hpp
#include <utility>
#define FORALL_CONSTREFS(mac) \
mac(const, &, ) mac(, &, ) mac(, &&, std::move) mac(const, &&, std::move)
class ExampleIntWrapper {
public:
# define OVERLOADS_PLEASE(const_, ref_, move_) \
int const_ ref_ data() const_ ref_ { return move_(data_); }
FORALL_CONSTREFS(OVERLOADS_PLEASE)
View wordcount.py
import re
from hash_map import HashMap
"""
This is the regular expression used to capture words. It could probably be endlessly
tweaked to catch more words, but this provides a standard we can test against, so don't
modify it for your assignment submission.
"""
rgx = re.compile("(\w[\w']*\w|\w)")
@rilerez
rilerez / meanHittingTime.m
Last active Oct 13, 2019
Calculates the mean hitting time of a state in a homogenous markov chain
View meanHittingTime.m
function K = fixedPoint(M)
[r c] = size(M);
assert(r==c);
I = eye(r);
K = -rref(I-M)(:,r);
K(r)=1;
assert(norm(M*K-K)<.0001*norm(K));
end
function p = projectFromPRn(X)
@rilerez
rilerez / gen-macro.scm
Last active Aug 22, 2019
generators with macros
View gen-macro.scm
(define-syntax-parameter yield
(lambda (stx)
(syntax-violation 'yield "~yield~ is undefined outside of a generator" stx)))
(define-syntax-rule (generator body ...)
(let ()
(define yield-tag (make-prompt-tag))
(define (yield% . returns)
(apply abort-to-prompt yield-tag returns))
(define (thunk)
@rilerez
rilerez / generator.scm
Created Aug 22, 2019
using prompts (delimited continuations) to build generators
View generator.scm
(define yield (prompt-tag))
(define (count-helper)
(let loop ((n 0))
(abort-to-prompt yield n)
(loop (1+ n))))
(define this-step count-helper)
(define (count)
@rilerez
rilerez / dijkstra.clj
Created Apr 20, 2019
Dijkstra's algorithm in clojure
View dijkstra.clj
(defprotocol WEIGHTED_GRAPH
(nodes [graph])
(neighbors [graph node])
(weight [graph from to]))
(defn dijkstra
[start goal graph]
(let [nodes (nodes graph)
neighbors #(neighbors graph %)
weight #(weight graph %1 %2)]