Processing.js

var x = 200;
var speed = 5;
var draw = function() {
    noStroke();
    background (252, 255, 214);
    fill (0, 0, 0);
    rect (350, 160, 50, 100);
    fill (0, 0, 0);
    rect (50, 160, 50, 100);
    fill (255, 0, 0);
    rect (x, 200, 100, 20);
    rect(x + 15, 178, 70, 40);
    fill (77, 66, 66);
    ellipse (x+25, 221, 24, 24);
    ellipse (x+75, 221, 24, 24);
    x = x + speed;
    if (x> 250) {
        speed = -5;
    }
    if (x < 100) {
        speed = 5;
    }
};

// hyperparameter to determine the strength of perspective
var persp = 200;
// apply perspective to something of size `size`
var perspective_calc = function(size, depth){ 
    return (size * persp) / (depth + persp);
}; 

// Sin class
Sin = function(z) {
    this.amp = z.amp || 1;
    this.per = z.per || width;
    this.phase = z.phase || 0;
    this.angFreq = Math.TAU / this.per;
    this.get = function(arg) {
        return this.amp * Math.sin(this.angFreq * arg - this.phase);
    };
    this.getDeriv = function(arg) {
        return this.amp * this.angFreq * Math.cos(this.angFreq * arg - this.phase);
    };
},

// Wave object
Wave = {
    list: [],
    N: 15,
    Amp: {
        start: height / 3,
        stop: height / 2.2,
        next: function() {
            return map(random(), 0, 1, this.start, this.stop);
        },
    },
    Per: {
        avg: width,
        std: width * 67 / 400,
        next: function() {
            return Math.abs(randomGaussian() * this.std + this.avg);
        },
    },
    Phase: {
        start: 0,
        stop: Math.TAU,
        next: function() {
            return map(random(), 0, 1, this.start, this.stop);
        },
    },
    const: function() {
        for(var n = 0; n < this.N; n ++){
            this.list.push(new Sin(
                { amp: this.Amp.next() / this.N, 
                  per: this.Per.next(), 
                  phase: this.Phase.next()
                }));
        }
    },
    get: function(arg) {
        var sum = 0;
        for(var w in this.list) {
            sum += this.list[w].get(arg);
        }   return sum;
    },
    getDeriv: function(arg) {
        var sum = 0;
        for(var w in this.list) {
            sum += this.list[w].getDeriv(arg);   
        }   return sum;
    }
},

// Display an Item instance
Item.prototype.display = function() {
    // set local environment for transformations
    pushMatrix();
    	// center us at position of the object
        translate(this.pos.x, this.pos.y);
        // rotate object to be parallel to gradient of Wave
        rotate(atan(Wave.getDeriv(this.outputX)) / 2);
    	// the display instructions depend on which type of object this is
        switch(this.image.substring(2)){
            // in the case our object is a Shark
            case "Shark":
                fill(Theme.Item.SharkFill);
                stroke(Theme.Item.SharkStroke); 
                strokeWeight(2);
                beginShape();
                    vertex(-20, 20);
                    bezierVertex(-9, -4, -12, -11, 10, -16);
                    bezierVertex(21, -16, 9, -5, 9, 4);
                    bezierVertex(8, -6, 10, 10, 10, 20);
                endShape();
                break;
            case "Buoy":
                //...
                break;
            //...
            default: break;
        }
	popMatrix();
};

