| OpenSimplexNoise noise; | |
| int[][] result; | |
| float t, c; | |
| float ease(float p) { | |
| return 3*p*p - 2*p*p*p; | |
| } | |
| float ease(float p, float g) { |
| // note : if you're on github gist and want to copy paste this code, you can click on the "Raw" button | |
| // and then do Ctrl A, Ctrl C, Ctrl V | |
| // (code below by Kurt Spencer, slightly modified code to run as Processing tab) | |
| // maybe you should rather use this new (improved) version of the noise instead : https://github.com/KdotJPG/OpenSimplex2 | |
| /* | |
| * OpenSimplex Noise in Java. | |
| * by Kurt Spencer | |
| * | |
| * v1.1 (October 5, 2014) |
| package somepackage; | |
| import java.util.Random; | |
| public class ExponentialAverager { | |
| public static void main(String[] args) { | |
| int N_ITER = 50; | |
| int N_VEC = 5; |
| # video here https://www.youtube.com/watch?v=7Ir0bbCBXa8 | |
| #include <FastLED.h> | |
| #if FASTLED_VERSION < 3001000 | |
| #error "Requires FastLED 3.1 or later; check github for latest code." | |
| #endif | |
| #define DATA_PIN 6 | |
| #define LED_TYPE WS2811 |
| from numpy import exp, array, random, dot | |
| training_set_inputs = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]]) | |
| training_set_outputs = array([[0, 1, 1, 0]]).T | |
| random.seed(1) | |
| synaptic_weights = 2 * random.random((3, 1)) - 1 | |
| for iteration in xrange(10000): | |
| output = 1 / (1 + exp(-(dot(training_set_inputs, synaptic_weights)))) | |
| synaptic_weights += dot(training_set_inputs.T, (training_set_outputs - output) * output * (1 - output)) | |
| print 1 / (1 + exp(-(dot(array([1, 0, 0]), synaptic_weights)))) |
The standard way of understanding the HTTP protocol is via the request reply pattern. Each HTTP transaction consists of a finitely bounded HTTP request and a finitely bounded HTTP response.
However it's also possible for both parts of an HTTP 1.1 transaction to stream their possibly infinitely bounded data. The advantages is that the sender can send data that is beyond the sender's memory limit, and the receiver can act on
NOTE: This is a question I found on StackOverflow which I’ve archived here, because the answer is so effing phenomenal.
If you are not into long explanations, see [Paolo Bergantino’s answer][2].
The above gradients compare interpolation in RGB, HSL, CIE Lab and CIE LCh color spaces. For more on color spaces, see Gregor Aisch’s post, How To Avoid Equidistant HSV Colors.
This example is built with D3. Code and documentation are available as the d3.cie plugin.
| /* | |
| * Euler's totient function phi(n). | |
| * http://en.wikipedia.org/wiki/Euler%27s_totient_function | |
| * | |
| * This is an *EXTREMELY* fast function and uses | |
| * several tricks to recurse. | |
| * | |
| * It assumes you have a list of primes and a fast | |
| * isprime() function. Typically, you use a bitset | |
| * to implement the sieve of Eratosthenes and use |
| /* | |
| * The binary gcd algorithm using iteration. | |
| * Should be fairly fast. | |
| * | |
| * Put in the public domain by the author: | |
| * | |
| * Christian Stigen Larsen | |
| * http://csl.sublevel3.org | |
| */ | |
| int binary_gcd(int u, int v) |
