StevenACoffman

How to Push to Someone Else's Pull Request

Let's say contributor has submitted a pull request to your (author) project (repo). They have made changes on their branch feature and have proposed to merge this into origin/master, where

origin -> https://github.com/author/repo.git

Now say you would like to make commits to their PR and push those changes. First, add their fork as a remote called

secemp9

class Agent:
    def __init__(self, name, ports=None):
        self.name = name
        self.ports = ports if ports else []
        # Each element of ports is either None or a tuple (other_agent, other_port_index)

    def __repr__(self):
        return f"{self.name}"

def connect(a, pa, b, pb):

rtkclouds

class Rezero(layers.Layer):
    def __init__(self):
        super().__init__()
        self.alpha1 = tf.Variable(0.0, trainable=True)

    def call(self, inputs, training):
        return self.alpha1*inputs
class CustomRezero(tf.keras.layers.Layer):

ScottKirvan

Minimal Unreal New Project Setup

Skip the Launcher and create a new project directly

What is the minimal number of required files and folders needed to create an Unreal Engine Project? Surprisingly little -- one, one-line file to be specific -- and you can launch without needing to use the Launcher or have unreal prompt for a Template project.

Maybe the interesting thing here is that this is an option for some kind of automation. It's literally just create a one-line file, "open" it, and (maybe) select your chosen Unreal version.

Given the number of dev and test files I create, this is a nice direct way to get up and going.

pervognsen

# I happened to be looking at some of Cranelift's code, and I noticed that their constant-time dominates()
# check was using a somewhat more ad-hoc version of a hidden gem from the data structures literature called the
# parenthesis representation for trees. As far as I know, this was invented by Jacobson in his 1989 paper
# Space-Efficient Static Trees and Graphs. I first learned about it from the slightly later paper by Munro and Raman
# called Succinct Representations of Balanced Parentheses and Static Trees. I figured I'd give it an extremely
# quick intro and then show how it leads to a (slightly better) version of Cranelift's algorithm.
#
# This parenthesis representation of trees is surprisingly versatile, but its most striking feature is that
# it lets us query the ancestor relationship between two nodes in a tree in constant time, with a few instructions.
# And the idea is extremely simple and intuitive if you just draw the right kind of picture.

qpwo

function import-ts-repl() { (
    set -e
    file=$1
    rm -f ${file}.js ${file}.js.map
    esbuild ${file} --target=node14 --format=cjs --sourcemap --outfile=${file}.js --platform=node --bundle
    node -r ${file}.js
    rm -f ${file}.js ${file}.js.map
); }

qpwo

// January 2022, Luke Harold Miles, public domain obviously
// Adapted from: https://github1s.com/expressjs/express/blob/master/examples/auth/index.js
// You can run with `ts-node express-typescript-auth.ts`
// Source for this file to get updates: https://gist.github.com/qpwo/4b2ae3aaaf222d099b34898152118c43

import { pbkdf2Sync, randomBytes, timingSafeEqual } from 'crypto'
import type { NextFunction, Request, Response } from 'express'
import express from 'express'
import type { Session } from 'express-session'
import session from 'express-session'

qpwo

"""
A simple predator-prey multi-agent reinforcement learning environment in
python without dependencies, and an implementation of an example q-learning agent.
Python 3.9
https://gist.github.com/qpwo/a19f43368afd77288bf3b7db81fdc18b/
February, 2021 -- Public domain dedication
"""

from dataclasses import dataclass, field
import random

robertmaxwilliams

// Compile with gcc -std=c99 mersenne_twister.c -o /dev/random
// ps the -o /dev/random part is a joke, it's not actually meant to be a random device.
// Absolutely no warranty, Kopyleft I guess who gives a shit
#include <stdint.h>
#include <stdio.h>
uint32_t x[624];
uint32_t index = 0;
void twist() {
    for (int k = 0; k < 624; k++) {
        x[k] = x[(k+397)%624] 

g-leech

import math
import scipy.stats as st

# assumes bivariate normal, dichotomised groups
def dichotomy_r_to_d(r) :
    d = 2*r / (math.sqrt(1 - r**2))
    return d

# Equation 9
# https://sci-hub.tw/10.1037/1082-989X.11.4.386