var GRID = {
    positions: [],
    cachorro_indices: [0, 1, 2, 5, 6, 7, 10, 11, 15, 16, 17, 20, 21, 22],
    jaguar_index: 12,
    connections: [[1, 5, 6], [0, 2, 6], [1, 3, 6, 7, 8], [2, 4, 8], [3, 8, 9], [0, 6, 10], [0, 1, 2, 5, 7, 10, 11, 12], [2, 6, 8, 12], [2, 3, 4, 7, 9, 12, 13, 14], [4, 8, 14], [5, 6, 11, 15, 16], [6, 10, 12, 16], [6, 7, 8, 11, 13, 16, 17, 18], [8, 12, 14, 18], [8, 9, 13, 18, 19, 25, 26, 27], [10, 16, 20], [10, 11, 12, 15, 17, 20, 21, 22], [12, 16, 18, 22], [12, 13, 14, 17, 19, 22, 23, 24], [14, 18, 24], [15, 16, 21], [16, 20, 22], [16, 17, 18, 21, 23], [18, 22, 24], [18, 19, 23], [14, 26, 28], [14, 25, 27, 29], [14, 26, 30], [25, 29], [28, 30], [27, 29]],
    jumping: [[0, 10], [5, 15], [10, 20], [1, 11], [6, 16], [11, 21], [2, 12], [7, 17], [12, 22], [3, 13], [8, 18], [13, 23], [4, 14], [9, 19], [14, 24], [0, 2], [1, 3], [2, 4], [5, 7], [6, 8], [7, 9], [10, 12], [11, 13], [12, 14], [15, 17], [16, 18], [17, 19], [20, 22], [21, 23], [22, 24], [0, 12], [6, 18], [12, 24], [4, 12], [8, 16], [12, 20], [2, 10], [10, 22], [28, 14], [25, 18], [14, 22], [2, 14], [8, 27], [14, 30], [25, 27], [28, 30], [13, 26], [14, 29]],
    jumped: [5, 10, 15, 6, 11, 16, 7, 12, 17, 8, 13, 18, 9, 14, 19, 1, 2, 3, 6, 7, 8, 11, 12, 13, 16, 17, 18, 21, 22, 23, 6, 12, 18, 8, 12, 16, 6, 16, 25, 14, 18, 8, 14, 27, 26, 29, 14, 26]
};

// Check if dog at position index_in_cachorros may move to position at intended_index in the GRID.cachorro_indices list
var check_cachorro_valid_move = function(index_in_cachorros, intended_index) {
    var current_index = GRID.cachorro_indices[index_in_cachorros];
    if( // not another dog already occupying this space
        GRID.cachorro_indices.indexOf(intended_index) === -1 
        // this vertex is connected to the dog's current position
        && GRID.connections[current_index].indexOf(intended_index) !== -1 
		// the jaguar is not blocking this space
       	&& intended_index !== GRID.jaguar_index 
      ) {
        // return that the move is valid
        return { final: intended_index };
    }
    // return that the move is invalid
    return undefined;
};

// Rotate a list `track` of vectors about the x-axis by an angle `theta`
// 	where each vector is of the form [x, y, z]
var rotateX3D = function(theta) {
    var sin_t = sin(theta);
    var cos_t = cos(theta);
    var node, y, z;
    for (var n = 0; n < track.length; n ++) {
        node = track[n];
        y = node[1]; 
        z = node[2]; 
        track[n][1] = y * cos_t - z * sin_t; 
        track[n][2] = z * cos_t + y * sin_t;
    }
};

// Constructor
var Object3D = function(z) {
    // location
    this.position = z.position || new PVector();
    // size
    this.dimensions = z.dimensions || PVector.construct(function() { return width / 3; });
	
    this.points = []; this.edges = []; this.faces = [];
    
    // Presets
    this.rotate = z.q("rotate", true);
    this.paused = z.q("paused", false);
    this.faceColor = z.faceColor || color(255);
    this.edgeColor = z.edgeColor || color(100);
    this.pointColor = z.pointColor || color(255, 128, 0);
    this.displayPoints = z.q("displayPoints", true);
    this.displayEdges = z.q("displayEdges", true);
    this.displayFaces = z.q("displayFaces", true);
    this.flip = false;
    
    this.alpha = new PVector(); // angular acceleration
    this.omega = new PVector(); // angular velocity
    this.theta = new PVector(); // angular position
    
    this.rotateX = function(theta, center) {
        //...
    };
    this.rotateY = function(theta, center) {
        //...
    };
    this.rotateZ = function(theta, center) {
        //...
    };
};

