jfacoustic

#include <vector>
#include <cmath>

struct vec3 {
    float x, y, z;
    void set(float X, float Y, float Z)
    {
        x = X;
        y = Y;
        z = Z;

jfacoustic

#include "../common/book.h"
#include "../common/cpu_bitmap.h"

#define DIM 1000

//From Wikipedia's article on the Mandelbrot Set:
__device__ int mandelbrot( int xa, int ya, float s, float xpos, float ypos) {
	float x0 = s * (float) (DIM/2 -xa)/((float)DIM/2) + xpos;
	float y0 = s * (float)(DIM/2 -ya )/((float)DIM/2) + ypos;
	int m = 0;

jfacoustic

#include <iostream>
#include <vector>
#include <ctime>
#include <gmpxx.h>
using namespace std;

mpz_class fibNorm(int n) {
	if (n <= 1 ) return n;
	return fibNorm(n-1) + fibNorm(n-2);
}

jfacoustic

//  CUDA function ptr example
//  For basic vector operations
//  Based on Chapter 2 of Programming Massively Parallel Processors 3rd Edition Kirk & Hwu

#include <stdio.h>
#include <cuda.h>

__global__ void addKernel(float * a, float * b, float * c, int n) {
    int i = blockDim.x * blockIdx.x  + threadIdx.x; 
    if(i < n) {

jfacoustic

(defn calculate-interest
  [apy base deposit months]
  (if (= months 0)
    ( + base (* base apy))
    (do (def newBase (+ base deposit))
        (if (= (mod months 12) 0)
          (calculate-interest apy (+ newBase (* newBase apy)) deposit (dec months))
          (calculate-interest apy newBase deposit (dec months))))))

jfacoustic

const cities = ['Tokyo', 'London', 'Rome', 'Donlon', 'Kyoto', 'Paris'].map(city => city.toLowerCase());

const matches = cities.reduce((acc, curr) => {
	const double = curr + curr;
	const match = [];
	cities.forEach(city => {
		if(double.includes(city)) {
			match.push(city);
		}
	});

jfacoustic

(defun split-string (str &key (delimiter #\space))
  (defun split-string-rec (str str-list delimiter-pos)
    (if delimiter-pos
	    (let ((current (subseq str 0 delimiter-pos))
	          (remaining (subseq str (+ delimiter-pos 1) (length str))))
	        (split-string-rec remaining
			                  (push current str-list)
			                  (position delimiter remaining)))
	    (reverse (push str str-list))))
  (split-string-rec str nil (position delimiter str)))

jfacoustic

(define (sum term a next b)
  (if (> a b)
      0
      (+ (term a)
	 (sum term (next a) next b))))

(define (simpson-integral f a b n)
  (let ((h (/ (- b a ) n)))
  (define (term n)
    (define y (f (+ a (* h n))))

jfacoustic

(define (sum term a next b)
  (define (iter a result)
    (if (> a b)
	      result
	      (iter (next a) (+ result (term a)))))
  (iter a 0))

jfacoustic

(define (product term a next b)
  (if (> a b)
      1
      (* (term a)
	 (product term (next a) next b))))

(define (inc x) (+ x 1))
(define (identity x) x)

(define (factorial n)