gatopeich

from dataclasses import dataclass, fields as datafields
from ujson import dumps, loads
# Note: ujson seamlessly serializes dataclasses, unlike stdlib's json

@dataclass
class Point:
    x: float
    y: float

# Shallow dataclass can be rebuilt from dict/json:

fay59

Here's a list of mildly interesting things about the C language that I learned mostly by consuming Clang's ASTs. Although surprises are getting sparser, I might continue to update this document over time.

There are many more mildly interesting features of C++, but the language is literally known for being weird, whereas C is usually considered smaller and simpler, so this is (almost) only about C.

1. Combined type and variable/field declaration, inside a struct scope [https://godbolt.org/g/Rh94Go]

struct foo {
   struct bar {
 int x;

WorldSEnder

// The two main components are the interfaces
// Generic<T, Context> and GenericArg<"identifier">

// Generic basically structurally replaces types in T that are GenericArg<S>
// for some `S extends keyof Context` with `Context[S]`
// See the test cases for specific uses.

// ====== TESTING
// Pass through for trivial types
type Test00 = Generic<number>;

nadavrot

High-Performance Matrix Multiplication

This is a short post that explains how to write a high-performance matrix multiplication program on modern processors. In this tutorial I will use a single core of the Skylake-client CPU with AVX2, but the principles in this post also apply to other processors with different instruction sets (such as AVX512).

Intro

Matrix multiplication is a mathematical operation that defines the product of

c0nn3r

import re
import os
import glob
import pandas as pd

import matplotlib.pyplot as plt

from collections import OrderedDict

fig_size = [12, 9]

honix

Red []

let: func [
	binds 
	block 
	/local 
		ctx
][
	ctx: context append/only append binds copy [result: do] block
	select ctx 'result

snoyberg

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE TypeFamilies #-}
module Main (main) where

import Foreign
import Foreign.C.Types

buserror

/*
 *
 * Ascii art http://www.network-science.de/ascii/ (font "mini")
 *
 * -Wall -g -Os -std=gnu99 -mcall-prologues -DF_CPU=8000000
 *    8366	    118	   1373	   9857	   2681	atmega644_sure_led_clock.axf
 *
 * 			-mcall-prologues -fno-inline-small-functions \
 *			-ffunction-sections -fdata-sections \
 *			-Wl,--relax,--gc-sections \

patik

body { counter-reset: h1counter h2counter h3counter h4counter h5counter h6counter; }

h1 { counter-reset: h2counter; }
h2 { counter-reset: h3counter; }
h3 { counter-reset: h4counter; }
h4 { counter-reset: h5counter; }
h5 { counter-reset: h6counter; }
h6 {}

h2:before {

anj1

import types
import tensorflow as tf 
import numpy as np

# Expressions are represented as lists of lists,
# in lisp style -- the symbol name is the head (first element)
# of the list, and the arguments follow.

# add an expression to an expression list, recursively if necessary.
def add_expr_to_list(exprlist, expr):