// default hyperparameter to how perspective changes with depth
Object3D.perspectiveStandard = width;
// method to change size with depth
Object3D.perspectiveCoefficient = function(depth) {
    return (addPerspective)? this.perspectiveStandard / (Math.max(depth, 1 - this.perspectiveStandard) + this.perspectiveStandard) : 1;
};
// scale location by perspective coefficient
Object3D.getLocation = function(P) {
    return PVector.mult(P, this.perspectiveCoefficient(P.z));
};
// computes normal vector to a face P
Object3D.prototype.getNormalVectorToFace = function(P) {
    var vector = PVector.cross(PVector.sub(P[0], P[1]), PVector.sub(P[2], P[1]));
    if(P.length > 3 && vector.mag() === 0){
        vector = PVector.cross(PVector.sub(P[1], P[2]), PVector.sub(P[3], P[2]));
    }
    vector.capMag(1);
    return vector;
};
// update an object by setting random acceleration
Object3D.prototype.update = function(center) {
    if(this.rotate && !this.paused) {
        this.alpha = PVector.construct(function(){ return Math.random_0(); }); 
        // update angular motion
        this.alpha.capMag(0.1);
        this.omega.add(this.alpha);
        this.theta.add(this.omega); this.theta.capMag(1);
        // update angular position of all points in the object
        this.rotateX(this.theta.x, center); 
        this.rotateY(this.theta.y, center); 
        this.rotateZ(this.theta.z, center);
    }
};
// return color of a face P depending on angle to lightsource
Object3D.prototype.color = function(P) {
    // compute shadow constant
    var c = (PVector.dot(globalLightVector, this.getNormalVectorToFace(P)) / globalLightVector.mag() / this.getNormalVectorToFace(P).mag() + 1) / 2;
    // return corresponding shaded face color
    return lerpColor(color(0, 0, 0), this.faceColor, (this.flip ? 1 - c : c));
};
// display the object
Object3D.prototype.display = function() {
    var P = new Array(this.faces[0].length);
    // display points
    //...
    // display edges
    // ...
    // display faces 
    // ...
};

// Inheriting class constructor
var Cuboid = function(z) {
    // pass to the Object3D constructor
    Object3D.call(this, z);
    // Class specific instructions 
    //...
};
// any Cuboid instance should act like an instance of Object3D
Cuboid.prototype = Object.create(Object3D.prototype);

var redCube = new Cuboid({ 
    position: new PVector(- width / 4, - height / 5, 0), 
    dimensions: PVector.construct(function() { return width / 5; }), 
    faceColor: color(255, 0, 0), 
    displayPoints: false, 
    displayEdges: false
});

// display a 3D object
Object3D.prototype.display = function() {
	//...
    // display a face
    var face = this.faces[0];
    // adjust vertices of face to perspective 
    var P = []; 
    for(var i = 0; i < face.length; i ++){
        P[i] = Object3D.getLocation(this.points[face[i]]);
    }
    // only draw if facing forward
    if(PVector.dot(globalForwardVector, this.getNormalVectorToFace(P)) >= 0) { 
        fill(this.color(P)); 
        beginShape();
        for(var i = 0; i < face.length; i ++) {
            vertex(P[i].x, P[i].y);
        }
        endShape(CLOSE);
    }
    //...
};

// Rotate a provided coordinate by an angle theta about a center 
var rotateX3D = function(config){
    var coordinate = config.coordinate || origin;
    var theta = config.theta || 0;
    var center = config.center || origin;
    var sint = sin(theta);
    var cost = cos(theta);
    var y = coordinate.y;
    var z = coordinate.z;
    coordinate.y = (y - center.y) * cost - (z - center.z) * sint + center.y; 
    coordinate.z = (z - center.z) * cost + (y - center.y) * sint + center.z; 
    return coordinate; 
};

