Alrecenk

// A Generic Min Heap Priority Queue for Unity that uses supplied float values for its ordering.
using System.Collections.Generic;
using UnityEngine;

public class PriorityQueue<T> where T : class{

    struct ValueItem {
        public T item;
        public float value;
        public ValueItem(T i, float v) { 

Alrecenk

std::string header = ...;
Variant glb = Variant::parseJSON(header);
glb["meshes"][glb["nodes"][glb["scenes"][0]["nodes"][0]]["mesh"]].printFormatted();

Alrecenk

package scratch;

import java.util.*;

public class islands {

  public static void main(String args[]){

    boolean map[][] = generateIslands(180, 50, new Random(287), 25, 15, .3);
    System.out.println(drawMap(map));

Alrecenk

/* This is an efficient implementation of a fixed size cache using Java generics.
 * It uses a least recently used eviction policy implemented via a combination hashtable/linked list data structure.
 * Written by Alrecenk October 2015 because I felt like playing with generics.
 */

import java.util.HashMap;
import java.util.Random;

public class Cache<KeyType, RecordType>{

Alrecenk

/* fast floating point exp function
 * must initialize table with buildexptable before using
 
Based on 
 A Fast, Compact Approximation of the Exponential Function
 Nicol N. Schraudolph 1999

Adapted to single precision to improve speed and added adjustment table to improve accuracy.
Alrecenk 2014

Alrecenk

//scales an image, maintaining aspect ratio, to fit within the desired width and height
//averages color over squares weighted by overlap area to get "perfect" results when scaling down
//does not interpolate and is not designed for scaling up, only down (hence thumbnail)
public static BufferedImage makethumbnail(BufferedImage img, double desiredwidth, double desiredheight){
  //System.out.println("Original Image size: " + img.getWidth(null)+ " x "+img.getHeight(null));
  if(img ==null || img.getWidth(null) <1 || img.getHeight(null) <1){
    return null; // something wrong with image
  }else{
    byte image[][][] = convertimage(img) ; // convert to byte array, first index is x, then y, then {r,g,b}

Alrecenk

//returns the hessian (gradient of gradient) of error with respect to weights 
//for a logistic regression with weights w on the given input and output
//output should be in the form 0 for negative, 1 for positive
public double[][] hessian(double w[]){
  heval++;//keep track of how many times this has been called
  double h[][] = new double[w.length][] ;
  //second derivative matrices are always symmetric so we only need triangular portion
  for(int j=0;j<h.length;j++){
    h[j] = new double [j+1] ;
  }

Alrecenk

//starting from w0 searches for a weight vector using gradient descent
//and Wolfe condition line-search until the gradient magnitude is below tolerance
//or a maximum number of iterations is reached.
public double[] gradientDescent(double w0[], double tolerance, int maxiter){
	double w[] = w0 ;
	double gradient[] = gradient(w0) ;
	int iteration = 0 ;
	while(Math.sqrt(dot(gradient,gradient)) > tolerance && iteration < maxiter){
		iteration++ ;
		//calculate step-size in direction of negative gradient

Alrecenk

//Performs a binary search to satisfy the Wolfe conditions
//returns alpha where next x =should be x0 + alpha*d 
//guarantees convergence as long as search direction is bounded away from being orthogonal with gradient
//x0 is starting point, d is search direction, alpha is starting step size, maxit is max iterations
//c1 and c2 are the constants of the Wolfe conditions (0.1 and 0.9 can work)
public static double stepSize(OptimizationProblem problem, double[] x0, double[] d, double alpha, int maxit, double c1, double c2){

  //get error and gradient at starting point  
  double fx0 = problem.error(x0);
  double gx0 = dot(problem.gradient(x0), d);

Alrecenk

for(int k=0;k<pos.length;k++){
  pp += pos[k]*pos[k] ;
  pn += pos[k]*neg[k] ;// calculate relevant dot products
  nn += neg[k]*neg[k] ;
}
//assuming w = alpha * (pos- neg) with b in the last w slot
//solve for alpha and b so that pos returns 0.75 and neg returns 0.25
double alphab[] = lineIntersection(pp-pn,1,sinv(0.75),pn-nn,1,sinv(0.25)) ;
w = new double[input[0].length] ;
for(int k=0;k<w.length-1;k++){