silky

{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE ScopedTypeVariables #-}

import Language.Haskell.Interpreter
import Text.InterpolatedString.Perl6
import Control.Exception
import Control.Monad
import Data.Traversable

format :: Either InterpreterError Bool -> String

silky

--Roughly based on https://github.com/Gabriel439/Haskell-Morte-Library/blob/master/src/Morte/Core.hs by Gabriel Gonzalez et al.

data Expr = Star | Box | Var Int | Lam Int Expr Expr | Pi Int Expr Expr | App Expr Expr deriving (Show, Eq)

subst v e (Var v')       | v == v' = e
subst v e (Lam v' ta b ) | v == v' = Lam v' (subst v e ta)            b
subst v e (Lam v' ta b )           = Lam v' (subst v e ta) (subst v e b )
subst v e (Pi  v' ta tb) | v == v' = Pi  v' (subst v e ta)            tb
subst v e (Pi  v' ta tb)           = Pi  v' (subst v e ta) (subst v e tb)
subst v e (App f a     )           = App    (subst v e f ) (subst v e a )

silky

-- buildPatSynDetails, so this is a mempty, even the type
-- we generate the same location here.
hsConDeclDetails _ = pprPanic "tcLHsBindsCtOrigin" (ppr val_val_binds)

--------------------
zonkForeignCall :: FlexibleInfo -> CoreBind
              -> Maybe FreeVars -- True <=> supplied EndBinds
             -> RecFlag
             -> Cts -> ForeignOpt Id

silky

from itertools import izip

def decompose(b, n):
    k = 0
    while n:
        r = n % b
        q = (n-r)/b
        yield (r, k)
        k += 1
        n = q

silky

import System.MIDI
import System.MIDI.Utility
import Control.Concurrent
import Control.Monad
import Data.Maybe
import Data.IORef
import Data.Tuple
import Data.Map hiding (filter, map)
import Prelude hiding (lookup, null)

silky

int[][] result;
float t, c;

float ease(float p) {
  return 3*p*p - 2*p*p*p;
}

float ease(float p, float g) {
  if (p < 0.5) 
    return 0.5 * pow(2*p, g);

silky

A Tour of PyTorch Internals (Part I)

The fundamental unit in PyTorch is the Tensor. This post will serve as an overview for how we implement Tensors in PyTorch, such that the user can interact with it from the Python shell. In particular, we want to answer four main questions:

1. How does PyTorch extend the Python interpreter to define a Tensor type that can be manipulated from Python code?
2. How does PyTorch wrap the C libraries that actually define the Tensor's properties and methods?
3. How does PyTorch cwrap work to generate code for Tensor methods?
4. How does PyTorch's build system take all of these components to compile and generate a workable application?

Extending the Python Interpreter

PyTorch defines a new package torch. In this post we will consider the ._C module. This module is known as an "extension module" - a Python module written in C. Such modules allow us to define new built-in object types (e.g. the Tensor) and to call C/C++ functions.

silky

-- The meta-circular interpreter from section 5 of Reynolds's Definitional
-- Interpreters for Higher Order Programming Languages
-- (http://www.cs.uml.edu/~giam/91.531/Textbooks/definterp.pdf)

data EXP
  = CONST Const
  | VAR Var
  | APPL Appl
  | LAMBDA Lambda
  | COND Cond

silky

# Initialize placeholders for feeding in to the queue
pl_queue_screens = tf.placeholder(tf.float32, shape=[config.seq_length, config.image_size, config.image_size, config.input_channels], name="queue_inputs")
pl_queue_targets = tf.placeholder(tf.uint8, shape=[config.seq_length], name="queue_targets_cnt")

#  ...

capacity = config.min_after_dequeue + 10 * (config.num_gpus*config.batch_size)
q = tf.RandomShuffleQueue(

silky

Experiments

• http://absulit.com/portfolio/demo/webvr/001/
• https://www.clicktorelease.com/code/polygon-shredder/vr/ #positional
• https://www.clicktorelease.com/tmp/threejs/webvr-physics/ #positional #input #haptic
• https://janusweb.metacade.com/ https://github.com/jbaicoianu/janusweb/
• https://jzitelli.github.io/poolvr/
• https://kuva.io/block-background/ #positional #input
• https://www.shadertoy.com/results?filter=vr
• https://vr-batted-ball-vis.herokuapp.com/index.html