// Whenever a key is pressed with code keyCode
var keyPressed = function(){
    if(!keys[keyCode]){
        sign = (R.angle.x >= 90 && R.angle.x < 270)? 1: -1;
    }
    keys[keyCode] = true;
};
// Whenever a key is released with code keyCode
var keyReleased = function(){
    keys[keyCode] = false;
};
// What to do if keys is true for the arrow buttons
var checkkeys = function(){
    //Movement if statements
    if(keys[UP]){ R.angle.y += sign * 5; }
    if(keys[DOWN]){ R.angle.y -= sign * 5; }
    if(keys[RIGHT]){ R.angle.x += 5; }
    if(keys[LEFT]){ R.angle.x -= 5; }
};

// Faces drawn are based on TrackElement objects that are calculated using f, Alpha, and R
var TrackElement = function(config) {
    this.t = config.t || 0;
    this.pos = config.pos || new PVector(0, 0, 0);
    this.a = config.a || 0;
    this.R = config.R || 1;
};
// Returns a TrackElement with all of the built parts at time t given previous special vector old_w
TrackElement.get = function(t, old_w) {
    var e = new TrackElement({
        t: t, pos: f(t), a: Alpha(t), R: R(t)
    });
    e.build(old_w);
    return e;
};
// Given previous orientation vector old_w, calculates all of the necessary vector attributes
TrackElement.prototype.build = function(old_w) {
    // direction of motion
    this.d = PVector.normalize(PVector.sub(f(this.t), f(this.t - 0.001)));
    // mapping old orientation onto direction
    this.w = PVector.normalize(PVector.proj(old_w, this.d));
    // perpendicular to d and w
    this.pi = PVector.normalize(PVector.cross(this.d, this.w));
    var v = PVector.mult(PVector.add(PVector.mult(this.w, Math.cos(this.a)), PVector.mult(this.pi, Math.sin(this.a))), this.R);
    // "outside" of the track
    this.varphi = PVector.add(this.pos, v);
    // "inside" of the track
    this.phi = PVector.sub(this.pos, v);
    // how a person would be oriented riding
    this.perp = PVector.normalize(PVector.cross(this.d, v));
};

// Pane constructor
var Pane = function(config){
    // in which state of our program will this pane be displayed?
    this.gameState = config.gameState || gameState;
    // like an HTML z-index
    this.n = config.n || 0;
    // are the components in this pane immune to user interactions?
    this.disabled = config.disabled || false;
    this.components = [];
};

// These prototype methods also are defined
Pane.prototype.add_component, 
Pane.prototype.draw, 
Pane.prototype.update;

// Component constructor
var Component = function(config){
    // to which pane does this component belong
    this.pane = config.pane || 0;
    // type of component
    this.type = config.type || "";
    this.x = config.x || 0;
    this.y = config.y || 0;
    this.w = config.w || 50;
    this.h = config.h || 50;
    this.fill = config.fill || Theme.FILL;
    this.outline = config.outline || Theme.OUTLINE;
    this.inputtext = (config.inputtext || "").toString();
    this.n = panes[this.pane];
};

// These prototype methods are also defined
Component.prototype.setText,
Component.prototype.setFill,
Component.prototype.setPane,
Component.prototype.move,
Component.prototype.checkPane,
Component.prototype.mouse_on_RECT,
Component.prototype.mouse_on_ELLIPSE,
Component.prototype.analyze, 
Component.prototype.return_value;

// Update a DropDown instance
DropDown.prototype.update = function(){
    this.color_shift = 0;
    var on = false;
    // if mouse hovering over button
    if(this.mouse_on_RECT(this.x + (this.w - this.h)/2, this.y, this.h, this.h)){
        // enter hover mode
        this.hover();
        // if mouse depressed
        if(mouseIsPressed){
            on = true; 
            // if mouse newly pressed
            if(!mouse){ this.beginning = true; }}
    }
    // if displaying dropdown options
    if(this.open){
        // loop over displayed options
        DROP_HOVER:
        for(var i = 0; i < this.options.length; i ++){
            // if mouse hovering over an option
            if(this.mouse_on_RECT(this.x + this.offset, this.y + (i+1)*this.h, this.rw, this.h)){
                this.hover_index = i;
                setCursor(HAND);
                if(mouseIsPressed){ on = true; this.press(i); }
            }
        }
    }
    // react to click on dropdown button
    if(this.beginning){ this.press(); }
    if(mouseIsPressed && !on){ this.open = false; }
    // reset if no mouse pressing
    if(!mouseIsPressed){ 
        this.mouse = false; 
        this.beginning = false;
	}
    // update display value
    this.update_value();
    // reset button fill color
    this.button_fill = this.setFill(this.original_button_fill);
};

