keveman

/*
 *  Copyright 2010-2012 NVIDIA Corporation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software

keveman

     let_(_v = get_<0>(_1)) [
       let_(_i = get_<9>(_1)) [
         let_(_y = _i/m) [
           let_(_x = _i - _y*m) [
             if_(_x >= k) [
               _v = minVoro_(_x, _y, _v, get_<3>(_1), m, n),
               if_(_y >= k) [
                 _v = minVoro_(_x, _y, _v, get_<8>(_1), m, n)
               ],
               if_(_y+k <= n) [

keveman

#include <iterator>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <iostream>
#include <cassert>
#include <memory>
#include <future>
#include <chrono>

keveman

import snakes.plugins
snakes.plugins.load('gv', 'snakes.nets', 'nets')
from nets import *

n = PetriNet('pn')

n.add_place(Place('p1', [1,2]))
n.add_place(Place('p2'))
n.add_place(Place('p3'))
n.add_place(Place('p4_i'))

keveman

#include <iostream>

template<int N> struct Int { };

auto church(Int<0>) {
  return [](auto f) {
    return [=](auto x) { return x; };
  };
}

keveman

Keybase proof

I hereby claim:

• I am keveman on github.
• I am keveman (https://keybase.io/keveman) on keybase.
• I have a public key ASB03gqL5zVaMqPYEgnpURRX_GptvH_nE1MUOilG85Hj-Qo

To claim this, I am signing this object:

keveman

def as_dot(g):
  names = dict()
  dot = "digraph {\n"
  for op_id in sorted(g._nodes_by_id):
    op = g._nodes_by_id[op_id]
    parts = op.name.split("/")
    n = names
    for p in parts:
      if p not in n:
        n[p] = dict()

keveman

const C = struct {
  x : u16,

  inline fn post_inc(self: *C) u16 {
    const tmp = self.*.x;
    self.*.x += 1;
    return tmp;
  }
};

keveman

#include <assert.h>
#include <iostream>
#include <memory>

#include "peglib.h"

#include <vector>
#include <string>

struct matrix {

keveman

#include <iostream>
#include "peg.inl.h"

@macro void foo(const char* str) {
  @meta auto x = parse(str);
  @meta x.dump(std::cout);
}

float W[32][16], x[32], y[16];