var draw = function() {
    // track mouse position/speed
    mouse_movement(); 
    // reset the cursor to arrow pointer
    setCursor(ARROW); 
    // draws background and checks state of program
    check_gameState(); 
    // draws all panes and hence their components
    draw_components(); 
    // update to cursor
    if(pcursorState !== cursorState){
        updateCursor();
        pcursorState = cursorState;
    }
    // prevents turning on a component before having clicked
    if(mouseIsPressed){ mouse = true; }
    else{ mouse = false; } 
};

// Reproduce two given Organisms into new Organism
Organism.reproduce = function(A, B) {
    // list of coefficients for x^i
    var a = {}; 
    // maxPower computed by by A and B
    var maxPower = Math.max(A.maxPower, B.maxPower);
    // who passes on their coefficient genes
    var winner = (random() < 0.5) ? A : B;
    // build new coefficient genes for child
    for(var i = 0; i < maxPower; i ++) {
        a[i] = (Math.random() <= PROBABILITY_OF_MUTATION_COEFFICIENT) ?
				winner.a[i] : 
				map(Math.random(), 0, 1, COEFFICIENT_RANGE[0], COEFFICIENT_RANGE[1]);
    }
    // keep adding coefficients for higher powers with low probability
    while(Math.random() <= PROBABILITY_OF_MUTATION_NEXTPOWER) {
        a[maxPower++] = map(Math.random(), 0, 1, COEFFICIENT_RANGE[0], COEFFICIENT_RANGE[1]);
    }
    // produce child Organism
    return new Organism({
        generation: winner.generation + 1,
        color: color(hue(winner.color + 0.10 * (Math.random() * 2 - 1) * (255)), saturation(winner.color), brightness(winner.color)),
        a: a,
        maxPower: maxPower,
        parent: [A, B]
    });
};

// INT object constructor
var INT = function(integer, base, conversion) {
    if(base === 2) {
        // remove leading zeros
        this.B2 = INT.simplifyString(str(integer));
        // bother performing conversion to base 10?
        if(conversion || conversion === undefined) { 
            this.to10(); 
        } else { this.B10 = "0"; } 
    } else { 
        this.B10 = INT.simplifyString(str(integer)); 
        if(conversion || conversion === undefined) { 
            this.to2(); 
        } else { this.B2 = "0"; }
    }
};

// add any number of INT instances
INT.ADD = function() {
    if(arguments.length === 0) { return undefined; }
    var SUM = arguments[0].copy();
    // sum the binary forms
    for(var i = 1; i < arguments.length; i ++) {
        SUM.set(INT.addBinaryString(SUM.B2, arguments[i].B2), 2, false);
    }   
    // compute its decimal form
    SUM.update(10);
    return SUM;
};
// add some number of INTs' binary forms
INT.addBinaryString = function() {
    // unpack argument[0] if array
    var args = (Array.isArray(arguments[0])) ? arguments[0] : arguments;
    switch(args.length) {
        case 0: return 0;
        case 1: return args[0].copy();
        case 2: 
            var SUM = "", sum, next = 0, 
				length = Math.max(INT.simplifyString(args[0]).length, INT.simplifyString(args[1]).length);
            // for all bits in summands
            for( var i = 0; i <= length; i ++ ) {
                // sum bits, possibly carry 1 from previous bits
                sum = parseInt(next, 2) +
                      INT.getDigit(INT.simplifyString(args[0]), i, 2) + 
                      INT.getDigit(INT.simplifyString(args[1]), i, 2) ;
                next = 0;
                if(sum > 1) { sum %= 2; next ++; }
                SUM = str(sum) + SUM;
            }
            return INT.simplifyString(SUM); 
        // when more than two summands
        default:
            var SUM = INT.simplifyString(args[0]);
            for( var i = 1; i < args.length; i ++ ) {
                SUM = INT.addBinaryString(SUM, INT.simplifyString(args[i]));
            }
            return INT.simplifyString(SUM);
    }
};

// evaluate expression E as mathematical set of instructions
INT.interpret = function(E) {
    // preparation for interpretation for whitespace
    E = E.replace(/ /g,''); E = E.replace(/\n/g, '');
    if(E.length === 0) { return ""; }
    // ignore leading operations
    if("^*/+-%(".contains(E.charAt(E.length - 1))) {
        return INT.interpret(E.substring(0, E.length - 1));
    }
    // ignore any expression outside our alphabet
    for(var i = 0; i < E.length; i ++) {
        if(!"^+-*/0123456789()% \n".contains(E.charAt(i))) {
            return "";
        }
    }
    // recursion on parenthesis
    var invar, i0, i;
    while(E.indexOf("(") > -1) {
        invar = 1; i0 = E.indexOf("("); i = i0 + 1;
        while(invar !== 0 && i++ < E.length) {
            switch(E.charAt(i)) {
                case "(": invar ++; break;
                case ")": invar --; break; default: 
            }
        }  
        if(invar !== 0) { return ""; }
        E = E.substring(0, i0) + this.interpret(E.substring(i0 + 1, i)) + E.substring(i + 1);
    }
    // generate INTs found in expression
    var numbers = [];
    var answer = "", startNum, endNum;
    ESTABLISH_INTS:
    for(var i = 0; i < E.length; i ++) {
        // continue building the number
        if("0123456789".contains(E.charAt(i))) {
            if(startNum === undefined) { 
                startNum = i; endNum = i; 
            } else { endNum ++; }
            if(i === E.length - 1) { 
                numbers.push(new INT("" + E.substring(startNum), base)); 
                E = E.substring(0, startNum); 
            }
        } else {
            numbers.push(new INT(E.substring(startNum, endNum + 1), base));
            E = E.substring(0, startNum) + E.substring(endNum + 1); i -= 1 + endNum - startNum;
            startNum = undefined;
        }
    }
    
    // prioritize exponentiation first
    EX:
    for(var i = 0; i < E.length; i ++) {
        switch(E.charAt(i)) {
            case '^': 
                numbers[i] = INT.POW(numbers[i], numbers[i + 1]);
                numbers.splice(i + 1, 1);
                E = E.substring(0, i) + E.substring(i + 1);
                i --;
                break;
        }
    }
    
    // multiplication, division, and modular division all at same priority level
    MMD: 
    for(var i = 0; i < E.length; i ++) {
        SWITCH:
        switch(E.charAt(i)) {
            case '*': 
                numbers[i] = INT.MULT(numbers[i], numbers[i + 1]);
                numbers.splice(i + 1, 1);
                E = E.substring(0, i) + E.substring(i + 1);
                i --;
                break SWITCH;
            case '/':
                numbers[i] = INT.DIV(numbers[i], numbers[i + 1]);
                numbers.splice(i + 1, 1);
                E = E.substring(0, i) + E.substring(i + 1);
                i --;
                break SWITCH;
            case '%':
                numbers[i] = INT.MOD(numbers[i], numbers[i + 1]);
                numbers.splice(i + 1, 1);
                E = E.substring(0, i) + E.substring(i + 1);
                i --;
                break SWITCH;
        }
    }
    
    // addition and subtraction share the lowest priority
    AS:
    for(var i = 0; i < E.length; i ++) {
        switch(E.charAt(i)) {
            case '+': 
                numbers[i] = INT.ADD(numbers[i], numbers[i + 1]);
                numbers.splice(i + 1, 1);
                E = E.substring(0, i) + E.substring(i + 1);
                i --;
                break;
            case '-':
                numbers[i] = INT.SUB(numbers[i], numbers[i + 1]);
                numbers.splice(i + 1, 1);
                E = E.substring(0, i) + E.substring(i + 1);
                i --;
        }
    }
    return (base === 2)? numbers[0].B2 : numbers[0].B10;
};

// cap the magnitude of this PVector to `cap`
PVector.prototype.capMag = function(cap) {
    this.mult(Math.min(cap, this.mag()) / this.mag());
};
// @static; perform the dot product between two 3D PVectors
PVector.dot = function(u, v) {
    return u.x * v.x + u.y * v.y + u.z * v.z;
};
// @static; perform the cross product between two 3D PVectors
PVector.cross = function(u, v) {
    return new PVector(u.y * v.z - u.z * v.y, u.z * v.x - u.x * v.z, u.x * v.y - u.y * v.x);
};
// @static; transform a PVector by a scale and translation
PVector.transform = function(vector, scalar, translator) {
    return PVector.add(translator, PVector.mult(vector, scalar));
};
// @static; fill in a 3D PVector with the outputs of some function `f`
PVector.construct = function(f) {
    return new PVector( f(), f(), f() );
};
// @static; Interpolate between two PVectors assuming t between 0 and 1
PVector.map = function(t, A, B) {
    return new PVector( map(t, 0, 1, A.x, B.x), map(t, 0, 1, A.y, B.y), map(t, 0, 1, A.z, B.z) );
};
// @static; Project PVector v onto plane given by normal PVector n
PVector.proj = function(v, n) { 
    return PVector.sub( v, PVector.mult(n, PVector.dot(v, n)) );
};

// set a default value for a property if not already set
Object.prototype.q = function(property, defaultVal) {
    return (this[property] === undefined) ? defaultVal : this[property];
};
// recursively copy an object
Object.prototype.copy = function() {
    var obj = {};
    // if array
    if(Array.isArray(this)) { 
        obj.length = this.length; 
    }
    // for all keys
    for(var k in this) {
        obj[k] = 
            // recursive call or pass by value
			(typeof(this[k]) === 'object') ?
			this[k].copy() : this[k];
    }
    return obj;
};

// @static; remove the element at given index
Array.remove = function(array, index) {
    array.splice(index, 1);
    return array;
};
// find first instance of e in array
Array.prototype.find = function(e) {
    for(var i = 0; i < this.length; i ++) {
        if(this[i] === e) { return i; }
    }   return -1;
};
// @static; remove the first instance of element e from array
Array.removeElement = function(array, e) {
    return Array.remove(array, array.find(e));
};
// return string assuming is 2D array
Array.prototype.toString2 = function() {
    var string = "[";
    for(var i = 0; i < this.length; i ++) {
        string += "[";
        for(var j = 0; j < this[i].length; j ++) {
            string += this[i][j] + ",";
        }
        string = string.substring(0, string.length - 1) + "],";
    }
    return string.substring(0, string.length - 1) + "]";
};
// find [i][j] index pair for element e in 2D array
Array.prototype.find2D = function(e) {
    for(var i = 0; i < this.length; i ++) {
        for(var j = 0; j < this.length; j ++) {
            if(this[i][j] === e) { return [i, j]; }
        }
    }
    return [-1, -1];
};
// @static; given equality method `equals` between Objects e, find object e
Array.prototype.findObj = function(e) {
    for(var i = 0; i < this.length; i ++) {
        if(equals(this[i], e)) { return i; }
    }   return -1;
};
// @static; remove duplicates from 1D array of Objects assuming given equality method `equals` between such Objects
Array.removeDuplicates = function(array) {
    var tempArray = [], temp;
    OUTER:
    for(var i = 0; i < array.length; i ++) {
        temp = array[i];
        for(var j = 0; j < tempArray.length; j ++) {
            if(equals(tempArray[j], temp)) {
                continue OUTER;  
            }
        }
        tempArray.push(temp);
    }
    return tempArray;
};
// copy 1D array assuming not storing arrays/objects to be passed by value
Array.prototype.shallowCopy = function() {
    var temp = [];
    for(var i = 0; i < this.length; i ++) {
        temp[i] = this[i];
    }
    return temp;
};