webclust-0.15.js

"use strict";

/* Library version */
var VERSION = "0.15";

/** ------------------------------------------------------

Main functions for the Web Clustering demo.

--------------------------------------------------------- */

/**
    Runs the visualization demo.
*/
async function demo() {
    running = true;
    
    // Wait function
    const delay = ms => new Promise(res => setTimeout(res, ms));
    
    // Disable button
    disable("demo", "running");
    await delay(25);
    
    clear();
    
    // Get clustering algorithm type and dataset name
    let type = get_selected_algorithm();
    let name = get_selected_dataset();

    // Get render options for the dataset
    let opt = get_render_options(name);
    let msize = get_marker_size(type);

    // Get data
    let data = orig_data.clone();

    // Build and train a clustering algorithm
    let cl = build_cluster(type);
    cl.train(data);
    
    if (!cl.iterable()) {
        let map = create_decision_boundaries(cl, opt);
        draw_map(map);
        draw_labels(data, opt);
        draw_markers(cl.get_markers(), opt, msize);
    }
    else {
        // Enable Stop button
        enable("stop");
        
        while (!cl.done() && running) {
            // Start time
            let start = new Date().getTime();

            // Iterate classifier
            cl.iterate();
            let map = create_decision_boundaries(cl, opt);
            draw_map(map);
            draw_labels(data, opt);
            draw_markers(cl.get_markers(), opt, msize);
            document.getElementById("citer").innerHTML = "Iteration: " + cl.current_iteration();
            
            // Time elapsed
            let end = new Date().getTime();
            let time = end - start;
            let rest = 150 - time;
            if (rest < 10) rest = 10;
            // Wait
            await delay(rest);
        }

        // Disable Stop button
        disable("stop");
    }
    document.getElementById("clusters").innerHTML = "Clusters: " + cl.no_clusters();
    
    // Enable button
    enable("demo");

    running = false;
}

/**
    Stops the iteration for iterable algorithms.
*/
function stop_demo() {
    running = false;
}

/**
    Optimize the k-value for K-Means clustering.
*/
async function optimize_k() {
    running = true;
    
    // Wait function
    const delay = ms => new Promise(res => setTimeout(res, ms));
    
    // Disable button
    disable("demo", "running");
    await delay(25);
    
    // Get dataset name
    let name = get_selected_dataset();
    // Get data
    let data = orig_data.clone();

    // Get params
    let dist = get_select_list("dist", 0);
    let init = get_select_list("init", 1);
    let seed = get_value("seed", 42, 0, 10000);

    // Run silhouette score optimization
    let opt = new KOptimizer(data, dist, init, seed);
    let k = opt.optimize();
    
    document.getElementById("k").value = k;

    // Enable button
    enable("demo");

    running = false;
}

/**
    Creates a map of the dedision boundaries for the current trained clustering algorithm.
*/
function create_decision_boundaries(classifier, opt) {
    let map = new Array(100 * 100).fill(0);
    
    // 100x100 map
    for (let x1 = 0; x1 < 100; x1++) {
        for (let x2 = 0; x2 < 100; x2++) {
            // x-values
            let v1 = x1 / 100.0 * opt[0] + opt[2];
            let v2 = x2 / 100.0 * opt[1] + opt[3];
            
            v1 += 0.005;
            v2 += 0.005;
            
            // Prediction
            let pred = classifier.predict([[v1, v2]]);
            // Set predicted label
            map[x1 + x2 * 100] = pred[0];
        }
    }
    return map;
}

/**
    Validates hyperparameter settings.
*/
function validate_setting(id, value, min_val, max_val) {
    let v = value;
    if (v < min_val) {
        v = min_val;
    }
    if (v > max_val) {
        v = max_val;
    }
    if (v != value) {
        document.getElementById(id).value = v;
    }
    return v;
}

/**
    Builds the specified clustering algorithm and trains on the specified dataset.
*/
function build_cluster(type) {
    if (type == "kmeans") {
        // Get options
        let k = get_value("k", 3, 1, 32);
        let dist = get_select_list("dist", 0);
        let init = get_select_list("init", 1);
        let seed = get_value("seed", 42, 0, 10000);

        let cl = new KMeans(k, dist, init, seed);
        return cl;
    }
    else if (type == "dbscan") {
        // Get options
        let eps = get_value("eps", 0.2, 0.01, 100, parseFloat);
        let min_pts = get_value("minpts", 5, 2, 100);
        let dist = get_select_list("dist", 0);
        
        let cl = new DBScan(eps, min_pts, dist);
        return cl;
    }
    else if (type == "meanshift") {
        // Get options
        let bw = get_value("bandwidth", 0.1, 0.05, 1, parseFloat);
        let dist = get_select_list("dist", 0);
        let w = get_select_list("weight", 0);
        
        let cl = new MeanShift(bw, dist, w);
        return cl;
    }
    else {
        throw("Unknown clustering algorithm: " + type);
    }
}

/** ------------------------------------------------------

Util functions for the VisualML demo.

--------------------------------------------------------- */

// Is set to true if a classifier is running
var running = false;

/**
    Shows the element with the specified id.
*/
function show(id) {
    let e = document.getElementById(id);
    if (e != null) {
        e.style.display = "block";
    }
}

/**
    Hides the element with the specified id.
*/
function hide(id) {
    let e = document.getElementById(id);
    if (e != null) {
        e.style.display = "none";
    }
}

/**
    Toggles visibility of the element with the specified id.
*/
function toggle(id) {
    let e = document.getElementById(id);
    if (e.style.display == "none") {
        e.style.display = "block";
    }
    else {
        e.style.display = "none";
    }
}

/**
    Toggles visibility of the element with the specified id and updates 
    expand arrow.
*/
function toggle_bt(id) {
    let e = document.getElementById(id);
    let bt = document.getElementById(id + "_bt");
    if (e.style.display == "none") {
        e.style.display = "block";
        bt.innerHTML = "&#9660;";
    }
    else {
        e.style.display = "none";
        bt.innerHTML = "&#9658;";
    }
}

/**
    Enables an element.
*/
function enable(id) {
    let e = document.getElementById(id);
    e.disabled = false;
    e.className = "enabled";
}

/**
    Disables an element.
*/
function disable(id, classid="disabled") {
    let e = document.getElementById(id);
    e.disabled = true;
    e.className = classid;
}

/**
    Returns the value of an input field as an integer array.
*/
function get_array(id, default_arr, conv_func=parseInt) {
    let e = document.getElementById(id);
    if (e == null) {
        return default_arr;
    }
    
    let str = e.value;
    
    let arr = str.split(",");
    for (let i in arr) {
        let val = arr[i];
        val = val.trim();
        arr[i] = conv_func(val);
        if (isNaN(arr[i])) {
            e.value = default_arr;
            return default_arr;
        }
    }
    return arr;
}

/**
    Returns the integer value from an input field.
*/
function get_value(id, default_val, min_val, max_val, conv_func=parseInt) {
    // Check if element is available
    let e = document.getElementById(id);
    if (e == null) {
        return default_val;
    }
    
    let str = e.value;
    str = str.trim();
    let val = conv_func(str);
    // Check if valid int
    if (isNaN(val)) {
        e.value = default_val;
        val = default_val;
    }

    // Range check
    if (val < min_val) {
        val = min_val;
        e.value = val;
    }
    if (val > max_val) {
        val = max_val;
        e.value = val;
    }

    return val;
}

/**
    Returns the selected value in a dropdown list.
*/
function get_select_list(id, default_val) {
    // Check if element is available
    let e = document.getElementById(id);
    if (e == null) {
        return default_val;
    }

    // Get selected value
    let val = e.options[e.selectedIndex].value;
    return val;
}


/**
    Returns the selected classifier.
*/
function get_selected_algorithm() {
    // Dataset radio buttons
    let name = ""
    let rlist = document.getElementsByName("sel-cl");
    for (let i = 0, length = rlist.length; i < length; i++) {
        if (rlist[i].checked)  {
            name = rlist[i].value;
            break;
        }
    }
    return name;
}

/**
    Returns the selected dataset.
*/
function get_selected_dataset() {
    // Dataset radio buttons
    let name = ""
    let rlist = document.getElementsByName("sel-ds");
    for (let i = 0, length = rlist.length; i < length; i++) {
        if (rlist[i].checked)  {
            name = rlist[i].value;
            break;
        }
    }
    return name;
}

/**
    Shows the settings for the selected classifier.
*/
function update_settings() {
    let type = get_selected_algorithm();
    let name = get_selected_dataset();
    
    let settings = get_settings(type, name);
    
    document.getElementById("opts").innerHTML = "";
    
    let html = "<table><tr>";
    if (type == "kmeans") {
        html += "<td class='param'>Clusters:</td><td><input class='value' name='k' id='k' value='" + settings[0] + "'></td>";
        html += "<td class='param'>Distance function:</td><td><select id='dist' class='value'><option value='0'>Euclidean</option><option value='1'>Manhattan</option><option value='2'>Chebyshev</option></select></td>";
        html += "<td class='param'>Initialization:</td><td><select id='init' class='value'><option value='1'>K-Means++</option><option value='0'>Random</option></select></td>";
        html += "<td class='param'>Seed:</td><td><input class='value' name='seed' id='seed' value='" + settings[1] + "'></td>";
        html += "</tr><tr>";
        html += "<td colspan='2' class='param'><input type='button' style='background-color: #d4e3cf;' onclick='javascript:optimize_k()' value='Find no clusters'></button></td>";
        html += "<td colspan='6'>Find optimal number of clusters using silhouette score</td>";
    }
    else if (type == "dbscan") {
        html += "<td class='param'>Epsilon:</td><td><input class='value' name='eps' id='eps' value='" + settings[0] + "'></td>";
        html += "<td class='param'>Min samples:</td><td><input class='value' name='minpts' id='minpts' value='" + settings[1] + "'></td>";
        html += "<td class='param'>Distance function:</td><td><select id='dist' class='value'><option value='0'>Euclidean</option><option value='1'>Manhattan</option><option value='2'>Chebyshev</option></select></td>";
    }
    else if (type == "meanshift") {
        html += "<td class='param'>Bandwidth:</td><td><input class='value' name='bandwidth' id='bandwidth' value='" + settings[0] + "'></td>";
        html += "<td class='param'>Distance function:</td><td><select id='dist' class='value'><option value='0'>Euclidean</option><option value='1'>Manhattan</option><option value='2'>Chebyshev</option></select></td>";
        html += "<td class='param'>Weight:</td><td><select id='weight' class='value'><option value='1'>Gaussian Kernel</option><option value='0'>None</option></select></td>";
    }
    html += "</tr></table>";
    
    document.getElementById("opts").innerHTML = html;
}

/**
    Shows the dataset labels.
*/
function show_data() {
    if (running) return;

    clear();
    
    data_name = get_selected_dataset();
    orig_data = get_dataset(data_name);
    let opt = get_render_options(data_name);
    
    draw_labels(orig_data, opt);
}

/**
    Shows the library version in a html "version" field.
*/
function show_version() {
    document.getElementById("version").innerHTML = VERSION;
}


// Randomizer seed
var global_seed = 42;
// Original data
var orig_data = null;
// Dataset name
var data_name;

/**
	Custom random function.

	Built-in random has no seed feature. Instead a simple pseudo-random with seed is used.  
	See explanation here:
    https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript
*/
function rnd() {
    let x = Math.sin(global_seed++) * 10000;
    return x - Math.floor(x);
}

/**
    Random normally distributed using the Box-Muller transform.

    See explanation here:
    https://stackoverflow.com/questions/25582882/javascript-math-random-normal-distribution-gaussian-bell-curve
*/
function rnd_bm() {
    let u = 0, v = 0;
    while(u === 0) u = rnd(); //Converting [0,1) to (0,1)
    while(v === 0) v = rnd();
    let num = Math.sqrt( -2.0 * Math.log( u ) ) * Math.cos( 2.0 * Math.PI * v );
    num = num / 10.0 + 0.5; // Translate to 0 -> 1
    if (num > 1 || num < 0) return rnd_bm(); // resample between 0 and 1
    return num;
}

/**
    Dictionary get function.
*/
function get(dict, key) {
    key += "";
    for (let  i = 0; i < dict.length; i++) {
        if (dict[i].key == key) {
            return dict[i].value;
        }
    }
    return null;
}

/** ------------------------------------------------------

Datasets used in the VisualML demo.

--------------------------------------------------------- */

/**
    Spiral dataset.
*/
function get_spiral() {
    let spiral_x = [
	    [ 0.000, 0.000], [ 0.001, 0.010], [ 0.006, 0.019], [ 0.016, 0.026], [ 0.021, 0.035], [ 0.000, 0.051], [ 0.025, 0.055], [ 0.018, 0.068],
		[ 0.024, 0.077], [ 0.039, 0.082], [ 0.042, 0.092], [ 0.075, 0.082], [ 0.072, 0.097], [ 0.069, 0.112], [ 0.086, 0.112], [ 0.094, 0.118],
		[ 0.131, 0.095], [ 0.103, 0.137], [ 0.129, 0.128], [ 0.108, 0.159], [ 0.059, 0.193], [ 0.176, 0.118], [ 0.194, 0.108], [ 0.164, 0.165],
		[ 0.240, 0.036], [ 0.166, 0.190], [ 0.229, 0.128], [ 0.237, 0.135], [ 0.280, 0.037], [ 0.291, 0.031], [ 0.287, 0.098], [ 0.304, 0.075],
		[ 0.290, 0.142], [ 0.269, 0.197], [ 0.331, 0.090], [ 0.351, 0.044], [ 0.361,-0.047], [ 0.369,-0.061], [ 0.381, 0.043], [ 0.393, 0.022],
		[ 0.399, 0.066], [ 0.406, 0.082], [ 0.414, 0.091], [ 0.369,-0.230], [ 0.442,-0.047], [ 0.449,-0.072], [ 0.464,-0.017], [ 0.420,-0.221],
		[ 0.484,-0.022], [ 0.462,-0.177], [ 0.487,-0.135], [ 0.434,-0.277], [ 0.478,-0.218], [ 0.506,-0.176], [ 0.449,-0.310], [ 0.411,-0.373],
		[ 0.431,-0.367], [ 0.404,-0.410], [ 0.468,-0.353], [ 0.440,-0.402], [ 0.456,-0.399], [ 0.419,-0.451], [ 0.449,-0.437], [ 0.514,-0.375],
		[ 0.321,-0.561], [ 0.368,-0.543], [ 0.479,-0.464], [ 0.227,-0.638], [ 0.374,-0.576], [ 0.235,-0.656], [ 0.118,-0.697], [ 0.175,-0.695],
		[ 0.003,-0.727], [ 0.313,-0.667], [ 0.053,-0.746], [ 0.186,-0.734], [ 0.186,-0.745], [ 0.113,-0.769], [ 0.041,-0.787], [-0.049,-0.796],
		[ 0.115,-0.800], [-0.251,-0.779], [-0.217,-0.799], [ 0.080,-0.835], [-0.443,-0.723], [-0.534,-0.672], [-0.468,-0.732], [-0.291,-0.829],
		[-0.176,-0.871], [-0.555,-0.707], [-0.366,-0.832], [-0.646,-0.654], [-0.538,-0.758], [-0.681,-0.647], [-0.632,-0.709], [-0.713,-0.642],
		[-0.653,-0.717], [-0.888,-0.414], [-0.739,-0.658], [-0.807,-0.591], [-0.000,-0.000], [-0.006,-0.008], [-0.013,-0.016], [-0.028,-0.012],
		[-0.029,-0.029], [-0.050,-0.006], [-0.052,-0.032], [-0.059,-0.039], [-0.081,-0.000], [-0.091,-0.005], [-0.101, 0.007], [-0.111,-0.010],
		[-0.112,-0.047], [-0.129, 0.025], [-0.139,-0.028], [-0.151, 0.008], [-0.160, 0.020], [-0.171,-0.010], [-0.180, 0.025], [-0.186, 0.046],
		[-0.199, 0.034], [-0.211,-0.018], [-0.216, 0.052], [-0.206, 0.108], [-0.241, 0.029], [-0.244, 0.067], [-0.254, 0.065], [-0.200, 0.186],
		[-0.241, 0.149], [-0.251, 0.151], [-0.285, 0.103], [-0.250, 0.189], [-0.292, 0.139], [-0.270, 0.196], [-0.296, 0.175], [-0.237, 0.263],
		[-0.238, 0.275], [-0.276, 0.252], [-0.238, 0.301], [-0.315, 0.237], [-0.332, 0.230], [-0.212, 0.355], [-0.223, 0.361], [-0.177, 0.397],
		[-0.013, 0.444], [-0.124, 0.437], [-0.265, 0.382], [-0.076, 0.469], [-0.277, 0.398], [-0.191, 0.457], [-0.138, 0.486], [ 0.062, 0.511],
		[-0.171, 0.497], [-0.162, 0.510], [-0.066, 0.541], [-0.107, 0.545], [ 0.115, 0.554], [-0.112, 0.565], [-0.099, 0.577], [ 0.008, 0.596],
		[ 0.025, 0.606], [ 0.331, 0.520], [ 0.251, 0.574], [ 0.176, 0.612], [ 0.037, 0.645], [ 0.322, 0.572], [ 0.122, 0.655], [ 0.078, 0.672],
		[ 0.443, 0.525], [ 0.375, 0.587], [ 0.471, 0.527], [ 0.434, 0.571], [ 0.520, 0.508], [ 0.377, 0.634], [ 0.358, 0.656], [ 0.586, 0.481],
		[ 0.450, 0.622], [ 0.495, 0.600], [ 0.553, 0.562], [ 0.631, 0.488], [ 0.622, 0.516], [ 0.536, 0.618], [ 0.649, 0.514], [ 0.491, 0.680],
		[ 0.801, 0.279], [ 0.634, 0.579], [ 0.717, 0.491], [ 0.832, 0.283], [ 0.802, 0.384], [ 0.898,-0.045], [ 0.808, 0.417], [ 0.912, 0.114],
		[ 0.920, 0.134], [ 0.889, 0.304], [ 0.948,-0.046], [ 0.958, 0.048], [ 0.954,-0.173], [ 0.954,-0.223], [ 0.850,-0.507], [ 0.916,-0.402],
		[ 0.000,-0.000], [ 0.010,-0.001], [ 0.018,-0.009], [ 0.028,-0.012], [ 0.037,-0.017], [ 0.050,-0.001], [ 0.056,-0.023], [ 0.068,-0.020],
		[ 0.070,-0.041], [ 0.080,-0.043], [ 0.075,-0.068], [ 0.088,-0.068], [ 0.085,-0.086], [ 0.110,-0.072], [ 0.123,-0.071], [ 0.119,-0.094],
		[ 0.114,-0.115], [ 0.106,-0.135], [ 0.044,-0.176], [ 0.119,-0.151], [ 0.146,-0.140], [ 0.128,-0.169], [ 0.131,-0.180], [ 0.090,-0.214],
		[ 0.168,-0.175], [ 0.099,-0.232], [ 0.088,-0.247], [ 0.077,-0.262], [ 0.113,-0.259], [ 0.087,-0.280], [ 0.145,-0.266], [ 0.084,-0.302],
		[ 0.077,-0.314], [ 0.003,-0.333], [ 0.096,-0.330], [-0.051,-0.350], [-0.117,-0.344], [ 0.126,-0.352], [-0.075,-0.377], [-0.111,-0.378],
		[-0.026,-0.403], [-0.063,-0.409], [-0.103,-0.412], [-0.109,-0.421], [-0.128,-0.426], [-0.026,-0.454], [-0.286,-0.366], [-0.302,-0.366],
		[-0.167,-0.455], [-0.128,-0.478], [-0.325,-0.386], [-0.256,-0.447], [-0.340,-0.400], [-0.325,-0.425], [-0.426,-0.341], [-0.447,-0.329],
		[-0.361,-0.435], [-0.326,-0.475], [-0.332,-0.483], [-0.526,-0.280], [-0.418,-0.439], [-0.497,-0.364], [-0.513,-0.359], [-0.570,-0.283],
		[-0.452,-0.462], [-0.621,-0.214], [-0.650,-0.148], [-0.652,-0.181], [-0.654,-0.210], [-0.685,-0.130], [-0.704,-0.062], [-0.557,-0.452],
		[-0.694, 0.218], [-0.737, 0.024], [-0.741,-0.101], [-0.757,-0.033], [-0.756, 0.133], [-0.774, 0.072], [-0.763,-0.195], [-0.654, 0.457],
		[-0.790, 0.172], [-0.725, 0.379], [-0.815, 0.148], [-0.660, 0.517], [-0.762, 0.373], [-0.727, 0.456], [-0.837, 0.232], [-0.636, 0.607],
		[-0.681, 0.571], [-0.586, 0.682], [-0.791, 0.448], [-0.766, 0.508], [-0.352, 0.860], [-0.801, 0.491], [-0.678, 0.665], [-0.461, 0.842],
		[-0.601, 0.761], [-0.496, 0.845], [-0.628, 0.766], [-0.473, 0.881]
	];
    
    let data = new Dataset(spiral_x);
    return data;
}

/**
    Flame dataset.
*/
function get_flame() {
    let flame_x = [
		[0.123,0.273], [0.090,0.312], [0.093,0.425], [0.057,0.432], [0.033,0.455], [0.043,0.488], [0.073,0.465], [0.090,0.445],
		[0.130,0.440], [0.160,0.452], [0.120,0.467], [0.167,0.472], [0.197,0.487], [0.127,0.492], [0.090,0.485], [0.090,0.503],
		[0.083,0.522], [0.117,0.532], [0.133,0.513], [0.167,0.500], [0.113,0.565], [0.160,0.532], [0.203,0.518], [0.247,0.518],
		[0.230,0.537], [0.197,0.550], [0.160,0.553], [0.160,0.592], [0.190,0.575], [0.217,0.565], [0.263,0.547], [0.180,0.607],
		[0.230,0.598], [0.253,0.582], [0.267,0.563], [0.297,0.537], [0.310,0.562], [0.323,0.585], [0.287,0.598], [0.223,0.623],
		[0.247,0.657], [0.293,0.635], [0.283,0.620], [0.320,0.612], [0.350,0.592], [0.383,0.582], [0.353,0.558], [0.403,0.548],
		[0.433,0.570], [0.403,0.593], [0.373,0.607], [0.363,0.628], [0.337,0.648], [0.303,0.665], [0.330,0.685], [0.390,0.707],
		[0.373,0.690], [0.377,0.667], [0.397,0.640], [0.417,0.653], [0.407,0.618], [0.440,0.612], [0.443,0.590], [0.487,0.588],
		[0.523,0.590], [0.477,0.607], [0.507,0.610], [0.447,0.625], [0.487,0.625], [0.447,0.640], [0.487,0.645], [0.450,0.657],
		[0.493,0.660], [0.437,0.675], [0.490,0.673], [0.453,0.702], [0.497,0.697], [0.457,0.718], [0.507,0.713], [0.570,0.712],
		[0.547,0.683], [0.527,0.663], [0.537,0.650], [0.520,0.633], [0.533,0.618], [0.560,0.597], [0.577,0.608], [0.593,0.630],
		[0.560,0.630], [0.577,0.645], [0.563,0.665], [0.590,0.688], [0.640,0.690], [0.610,0.667], [0.680,0.667], [0.633,0.645],
		[0.717,0.647], [0.697,0.627], [0.657,0.630], [0.627,0.613], [0.677,0.610], [0.657,0.595], [0.603,0.592], [0.620,0.577],
		[0.610,0.562], [0.567,0.573], [0.777,0.618], [0.740,0.612], [0.693,0.592], [0.667,0.568], [0.797,0.592], [0.750,0.587],
		[0.707,0.570], [0.743,0.567], [0.793,0.572], [0.840,0.570], [0.787,0.552], [0.737,0.552], [0.687,0.553], [0.660,0.542],
		[0.697,0.533], [0.870,0.537], [0.833,0.542], [0.793,0.532], [0.747,0.525], [0.723,0.505], [0.760,0.492], [0.780,0.513],
		[0.820,0.518], [0.863,0.515], [0.837,0.502], [0.803,0.492], [0.783,0.463], [0.817,0.472], [0.853,0.483], [0.903,0.500],
		[0.907,0.480], [0.863,0.467], [0.833,0.458], [0.813,0.438], [0.847,0.422], [0.867,0.443], [0.903,0.460], [0.937,0.458],
		[0.947,0.432], [0.940,0.413], [0.900,0.440], [0.890,0.417], [0.887,0.400], [0.487,0.562], [0.530,0.555], [0.513,0.532],
		[0.450,0.537], [0.350,0.522], [0.410,0.510], [0.467,0.510], [0.507,0.493], [0.570,0.513], [0.623,0.517], [0.553,0.485],
		[0.527,0.480], [0.477,0.475], [0.447,0.490], [0.347,0.497], [0.413,0.468], [0.450,0.453], [0.410,0.450], [0.377,0.460],
		[0.310,0.448], [0.273,0.418], [0.357,0.440], [0.493,0.447], [0.517,0.463], [0.567,0.457], [0.620,0.467], [0.647,0.435],
		[0.587,0.435], [0.537,0.437], [0.507,0.428], [0.457,0.433], [0.413,0.425], [0.380,0.420], [0.340,0.415], [0.303,0.395],
		[0.367,0.400], [0.407,0.398], [0.433,0.413], [0.450,0.402], [0.487,0.408], [0.553,0.420], [0.593,0.410], [0.637,0.412],
		[0.690,0.397], [0.530,0.398], [0.263,0.387], [0.250,0.358], [0.260,0.335], [0.303,0.312], [0.350,0.308], [0.433,0.280],
		[0.497,0.280], [0.557,0.288], [0.617,0.293], [0.663,0.317], [0.703,0.347], [0.660,0.368], [0.613,0.383], [0.570,0.393],
		[0.587,0.373], [0.613,0.355], [0.637,0.332], [0.603,0.313], [0.587,0.340], [0.543,0.322], [0.537,0.340], [0.557,0.360],
		[0.527,0.357], [0.537,0.377], [0.487,0.387], [0.503,0.372], [0.457,0.385], [0.417,0.378], [0.370,0.383], [0.310,0.363],
		[0.333,0.348], [0.370,0.330], [0.370,0.358], [0.413,0.360], [0.453,0.365], [0.493,0.358], [0.443,0.352], [0.410,0.340],
		[0.433,0.330], [0.440,0.313], [0.513,0.312], [0.500,0.327], [0.500,0.345], [0.470,0.338], [0.460,0.295], [0.410,0.303]
    ];
    
    let data = new Dataset(flame_x);
    return data;
}

/**
    Moons dataset.
*/
function get_moons() {
    let moons_x = [
		[0.285,0.684], [0.500,0.694], [0.350,0.548], [0.210,0.742], [0.377,0.710], [0.817,0.385], [0.382,0.420], [0.951,0.495], 
		[0.054,0.599], [0.059,0.514], [0.837,0.315], [0.060,0.473], [0.371,0.696], [0.411,0.755], [0.520,0.257], [0.190,0.691], 
		[0.210,0.680], [0.665,0.470], [0.712,0.252], [0.395,0.475], [0.348,0.395], [0.573,0.538], [0.429,0.669], [0.067,0.486], 
		[0.034,0.581], [0.436,0.648], [0.857,0.478], [0.631,0.300], [0.920,0.446], [0.667,0.552], [0.480,0.700], [0.472,0.325], 
		[0.210,0.678], [0.482,0.338], [0.807,0.314], [0.450,0.321], [0.615,0.542], [0.046,0.620], [0.095,0.577], [0.830,0.374], 
		[0.749,0.262], [0.780,0.394], [0.646,0.460], [0.493,0.664], [0.843,0.307], [0.447,0.350], [0.631,0.586], [0.341,0.442], 
		[0.724,0.334], [0.934,0.472], [0.125,0.578], [0.148,0.642], [0.520,0.651], [0.730,0.310], [0.165,0.665], [0.506,0.684], 
		[0.063,0.556], [0.420,0.403], [0.389,0.453], [0.009,0.428], [0.643,0.502], [0.538,0.645], [0.067,0.545], [0.444,0.400], 
		[0.448,0.716], [0.960,0.437], [0.155,0.609], [0.446,0.369], [0.916,0.440], [0.883,0.532], [0.059,0.448], [0.909,0.450], 
		[0.544,0.282], [0.497,0.312], [0.606,0.495], [0.154,0.600], [0.740,0.339], [0.709,0.271], [0.234,0.759], [0.859,0.409], 
		[0.883,0.478], [0.151,0.631], [0.580,0.545], [0.515,0.354], [0.260,0.676], [0.742,0.283], [0.361,0.429], [0.360,0.511], 
		[0.607,0.600], [0.045,0.407], [0.527,0.585], [0.118,0.503], [0.332,0.542], [0.531,0.674], [0.370,0.532], [0.642,0.303], 
		[0.092,0.452], [0.853,0.351], [0.114,0.571], [0.496,0.639], [0.573,0.289], [0.092,0.650], [0.363,0.653], [0.071,0.477], 
		[0.432,0.760], [0.800,0.308], [0.323,0.724], [0.054,0.519], [0.339,0.484], [0.152,0.641], [0.091,0.487], [0.185,0.703], 
		[0.085,0.552], [0.601,0.533], [0.288,0.726], [0.448,0.288], [0.635,0.425], [0.841,0.425], [0.460,0.711], [0.165,0.633], 
		[0.208,0.637], [0.185,0.643], [0.075,0.526], [0.795,0.270], [0.047,0.457], [0.609,0.294], [0.086,0.513], [0.332,0.712], 
		[0.331,0.565], [0.260,0.715], [0.058,0.570], [0.591,0.188], [0.613,0.418], [0.321,0.387], [0.605,0.516], [0.882,0.516], 
		[0.933,0.556], [0.690,0.507], [0.435,0.320], [0.311,0.714], [0.620,0.553], [0.642,0.491], [0.553,0.268], [0.220,0.669], 
		[0.885,0.356], [0.094,0.506], [0.381,0.733], [0.047,0.539], [0.589,0.626], [0.259,0.738], [0.652,0.293], [0.094,0.624], 
		[0.911,0.552], [0.392,0.680], [0.059,0.453], [0.167,0.595], [0.491,0.316], [0.536,0.290], [0.650,0.497], [0.552,0.350], 
		[0.890,0.474], [0.642,0.297], [0.126,0.638], [0.269,0.689], [0.753,0.268], [0.675,0.266], [0.042,0.419], [0.418,0.399], 
		[0.463,0.702], [0.747,0.306], [0.412,0.378], [0.066,0.575], [0.564,0.652], [0.858,0.359], [0.367,0.460], [0.671,0.405], 
		[0.571,0.545], [0.214,0.729], [0.692,0.311], [0.688,0.470], [0.879,0.353], [0.312,0.599], [0.957,0.519], [0.383,0.367], 
		[0.847,0.390], [0.664,0.298], [0.012,0.472], [0.430,0.367], [0.671,0.274], [0.817,0.341], [0.077,0.452], [0.651,0.253], 
		[0.484,0.682], [0.908,0.619], [0.574,0.599], [0.346,0.479], [0.853,0.396], [0.648,0.293], [0.955,0.512], [0.802,0.267], 
		[0.057,0.386], [0.516,0.326], [0.634,0.246], [0.114,0.627], [0.290,0.684], [0.904,0.339], [0.377,0.731], [0.187,0.661], 
		[0.390,0.443], [0.338,0.704], [0.426,0.373], [0.932,0.536], [0.360,0.476], [0.544,0.319], [0.406,0.388], [0.591,0.241], 
		[0.220,0.689], [0.660,0.439], [0.850,0.354], [0.414,0.388], [0.908,0.516], [0.468,0.338], [0.583,0.246], [0.592,0.551], 
		[0.927,0.571], [0.012,0.444], [0.308,0.478], [0.597,0.617], [0.799,0.366], [0.926,0.373], [0.100,0.613], [0.395,0.723], 
		[0.631,0.549], [0.847,0.448], [0.424,0.670], [0.433,0.331], [0.543,0.637], [0.593,0.319], [0.076,0.519], [0.416,0.680], 
		[0.766,0.335], [0.504,0.572], [0.092,0.579], [0.350,0.532], [0.476,0.671], [0.620,0.644], [0.936,0.491], [0.334,0.532], 
		[0.515,0.328], [0.885,0.472], [0.307,0.734], [0.075,0.528], [0.101,0.539], [0.651,0.193], [0.583,0.588], [0.508,0.292], 
		[0.923,0.506], [0.404,0.318], [0.054,0.441], [0.413,0.358], [0.725,0.246], [0.615,0.504], [0.539,0.298], [0.098,0.523], 
		[0.383,0.548], [0.508,0.654], [0.428,0.390], [0.289,0.716], [0.888,0.429], [0.146,0.573], [0.117,0.572], [0.543,0.260], 
		[0.483,0.303], [0.495,0.656], [0.315,0.694], [0.804,0.301], [0.328,0.554], [0.675,0.278], [0.434,0.700], [0.665,0.313], 
		[0.350,0.663], [0.555,0.597], [0.644,0.288], [0.373,0.717], [0.450,0.636], [0.928,0.621], [0.182,0.625], [0.374,0.698], 
		[0.541,0.577], [0.249,0.733], [0.354,0.585], [0.614,0.474], [0.404,0.504], [0.679,0.462], [0.526,0.596], [0.888,0.375], 
		[0.684,0.321], [0.840,0.394], [0.530,0.625], [0.242,0.665], [0.768,0.271], [0.377,0.511], [0.732,0.287], [0.508,0.291], 
		[0.233,0.660], [0.440,0.356], [0.678,0.412], [0.165,0.674], [0.586,0.605], [0.406,0.335], [0.850,0.497], [0.810,0.398], 
		[0.349,0.479], [0.357,0.755], [0.653,0.547], [0.896,0.515], [0.386,0.364], [0.738,0.275], [0.495,0.320], [0.610,0.568], 
		[0.305,0.532], [0.968,0.579], [0.823,0.286], [0.346,0.406], [0.225,0.654], [0.105,0.632], [0.900,0.576], [0.146,0.607], 
		[0.816,0.364], [0.520,0.639], [0.153,0.662], [0.180,0.708], [0.711,0.310], [0.746,0.329], [0.047,0.452], [0.491,0.679], 
		[0.402,0.715], [0.605,0.498], [0.955,0.509], [0.950,0.474], [0.072,0.460], [0.209,0.666], [0.337,0.731], [0.388,0.421], 
		[0.180,0.629], [0.906,0.413], [0.851,0.370], [0.123,0.579], [0.813,0.321], [0.863,0.401], [0.901,0.431], [0.667,0.231], 
		[0.969,0.503], [0.310,0.534], [0.592,0.281], [0.619,0.552], [0.420,0.724], [0.556,0.572], [0.468,0.687], [0.343,0.447], 
		[0.659,0.263], [0.563,0.669], [0.449,0.357], [0.407,0.421], [0.456,0.327], [0.269,0.667], [0.332,0.493], [0.702,0.293], 
		[0.294,0.744], [0.664,0.454], [0.508,0.631], [0.778,0.233], [0.523,0.320], [0.147,0.626], [0.365,0.453], [0.618,0.288], 
		[0.119,0.629], [1.000,0.565], [0.662,0.424], [0.615,0.500], [0.855,0.337], [0.775,0.308], [0.493,0.707], [0.159,0.609], 
		[0.874,0.427], [0.962,0.553], [0.853,0.413], [0.939,0.451], [0.733,0.329], [0.928,0.562], [0.285,0.699], [0.818,0.337], 
		[0.635,0.425], [0.828,0.353], [0.899,0.377], [0.426,0.351], [0.862,0.457], [0.451,0.305], [0.591,0.300], [0.841,0.364], 
		[0.070,0.429], [0.875,0.354], [0.337,0.611], [0.245,0.693], [0.573,0.555], [0.404,0.394], [0.615,0.447], [0.358,0.435], 
		[0.395,0.685], [0.612,0.605], [0.243,0.707], [0.428,0.365], [0.835,0.419], [0.584,0.233], [0.385,0.706], [0.980,0.495], 
		[1.000,0.482], [0.508,0.635], [0.368,0.439], [0.515,0.727], [0.605,0.602], [0.132,0.637], [0.476,0.669], [0.660,0.253], 
		[0.580,0.273], [0.796,0.330], [0.656,0.326], [0.000,0.525], [0.633,0.576], [0.380,0.752], [0.074,0.582], [0.438,0.344], 
		[0.496,0.659], [0.064,0.437], [0.433,0.723], [0.617,0.273], [0.228,0.729], [0.293,0.671], [0.330,0.523], [0.578,0.434], 
		[0.144,0.667], [0.107,0.607], [0.370,0.331], [0.300,0.762], [0.958,0.477], [0.420,0.396], [0.111,0.500], [0.492,0.681], 
		[0.895,0.482], [0.447,0.736], [0.523,0.293], [0.569,0.690], [0.400,0.480], [0.539,0.240], [0.215,0.710], [0.292,0.736], 
		[0.162,0.649], [0.519,0.351], [0.869,0.369], [0.175,0.579], [0.312,0.707], [0.650,0.444], [0.214,0.688], [0.539,0.658], 
		[0.388,0.384], [0.398,0.361], [0.444,0.680], [0.283,0.728], [0.469,0.714], [0.621,0.558], [0.581,0.330], [0.759,0.317], 
		[0.604,0.564], [0.611,0.507], [0.635,0.547], [0.362,0.678], [0.390,0.732], [0.420,0.467], [0.082,0.535], [0.617,0.254], 
		[0.080,0.504], [0.425,0.445], [0.491,0.353], [0.842,0.405], [0.387,0.501], [0.137,0.607], [0.310,0.726], [0.622,0.279], 
		[0.699,0.552], [0.721,0.263], [0.756,0.356], [0.594,0.264], [0.590,0.599], [0.451,0.389], [0.322,0.540], [0.193,0.734], 
		[0.636,0.479], [0.348,0.401], [0.550,0.308], [0.400,0.470]
    ];
    
    let data = new Dataset(moons_x);
    return data;
}

/**
    Gaussian dataset.
*/
function get_gaussian() {
	let gaussian_x = [
		[0.351,0.334], [0.282,0.315], [0.245,0.379], [0.373,0.209], [0.221,0.304], [0.384,0.295], [0.238,0.253], [0.246,0.111],
		[0.103,0.187], [0.250,0.363], [0.234,0.119], [0.349,0.257], [0.352,0.175], [0.284,0.280], [0.282,0.305], [0.437,0.209],
		[0.286,0.188], [0.216,0.258], [0.308,0.248], [0.331,0.278], [0.324,0.240], [0.111,0.214], [0.222,0.296], [0.316,0.238],
		[0.321,0.398], [0.276,0.332], [0.107,0.369], [0.386,0.350], [0.295,0.313], [0.402,0.265], [0.322,0.293], [0.313,0.329],
		[0.438,0.327], [0.305,0.104], [0.332,0.245], [0.252,0.211], [0.208,0.474], [0.295,0.330], [0.075,0.268], [0.088,0.389],
		[0.290,0.358], [0.295,0.341], [0.296,0.371], [0.259,0.155], [0.370,0.158], [0.268,0.155], [0.220,0.097], [0.417,0.334],
		[0.221,0.203], [0.233,0.124], [0.284,0.168], [0.154,0.316], [0.261,0.313], [0.309,0.270], [0.295,0.196], [0.354,0.334],
		[0.215,0.344], [0.331,0.057], [0.327,0.232], [0.272,0.313], [0.161,0.239], [0.411,0.407], [0.271,0.187], [0.225,0.246],
		[0.232,0.344], [0.281,0.262], [0.279,0.302], [0.248,0.167], [0.266,0.338], [0.222,0.192], [0.404,0.318], [0.410,0.274],
		[0.155,0.292], [0.263,0.293], [0.334,0.295], [0.352,0.307], [0.165,0.386], [0.196,0.316], [0.238,0.147], [0.225,0.291],
		[0.235,0.307], [0.255,0.339], [0.244,0.170], [0.202,0.188], [0.217,0.273], [0.306,0.383], [0.203,0.356], [0.285,0.337],
		[0.305,0.324], [0.220,0.280], [0.318,0.116], [0.257,0.389], [0.178,0.337], [0.232,0.194], [0.196,0.376], [0.234,0.400],
		[0.194,0.211], [0.195,0.097], [0.310,0.194], [0.129,0.170], [0.338,0.266], [0.228,0.265], [0.169,0.267], [0.289,0.289],
		[0.291,0.261], [0.365,0.341], [0.324,0.241], [0.288,0.179], [0.193,0.156], [0.419,0.371], [0.361,0.261], [0.305,0.322],
		[0.223,0.260], [0.355,0.387], [0.245,0.319], [0.291,0.336], [0.318,0.317], [0.336,0.383], [0.289,0.178], [0.190,0.405],
		[0.318,0.234], [0.320,0.268], [0.097,0.154], [0.344,0.233], [0.296,0.329], [0.708,0.766], [0.495,0.616], [0.662,0.731],
		[0.626,0.587], [0.718,0.621], [0.678,0.698], [0.529,0.707], [0.573,0.707], [0.759,0.639], [0.519,0.548], [0.667,0.550],
		[0.640,0.611], [0.571,0.555], [0.661,0.621], [0.581,0.782], [0.782,0.571], [0.690,0.533], [0.656,0.657], [0.681,0.685],
		[0.732,0.627], [0.717,0.621], [0.528,0.643], [0.617,0.682], [0.720,0.762], [0.682,0.614], [0.635,0.715], [0.641,0.594],
		[0.779,0.754], [0.693,0.556], [0.733,0.526], [0.692,0.634], [0.713,0.598], [0.633,0.768], [0.696,0.720], [0.591,0.752],
		[0.616,0.473], [0.791,0.643], [0.675,0.683], [0.596,0.779], [0.745,0.537], [0.659,0.552], [0.551,0.635], [0.587,0.738],
		[0.700,0.725], [0.713,0.678], [0.659,0.747], [0.605,0.523], [0.625,0.820], [0.572,0.585], [0.554,0.709], [0.643,0.671],
		[0.640,0.715], [0.724,0.727], [0.688,0.741], [0.572,0.642], [0.582,0.588], [0.669,0.701], [0.740,0.685], [0.682,0.705],
		[0.636,0.808], [0.723,0.794], [0.591,0.504], [0.744,0.696], [0.682,0.751], [0.612,0.678], [0.682,0.575], [0.655,0.657],
		[0.528,0.698], [0.689,0.680], [0.598,0.572], [0.492,0.747], [0.668,0.568], [0.614,0.628], [0.553,0.639], [0.755,0.777],
		[0.609,0.658], [0.663,0.599], [0.742,0.684], [0.662,0.744], [0.573,0.696], [0.762,0.591], [0.676,0.683], [0.505,0.735],
		[0.697,0.693], [0.594,0.689], [0.552,0.751], [0.650,0.799], [0.652,0.606], [0.615,0.738], [0.812,0.731], [0.682,0.513],
		[0.725,0.608], [0.602,0.627], [0.757,0.681], [0.759,0.681], [0.650,0.726], [0.613,0.599], [0.654,0.544], [0.772,0.671],
		[0.582,0.763], [0.657,0.431], [0.670,0.653], [0.617,0.523], [0.491,0.701], [0.709,0.685], [0.614,0.620], [0.709,0.659],
		[0.730,0.643], [0.699,0.412], [0.592,0.813], [0.588,0.589], [0.626,0.628], [0.786,0.731], [0.540,0.611], [0.611,0.643],
		[0.628,0.647], [0.584,0.429], [0.713,0.606], [0.707,0.447], [0.719,0.587], [0.675,0.606], [0.857,0.683], [0.719,0.805],
		[0.656,0.623], [0.622,0.685], [0.080,0.590], [0.163,0.596], [0.202,0.620], [0.182,0.794], [0.363,0.430], [0.303,0.739],
		[0.246,0.727], [0.311,0.741], [0.237,0.552], [0.407,0.621], [0.179,0.724], [0.180,0.568], [0.224,0.574], [0.063,0.689],
		[0.265,0.649], [0.312,0.761], [0.284,0.881], [0.387,0.677], [0.303,0.638], [0.221,0.675], [0.216,0.623], [0.281,0.703],
		[0.236,0.630], [0.380,0.620], [0.264,0.496], [0.358,0.657], [0.100,0.584], [0.282,0.654], [0.125,0.665], [0.270,0.629],
		[0.243,0.770], [0.306,0.722], [0.310,0.768], [0.208,0.727], [0.343,0.448], [0.287,0.608], [0.271,0.575], [0.186,0.637],
		[0.464,0.625], [0.222,0.736], [0.277,0.590], [0.424,0.788], [0.233,0.537], [0.413,0.550], [0.285,0.675], [0.231,0.625],
		[0.332,0.519], [0.234,0.756], [0.445,0.698], [0.314,0.680], [0.231,0.714], [0.110,0.382], [0.374,0.548], [0.328,0.609],
		[0.359,0.536], [0.113,0.648], [0.338,0.718], [0.298,0.504], [0.272,0.467], [0.172,0.740], [0.188,0.656], [0.413,0.817],
		[0.169,0.640], [0.218,0.642], [0.118,0.663], [0.246,0.716], [0.318,0.518], [0.418,0.579], [0.298,0.603], [0.408,0.681],
		[0.452,0.574], [0.210,0.709], [0.309,0.625], [0.276,0.741], [0.184,0.618], [0.334,0.776], [0.307,0.683], [0.416,0.647],
		[0.228,0.601], [0.196,0.728], [0.234,0.586], [0.357,0.649], [0.357,0.733], [0.237,0.654], [0.139,0.806], [0.123,0.578],
		[0.287,0.608], [0.205,0.525], [0.272,0.623], [0.493,0.616], [0.001,0.746], [0.151,0.816], [0.283,0.641], [0.080,0.679],
		[0.333,0.566], [0.302,0.568], [0.232,0.510], [0.289,0.465], [0.068,0.392], [0.294,0.753], [0.311,0.604], [0.171,0.450],
		[0.246,0.522], [0.272,0.409], [0.147,0.680], [0.240,0.709], [0.291,0.744], [0.367,0.849], [0.097,0.707], [0.407,0.626],
		[0.307,0.614], [0.337,0.958], [0.411,0.439], [0.395,0.655], [0.182,0.776], [0.315,0.712], [0.035,0.654], [0.139,0.660],
		[0.148,0.639], [0.355,0.472], [0.295,0.676], [0.224,0.684], [0.057,0.381], [0.150,0.567], [0.266,0.616], [0.591,0.243],
		[0.714,0.310], [0.735,0.106], [0.562,0.270], [0.614,0.385], [0.574,0.236], [0.619,0.330], [0.640,0.360], [0.628,0.287],
		[0.605,0.271], [0.690,0.206], [0.528,0.306], [0.583,0.163], [0.680,0.264], [0.467,0.250], [0.596,0.335], [0.609,0.190],
		[0.672,0.371], [0.669,0.277], [0.779,0.256], [0.669,0.398], [0.563,0.331], [0.547,0.265], [0.564,0.213], [0.627,0.302],
		[0.602,0.251], [0.512,0.190], [0.410,0.188], [0.619,0.294], [0.574,0.274], [0.614,0.305], [0.546,0.313], [0.639,0.189],
		[0.730,0.320], [0.633,0.300], [0.740,0.353], [0.972,0.274], [0.712,0.398], [0.604,0.250], [0.792,0.166], [0.627,0.276],
		[0.818,0.278], [0.624,0.297], [0.483,0.335], [0.537,0.253], [0.602,0.226], [0.763,0.251], [0.549,0.334], [0.790,0.237],
		[0.771,0.301], [0.678,0.203], [0.628,0.171], [0.615,0.208], [0.535,0.145], [0.730,0.262], [0.442,0.180], [0.605,0.218],
		[0.558,0.367], [0.800,0.220], [0.702,0.305], [0.675,0.162], [0.443,0.226], [0.659,0.311], [0.715,0.392], [0.556,0.107],
		[0.580,0.177], [0.635,0.272], [0.709,0.342], [0.640,0.237], [0.522,0.366], [0.416,0.284], [0.710,0.317], [0.598,0.166],
		[0.656,0.088], [0.641,0.204], [0.627,0.226], [0.627,0.139], [0.705,0.248], [0.709,0.290], [0.565,0.382], [0.485,0.410],
		[0.793,0.366], [0.680,0.371], [0.544,0.205], [0.711,0.306], [0.691,0.233], [0.693,0.283], [0.726,0.295], [0.915,0.283],
		[0.594,0.174], [0.641,0.179], [0.656,0.250], [0.706,0.365], [0.815,0.273], [0.648,0.311], [0.608,0.352], [0.760,0.314],
		[0.799,0.322], [0.640,0.235], [0.643,0.165], [0.581,0.353], [0.790,0.234], [0.656,0.406], [0.627,0.361], [0.730,0.364],
		[0.547,0.364], [0.519,0.358], [0.614,0.143], [0.493,0.135], [0.457,0.188], [0.768,0.354], [0.692,0.243], [0.677,0.164],
		[0.734,0.323], [0.819,0.288], [0.792,0.251], [0.670,0.284], [0.591,0.243], [0.769,0.191], [0.597,0.186], [0.704,0.301],
		[0.484,0.111], [0.618,0.156], [0.714,0.281], [0.695,0.351]
	];
	
	let data = new Dataset(gaussian_x);
    return data;
}

/**
    Blobs dataset.
*/
function get_blobs() {
    let blobs_x = [
		[0.359,0.691], [0.567,0.500], [0.917,0.286], [0.649,0.455], [0.577,0.581], [0.180,0.643], [0.885,0.413], [0.851,0.368], 
		[0.140,0.688], [0.598,0.434], [0.668,0.445], [0.090,0.645], [0.149,0.725], [0.512,0.709], [0.390,0.286], [0.826,0.331], 
		[0.411,0.283], [0.625,0.402], [0.545,0.694], [0.513,0.600], [0.047,0.739], [0.644,0.431], [0.827,0.333], [0.105,0.671], 
		[0.629,0.403], [0.103,0.727], [0.607,0.378], [0.864,0.425], [0.065,0.688], [0.171,0.754], [0.633,0.441], [0.471,0.641], 
		[0.598,0.326], [0.924,0.340], [0.121,0.697], [0.441,0.188], [0.107,0.656], [0.844,0.392], [0.517,0.688], [0.625,0.449], 
		[0.877,0.364], [0.587,0.376], [0.672,0.419], [0.620,0.405], [0.135,0.682], [0.880,0.378], [0.585,0.386], [0.605,0.438], 
		[0.136,0.762], [0.930,0.342], [0.961,0.406], [0.090,0.739], [0.884,0.379], [0.376,0.333], [0.115,0.682], [0.683,0.482], 
		[0.075,0.674], [0.655,0.420], [0.417,0.585], [0.121,0.719], [0.422,0.339], [0.623,0.480], [0.873,0.416], [0.467,0.232], 
		[0.640,0.400], [0.085,0.715], [0.546,0.441], [0.103,0.684], [0.838,0.469], [0.867,0.335], [0.154,0.649], [0.116,0.685], 
		[0.378,0.307], [0.456,0.283], [0.111,0.674], [0.119,0.718], [0.391,0.201], [0.469,0.639], [0.628,0.416], [0.074,0.718], 
		[0.808,0.404], [0.682,0.430], [0.166,0.765], [0.805,0.413], [0.644,0.343], [0.415,0.294], [0.490,0.622], [0.618,0.400], 
		[0.423,0.237], [0.485,0.639], [0.628,0.449], [0.077,0.655], [0.464,0.674], [0.411,0.281], [0.873,0.365], [0.604,0.420], 
		[0.458,0.632], [0.625,0.388], [0.449,0.260], [0.491,0.739], [0.714,0.429], [0.371,0.309], [0.615,0.451], [0.088,0.720], 
		[0.110,0.760], [0.440,0.236], [0.096,0.721], [0.480,0.221], [0.410,0.257], [0.638,0.354], [0.148,0.722], [0.009,0.734], 
		[0.392,0.171], [0.535,0.574], [0.055,0.745], [0.910,0.332], [0.427,0.310], [0.459,0.670], [0.136,0.662], [0.148,0.665], 
		[0.498,0.269], [0.875,0.433], [0.470,0.621], [0.875,0.393], [0.653,0.434], [0.413,0.260], [0.680,0.379], [0.586,0.605], 
		[0.902,0.334], [0.397,0.649], [0.503,0.605], [0.719,0.424], [0.780,0.336], [0.834,0.371], [0.530,0.557], [0.387,0.250], 
		[0.074,0.622], [0.912,0.397], [0.395,0.255], [0.897,0.396], [0.975,0.372], [0.809,0.429], [0.595,0.425], [0.801,0.327], 
		[0.616,0.428], [0.533,0.615], [0.068,0.724], [0.116,0.729], [0.458,0.288], [0.717,0.423], [0.603,0.598], [0.124,0.659], 
		[0.131,0.695], [0.930,0.389], [0.506,0.635], [0.096,0.708], [0.553,0.604], [0.470,0.585], [0.087,0.754], [0.429,0.596], 
		[0.852,0.449], [0.109,0.665], [0.617,0.355], [0.625,0.373], [0.479,0.576], [0.911,0.419], [0.582,0.432], [0.618,0.406], 
		[0.863,0.381], [0.882,0.423], [0.590,0.572], [0.896,0.440], [0.435,0.251], [0.379,0.279], [0.149,0.619], [0.554,0.656], 
		[0.319,0.230], [0.067,0.667], [0.480,0.633], [0.147,0.687], [0.868,0.427], [0.396,0.284], [0.135,0.623], [0.610,0.517], 
		[0.128,0.741], [0.435,0.704], [0.623,0.464], [0.464,0.251], [0.904,0.390], [0.892,0.375], [0.332,0.295], [0.640,0.436], 
		[0.459,0.606], [0.579,0.454], [0.623,0.471], [0.933,0.414], [0.425,0.166], [0.450,0.690], [0.396,0.277], [0.109,0.685], 
		[0.607,0.385], [0.627,0.354], [0.862,0.398], [0.101,0.789], [0.587,0.643], [0.688,0.375], [0.124,0.644], [0.367,0.209], 
		[0.647,0.380], [0.433,0.352], [0.393,0.289], [0.487,0.497], [0.403,0.242], [0.517,0.626], [0.928,0.434], [0.075,0.649], 
		[0.112,0.735], [0.101,0.642], [0.419,0.328], [0.503,0.219], [0.602,0.468], [0.528,0.681], [0.041,0.756], [0.477,0.661], 
		[0.934,0.365], [0.361,0.239], [0.089,0.663], [0.113,0.691], [0.488,0.664], [0.048,0.700], [0.123,0.695], [0.139,0.689], 
		[0.637,0.356], [0.884,0.416], [0.613,0.536], [0.834,0.416], [0.796,0.348], [0.687,0.464], [0.871,0.407], [0.615,0.413], 
		[0.663,0.409], [0.379,0.218], [0.482,0.650], [0.073,0.668], [0.539,0.642], [0.912,0.400], [0.167,0.763], [0.630,0.400], 
		[0.501,0.629], [0.418,0.643], [0.158,0.702], [0.394,0.287], [0.930,0.447], [0.129,0.649], [0.418,0.300], [0.855,0.421], 
		[0.616,0.411], [0.819,0.372], [0.648,0.519], [0.087,0.727], [0.913,0.472], [0.402,0.210], [1.004,0.435], [0.437,0.673], 
		[0.389,0.310], [0.369,0.245], [0.946,0.337], [0.915,0.414], [0.610,0.454], [0.503,0.621], [0.568,0.457], [0.415,0.606], 
		[0.106,0.641], [0.142,0.767], [0.504,0.598], [0.316,0.231], [0.645,0.454], [0.090,0.693], [0.365,0.337], [0.442,0.230], 
		[0.921,0.410], [0.403,0.278], [0.636,0.446], [0.105,0.635], [0.439,0.697], [0.467,0.670], [0.438,0.598], [0.525,0.599], 
		[0.431,0.298], [0.403,0.199], [0.433,0.680], [0.665,0.454], [0.876,0.383], [0.618,0.422], [0.928,0.361], [0.623,0.383], 
		[0.604,0.384], [0.911,0.423], [0.117,0.766], [0.409,0.397], [0.542,0.614], [0.702,0.473], [0.809,0.333], [0.497,0.559], 
		[0.451,0.199], [0.309,0.276], [0.578,0.491], [0.515,0.746], [0.135,0.754], [0.391,0.260], [0.504,0.645], [0.678,0.448], 
		[0.708,0.425], [0.698,0.425], [0.449,0.596], [0.845,0.397], [0.862,0.403], [0.854,0.348], [0.474,0.607], [0.435,0.513], 
		[0.641,0.377], [0.366,0.298], [0.134,0.689], [0.642,0.453], [0.368,0.292], [0.097,0.741], [0.398,0.697], [0.499,0.616], 
		[0.407,0.195], [0.116,0.746], [0.450,0.655], [0.112,0.717], [0.410,0.307], [0.392,0.575], [0.443,0.603], [0.053,0.723], 
		[0.429,0.227], [0.476,0.656], [0.431,0.545], [0.390,0.265], [0.566,0.727], [0.447,0.240], [0.065,0.700], [0.114,0.747], 
		[0.431,0.690], [0.201,0.687], [0.966,0.302], [0.111,0.721], [0.396,0.298], [0.176,0.636], [0.509,0.462], [0.499,0.624], 
		[0.439,0.286], [0.477,0.651], [0.520,0.566], [0.848,0.378], [0.484,0.150], [0.375,0.348], [0.160,0.720], [0.433,0.291], 
		[0.399,0.269], [0.121,0.656], [0.381,0.223], [0.063,0.672], [0.618,0.409], [0.115,0.626], [0.588,0.489], [0.898,0.378], 
		[0.634,0.416], [0.905,0.316], [0.157,0.706], [0.431,0.225], [0.928,0.410], [0.069,0.794], [0.571,0.616], [0.544,0.369], 
		[0.794,0.368], [0.855,0.385], [0.893,0.396], [0.765,0.431], [0.440,0.702], [0.592,0.394], [0.456,0.568], [0.490,0.624], 
		[0.912,0.429], [0.854,0.430], [0.391,0.288], [0.431,0.325], [0.506,0.612], [0.859,0.422], [0.812,0.377], [0.419,0.273], 
		[0.939,0.487], [0.530,0.653], [0.152,0.717], [0.648,0.478], [0.528,0.578], [0.150,0.724], [0.930,0.421], [0.862,0.336], 
		[0.898,0.405], [0.397,0.336], [0.863,0.367], [0.391,0.268], [0.692,0.417], [0.842,0.319], [0.422,0.261], [0.861,0.371], 
		[0.673,0.476], [0.021,0.747], [0.587,0.422], [0.937,0.375], [0.485,0.582], [0.903,0.416], [0.640,0.414], [0.627,0.434], 
		[0.153,0.712], [0.106,0.761], [0.951,0.413], [0.846,0.456], [0.107,0.719], [0.345,0.307], [0.869,0.307], [0.583,0.400], 
		[0.486,0.418], [0.916,0.369], [0.441,0.330], [0.083,0.719], [0.611,0.501], [0.955,0.356], [0.411,0.288], [0.931,0.404], 
		[0.662,0.428], [0.473,0.677], [0.383,0.195], [0.585,0.659], [0.067,0.689], [0.880,0.359], [0.323,0.244], [0.074,0.706], 
		[0.348,0.355], [0.859,0.414], [0.680,0.457], [0.641,0.430], [0.890,0.292], [0.118,0.746], [0.718,0.414], [0.604,0.438], 
		[0.924,0.452], [0.501,0.626], [0.632,0.365], [0.649,0.468], [0.484,0.642], [0.659,0.340], [0.855,0.453], [0.133,0.646], 
		[0.515,0.626], [0.221,0.673], [0.116,0.677], [0.077,0.736], [0.611,0.443], [0.102,0.748], [0.920,0.347], [0.899,0.403], 
		[0.636,0.401], [0.913,0.396], [0.894,0.300], [0.597,0.438], [0.155,0.725], [0.665,0.424], [0.894,0.346], [0.427,0.281], 
		[0.082,0.766], [0.402,0.281], [0.897,0.339], [0.492,0.587], [0.614,0.422], [0.407,0.355], [0.960,0.412], [0.516,0.686], 
		[0.626,0.383], [0.511,0.675], [0.903,0.364], [0.458,0.622], [0.593,0.463], [0.569,0.680], [0.524,0.638], [0.458,0.573], 
		[0.631,0.420], [0.599,0.418], [0.492,0.682], [0.603,0.463], [0.166,0.649], [0.478,0.213], [0.654,0.448], [0.393,0.270], 
		[0.105,0.718], [0.486,0.196], [0.881,0.368], [0.926,0.286], [0.404,0.251], [0.497,0.258], [0.376,0.256], [0.333,0.242], 
		[0.077,0.637], [0.452,0.330], [0.968,0.331], [0.816,0.326], [0.865,0.390], [0.891,0.325], [0.389,0.259], [0.153,0.698], 
		[0.875,0.372], [0.438,0.224], [0.984,0.341], [0.478,0.715], [0.479,0.638], [0.471,0.626], [0.431,0.258], [0.163,0.682], 
		[0.621,0.379], [0.405,0.571], [0.104,0.705], [0.445,0.204], [0.670,0.450], [0.495,0.631], [0.222,0.747], [0.527,0.580], 
		[0.876,0.364], [0.598,0.468], [0.500,0.621], [0.166,0.784], [0.452,0.701], [0.493,0.628], [0.455,0.314], [0.501,0.625], 
		[0.827,0.338], [0.115,0.758], [0.409,0.311], [0.948,0.330], [0.832,0.376], [0.887,0.375], [0.478,0.657], [0.399,0.254], 
		[0.081,0.648], [0.482,0.613], [0.411,0.644], [0.674,0.397], [0.497,0.629], [0.475,0.604], [0.415,0.268], [0.437,0.260], 
		[0.601,0.401], [0.388,0.291], [0.159,0.741], [0.123,0.678], [0.500,0.641], [0.429,0.275], [0.898,0.360], [0.123,0.550], 
		[0.413,0.230], [0.059,0.673], [0.346,0.301], [0.142,0.779], [0.051,0.692], [0.167,0.730], [0.540,0.671], [0.648,0.484], 
		[0.415,0.235], [0.488,0.603], [0.588,0.367], [0.431,0.179], [0.401,0.291], [0.396,0.257], [0.498,0.664], [0.110,0.702], 
		[0.883,0.354], [0.551,0.394], [0.486,0.640], [0.144,0.663], [0.930,0.347], [0.095,0.676], [0.400,0.233], [0.125,0.734], 
		[0.449,0.679], [0.543,0.414], [0.595,0.515], [0.651,0.388], [0.437,0.572], [0.895,0.444], [0.940,0.340], [0.633,0.360], 
		[0.147,0.706], [0.481,0.537], [0.678,0.378], [0.375,0.181], [0.450,0.644], [0.323,0.291], [0.111,0.749], [0.186,0.635], 
		[0.867,0.405], [0.491,0.663], [0.454,0.270], [0.873,0.395], [0.898,0.367], [0.522,0.751], [0.470,0.600], [0.884,0.370], 
		[0.439,0.719], [0.422,0.669], [0.604,0.419], [0.523,0.693], [0.411,0.281], [0.630,0.408], [0.110,0.701], [0.127,0.697], 
		[0.440,0.618], [0.870,0.370], [0.430,0.225], [0.430,0.226], [0.391,0.240], [0.458,0.616], [0.406,0.250], [0.161,0.672], 
		[0.590,0.667], [0.662,0.423], [0.442,0.659], [0.505,0.606], [0.650,0.417], [0.915,0.339], [0.162,0.695], [0.440,0.325], 
		[0.572,0.599], [0.499,0.580], [0.135,0.613], [0.910,0.403], [0.070,0.705], [0.406,0.713], [0.874,0.401], [0.514,0.633], 
		[0.418,0.335], [0.077,0.709], [0.623,0.397], [0.509,0.659], [0.675,0.424], [0.440,0.284], [0.384,0.231], [0.396,0.223], 
		[0.408,0.275], [0.583,0.363], [0.966,0.313], [0.900,0.356], [0.601,0.467], [0.370,0.233], [0.898,0.368], [0.901,0.364], 
		[0.178,0.762], [0.226,0.722], [0.347,0.255], [0.463,0.639], [0.221,0.734], [0.405,0.291], [0.149,0.717], [0.373,0.281], 
		[0.900,0.331], [0.431,0.274], [0.640,0.384], [0.465,0.569], [0.517,0.594], [0.361,0.306], [0.398,0.325], [0.846,0.281], 
		[0.591,0.369], [0.430,0.308], [0.084,0.706], [0.101,0.612], [0.397,0.286], [0.548,0.580], [0.640,0.477], [0.467,0.569], 
		[0.093,0.723], [0.589,0.376], [0.501,0.254], [0.503,0.611], [0.876,0.360], [0.949,0.368], [0.388,0.311], [0.689,0.421], 
		[0.556,0.431], [0.435,0.205], [0.095,0.684], [0.603,0.486], [0.135,0.756], [0.837,0.352], [0.381,0.287], [0.744,0.352], 
		[0.398,0.210], [0.895,0.401], [0.550,0.618], [0.133,0.693], [0.629,0.402], [0.636,0.463], [0.840,0.428], [0.532,0.642], 
		[0.573,0.386], [0.948,0.381], [0.488,0.678], [0.386,0.240], [0.638,0.452], [0.559,0.645], [0.521,0.674], [0.639,0.418], 
		[0.870,0.398], [0.361,0.288], [0.453,0.216], [0.133,0.752], [0.130,0.695], [0.150,0.632], [0.132,0.722], [0.517,0.687], 
		[0.601,0.642], [0.445,0.676], [0.405,0.307], [0.904,0.370], [0.918,0.416], [0.846,0.330], [0.636,0.463], [0.863,0.360], 
		[0.399,0.280], [0.454,0.572], [0.646,0.454], [0.704,0.390], [0.930,0.316], [0.322,0.312], [0.587,0.351], [0.068,0.703], 
		[0.922,0.414], [0.864,0.366], [0.517,0.709], [0.614,0.448], [0.370,0.233], [0.395,0.239], [0.463,0.601], [0.372,0.359], 
		[0.625,0.497], [0.164,0.716], [0.877,0.327], [0.450,0.302], [0.465,0.715], [0.460,0.268], [0.418,0.238], [0.112,0.687], 
		[0.594,0.450], [0.096,0.682], [0.482,0.689], [0.514,0.560], [0.924,0.371], [0.555,0.526], [1.009,0.406], [0.658,0.427], 
		[0.393,0.195], [0.090,0.792], [0.081,0.668], [0.864,0.356], [0.779,0.357], [0.567,0.535], [0.502,0.636], [0.631,0.368], 
		[0.520,0.596], [0.522,0.552], [0.448,0.211], [0.430,0.275], [0.870,0.357], [0.934,0.348], [0.697,0.474], [0.151,0.652], 
		[0.186,0.735], [0.592,0.438], [0.134,0.614], [0.501,0.598], [0.499,0.648], [0.876,0.310], [0.866,0.321], [0.905,0.398], 
		[0.383,0.351], [0.330,0.208], [0.090,0.732], [0.456,0.333], [0.419,0.264], [0.109,0.658], [0.696,0.401], [0.674,0.436], 
		[0.406,0.273], [0.429,0.165], [0.670,0.506], [0.106,0.701], [0.650,0.406], [0.659,0.349], [0.835,0.374], [0.601,0.604]
    ];
    
    let data = new Dataset(blobs_x);
    return data;
}

/**
    Returns the dataset with the specified name.
*/
function get_dataset(name) {
    if (name == "spiral") {
        return get_spiral();
    }
    else if (name == "flame") {
        return get_flame();
    }
    else if (name == "moons") {
        return get_moons();
    }
    else if (name == "gaussian") {
        return get_gaussian();
    }
    else if (name == "blobs") {
        return get_blobs();
    }
    else if (name == "circle") {
        return get_circle();
    }
    else {
        throw("Unknown dataset: " + name);
    }
}

/**
    Returns the render options for the specified dataset.
*/
function get_render_options(name) {
    if (name == "spiral") {
        return [2.2, 2.2, -1.1, -1.1];
    }
    else if (name == "flame") {
        return [1.1, 1.1, -0.05, -0.05];
    }
    else if (name == "moons") {
        return [1.1, 1.1, -0.05, -0.05];
    }
    else if (name == "circle") {
        return [1.1, 1.1, -0.05, -0.05];
    }
    else if (name == "gaussian") {
        return [1.1, 1.1, -0.05, -0.05];
    }
    else if (name == "blobs") {
        return [1.1, 1.1, -0.05, -0.05];
    }
    else {
        throw("Unknown dataset: " + name);
    }
}

/**
	Returns the size of rendered markers.
*/
function get_marker_size(type) {
	if (type == "kmeans") {
		return 9;
	}
	else if (type == "dbscan") {
		return 5;
	}
	else if (type == "meanshift") {
		return 5;
	}
	return 5;
}

/**
	Returns the default hyperparameter settings for classifier and datasets combinations.
*/
function get_settings(type, name) {
    if (type == "kmeans") {
    	if (name == "spiral") {
	        return [3, 42];
	    }
	    else if (name == "flame") {
	        return [2, 42];
	    }
	    else if (name == "moons") {
	        return [2, 42];
	    }
	    else if (name == "circle") {
	        return [2, 42];
	    }
	    else if (name == "gaussian") {
	        return [4, 42];
	    }
	    else if (name == "blobs") {
	        return [5, 3];
	    }
	    else {
        	return [3, 42];
        }
    }
    else if (type == "dbscan") {
    	if (name == "spiral") {
	        return [0.12, 6];
	    }
	    else if (name == "flame") {
	        return [0.06, 10];
	    }
	    else if (name == "moons") {
	        return [0.05, 6];
	    }
	    else if (name == "gaussian") {
	        return [0.06, 7];
	    }
	    else if (name == "blobs") {
	        return [0.04, 6];
	    }
    	return [0.05, 6];
    }
    else if (type == "meanshift") {
    	if (name == "spiral") {
	        return [0.4];
	    }
	    else if (name == "gaussian") {
	        return [0.2];
	    }
    	return [0.1];
    }
}

/** ------------------------------------------------------

Utility functions and classes for classifiers.

--------------------------------------------------------- */

/**
    Holds a loaded and converted dataset.
*/
class Dataset {
    // Constructor
    constructor(x) {
        this.x = x;
    }

    // Returns a copy of this dataset
    clone() {
    	let nx = [];

    	// Copy all instances
    	for (let i = 0; i < this.no_examples(); i++) {
    		// Copy attributes of current instance
    		let e = this.x[i];
    		let new_e = [];
    		for (let a = 0; a < e.length; a++) {
    			new_e.push(e[a]);
    		}

    		// Add to new data arrays
    		nx.push(new_e);
    	}

    	// Create new dataset
    	let new_data = new Dataset(nx);
        return new_data;
    }

    // Returns thenumber of examples (size) of this dataset.
    no_examples() {
        return this.x.length;
    }

    // Returns the number of attributes in this dataset.
    no_attr() {
        return this.x[0].length;
    }

    // Feature-wise normalization where we subtract the mean and divide with stdev
    normalize() {
        for (let c = 0; c < this.no_attr(); c++) {
            let m = this.attr_mean(c); // mean
            let std = this.attr_stdev(c, m); // stdev
            for (let i = 0; i < this.no_examples(); i++) {
                this.x[i][c] = (this.x[i][c] - m) / std;
            }
        }
    }

    // Randomly shuffles the dataset examples
    shuffle() {
        // Create new arrays
        let nx = [];
        // Holds which instances that have been copied or not
        let done = new Array(this.x.length).fill(0);
        
        // Continue until all ínstances have been copied
        while (nx.length < this.x.length) {
            // Find a random instance that has not been copied
            let i = -1;
            while (i == -1) {
                let ti = Math.floor(rnd() * this.x.length);
                if (done[ti] == 0) {
                    // Not copied. Use this index.
                    done[ti] = 1;
                    i = ti;
                }
                else {
                    // Already copied. Get new index.
                    i = -1;
                }
            }
            
            // Get values
            let xv = this.x[i];
            
            // Copy to new arrays
            nx.push(xv);
        }

        this.x = nx;
    }

    // Calculates the mean value of an attribute
    attr_mean(c) {
        let m = 0;
        for (let i = 0; i < this.no_examples(); i++) {
            m += this.x[i][c];
        }
        m /= this.no_examples();
        return m;
    }

    // Calculates the min value of an attribute
    attr_min(c) {
        let m = 100000;
        for (let i = 0; i < this.no_examples(); i++) {
        	if (this.x[i][c] < m) {
        		m = this.x[i][c];
        	}
        }
        return m;
    }

    // Calculates the max value of an attribute
    attr_max(c) {
        let m = -100000;
        for (let i = 0; i < this.no_examples(); i++) {
        	if (this.x[i][c] > m) {
        		m = this.x[i][c];
        	}
        }
        return m;
    }

    // Calculates the standard deviation of an attribute
    attr_stdev(c, m) {
        let std = 0;
        for (let i = 0; i < this.no_examples(); i++) {
            std += Math.pow(this.x[i][c]  - m, 2);
        }
        std = Math.sqrt(std / (this.no_examples() - 1));
        return std;
    }
}

/** ------------------------------------------------------

Implementation of K-Means clustering algorithm.

--------------------------------------------------------- */

class KMeans {
    constructor(k, distf, initf, seed) {
        this.k = k;
        this.data = [];
        this.centroids = [];
        global_seed = seed;
        
        // Distance function
        if (distf == "0") {
            this.dist_func = this.dist_euclidean;
        }
        else if(distf == "1") {
            this.dist_func = this.dist_manhattan;
        }
        else if(distf == "2") {
            this.dist_func = this.dist_chebyshev;
        }
        else {
            throw("Unknown distance function: " + distf);
        }

        // Initalizer function
        if (initf == "0") {
            this.init_func = this.random_init;
        }
        else if(initf == "1") {
            this.init_func = this.kmplusplus_init;
        }
        else {
            throw("Unknown initalizer function: " + initf);
        }

        // Current training iteration
        this.current_iter = 0;
        this.max_iter = 100;
        // Training done
        this.training_done = false;
    }

    // Returns number of clusters
    no_clusters() {
        return this.k;
    }
    
    // Sets if this algorithm has iterable training phase
    iterable() {
        return true;
    }
  
    // Random centroids initialization
    random_init(data) {
        for (let i = 0; i < this.k; i++) {
            let c = new KMCentroid(i + 1);
            c.set_random(data);
            this.centroids.push(c);
        }
    }

    // Calculates min squared distance between this instance and current centroids
    min_sqdist_centroids(inst) {
        // Iterate over all centroids
        for (let c = 0; c < this.centroids.length; c++) {
            // Calculate squared dist and see if we have a new min
            let sqdist = Math.pow(this.dist_func(inst, this.centroids[c]), 2);
            if (sqdist < inst.dist) {
                inst.centroid = c;
                inst.dist = sqdist;
            }
        }
        return inst.dist;
    }

    // K-Means++ initialization
    // See: http://www.real-statistics.com/multivariate-statistics/cluster-analysis/initializing-clusters-k-means/
    kmplusplus_init(data) {
        // Step 1: select one random instance as centroid
        let i = parseInt(rnd() * data.no_examples());
        let c = new KMCentroid(this.centroids.length + 1);
        c.set(data.x[i]);
        this.centroids.push(c);

        // Step 2: select other random instances as centroids based on how far
        // away they are from current centroids
        while (this.centroids.length < this.k) {
            // Calculate sum of min squared dists to current centroids
            let sum_dist = 0;
            for (let i = 0; i < data.no_examples(); i++) {
                let inst = new KMInstance(data.x[i]);
                sum_dist += this.min_sqdist_centroids(inst);
            }

            // Select a new instance to be centroid with probability
            // D(xi)^2 / Sum (D(xj)^2)
            let selected = false;
            while (!selected) {
                // Find random instance
                let i = parseInt(rnd() * data.no_examples());
                let inst = new KMInstance(data.x[i]);
                // Calculate probability
                let prob = this.min_sqdist_centroids(inst) / sum_dist;
                // If random value is equal or below probability, select this instance as centroid
                if (rnd() <= prob) {
                    let c = new KMCentroid(this.centroids.length + 1);
                    c.set(inst.x);
                    this.centroids.push(c);
                    selected = true;
                }
            }
        }
    }

    // Trains the clustering algorithm
    train(data) {
        this.init_func(data);
        
        // Add data to internal array
        for (let i = 0; i < data.no_examples(); i++) {
            let e = new KMInstance(data.x[i]);
            this.data.push(e);
        }
    }

    // Checks if the training is done or not
    done() {
        return this.training_done;
    }
    
    // Returns the current iteration
    current_iteration() {
        return this.current_iter;
    }
    
    // Executes all training iterations
    iterate_all() {
        while(!this.training_done) {
            this.iterate();
        }
    }
    
    // Executes one training iteration
    iterate() {
        // Flag if assignments have been changed or not
        let changed = false;

        // Assign each instance to the closest centroid
        for (let i = 0; i < this.data.length; i++) {
            let inst = this.data[i];
            inst.reset();

            // Calculate distance to each centroid
            for (let c = 0; c < this.centroids.length; c++) {
                let dist = this.dist_func(inst, this.centroids[c]);
                if (dist < inst.dist) {
                    inst.centroid = c;
                    inst.dist = dist;
                }
            }

            // Check if assignment for this instance has changed
            if (inst.centroid != inst.prev_centroid) {
                changed = true;
            }
        }

        // Move each centroid to mean
        for (let c = 0; c < this.centroids.length; c++) {
            let centroid = this.centroids[c];

            let new_x = new Array(centroid.no_attr()).fill(0);

            let cnt = 0;
            for (let i = 0; i < this.data.length; i++) {
                let inst = this.data[i];
                if (inst.centroid == c) {
                    cnt++;
                    for (let a = 0; a < centroid.no_attr(); a++) {
                        new_x[a] += inst.x[a];
                    }
                }
            }

            for (let a = 0; a < centroid.no_attr(); a++) {
                new_x[a] /= cnt;
            }
            centroid.x = new_x;
        }

        // Stop training if no new assignments were made
        if (!changed || this.current_iter >= this.max_iter) {
            this.training_done = true;    
        }
        this.current_iter++;
    }
    
    // Predicts a list of instances
    predict(instances) {
        let pred = [];
        for (let i = 0; i < instances.length; i++) {
            let inst = instances[i];
            pred.push(this.classify(inst));
        }
        return pred;
    }
    
    // Classifies which cluster an instance belongs to
    classify(i) {
        let inst = new KMInstance(i);
        inst.centroid = 0;
        inst.dist = this.dist_func(inst, this.centroids[0]);

        // Calculate distance to each centroid
        for (let c = 1; c < this.centroids.length; c++) {
            let dist = this.dist_func(inst, this.centroids[c]);
            if (dist < inst.dist) {
                inst.dist = dist;
                inst.centroid = c;
            }
        }
        
        return this.centroids[inst.centroid].label;
    }

    // Returns the markers to be rendered, in this case
    // the centroids
    get_markers() {
        let m = [];
        for (let c = 0; c < this.centroids.length; c++) {
            m.push(this.centroids[c].x);
        }
        return m;
    }
    
    // Calculates distance (Euclidean) between an instance and a centroid
    dist_euclidean(inst, c) {
        let sumSq = 0;
        for (let i = 0; i < c.x.length; i++) {
            sumSq += Math.pow(inst.x[i] - c.x[i], 2);
        }
        sumSq = Math.sqrt(sumSq);
        return sumSq;
    }

    // Calculates Manhattan distance between an instance and a centroid
    dist_manhattan(inst, c) {
        let sum = 0;
        for (let i = 0; i < c.x.length; i++) {
            sum += Math.abs(inst.x[i] - c.x[i]);
        }
        return sum;
    }

    // Calculates Chebyshev distance between an instance and a centroid
    dist_chebyshev(inst, c) {
        let best_v = 0;
        for (let i = 0; i < c.x.length; i++) {
            let v = Math.abs(inst.x[i] - c.x[i]);
            if (v > best_v) {
                best_v = v;
            }
        }
        return best_v;
    }
}

/**
    Holds a dataset instance.
*/
class KMInstance {
    constructor(x) {
        this.x = x;
        this.prev_centroid = -1;
        this.centroid = 0;
        this.dist = 100000;
    }

    // Reset assignment for this instance
    reset() {
        this.prev_centroid = this.centroid;
        this.centroid = 0;
        this.dist = 100000;
    }
}

/**
    Centroid class for K-Means.
*/
class KMCentroid {
    // Constructor
    constructor(label) {
        this.label = label;
    }

    // Set attribute values
    set(x) {
        this.x = x;
    }

    // Random initialization
    set_random(data) {
        // Create empty x array
        this.x = new Array(data.no_attr()).fill(0);;

        // Randomize all attributes between min and max
        for (let c = 0; c < data.no_attr(); c++) {
            let mi = data.attr_min(c);
            let ma = data.attr_max(c);
            let r = ma - mi;
            let rndval = mi + rnd() * r;
            this.x[c] = rndval;
        }
    }

    // Number of attributes
    no_attr() {
        return this.x.length;
    }
}

/**
    Finds optimal number of clusters (k-value) using silhouette scores.
*/
class KOptimizer {
    // Constructor
    constructor(orig_data, distf, initf, seed) {
        this.km = null;
        this.data = null;
        this.orig_data = orig_data;
        this.distf = distf;
        this.initf = initf;
        this.seed = seed;
    }

    // Runs the optimization. 
    // Tests all k-values between the specified start and end k.
    optimize(start_k = 2, end_k = 20) {
        let best_k = -1;
        let best_score = -2; // Range between -1 and +1
        
        for (let k = start_k; k <= end_k; k++) {
            let score = this.calc_silhouette_score(k);
            if (score > best_score) {
                best_score = score;
                best_k = k;
            }
        }

        return best_k;
    }

    // Calculates the silhouette score for a k-value
    calc_silhouette_score(k) {
        // Run K-Means clustering for the specified k
        this.km = new KMeans(k, this.distf, this.initf, this.seed);
        this.km.train(this.orig_data);
        this.km.iterate_all();
        this.data = this.km.data;

        // Calculate mean silhouette coefficient over all instances
        let mean_coef = 0;
        let cnt = 0;
        for (let i = 0; i < this.data.length; i++) {
            let inst = this.data[i];
            
            // Calculate mean intra-cluster distance
            let a = this.mean_cluster_distance(inst, inst.centroid);

            // Calculate mean distance to nearest other cluster
            let b = 100000;
            for (let c = 0; c < this.km.centroids.length; c++) {
                if (c != inst.centroid) {
                    let bi = this.mean_cluster_distance(inst, c);
                    if (bi < b) {
                        b = bi;
                    }
                }
            }

            // Calculate coefficient
            let coef = (b - a) / Math.max(a, b);
            mean_coef += coef;
            cnt++;
        }

        // Mean coefficient over all instances
        mean_coef /= cnt;

        return mean_coef;
    }

    // Calculates the mean distance between the instance and all instances
    // in the specified cluster.
    mean_cluster_distance(inst, cid) {
        let dist = 0;
        let cnt = 0;
        for (let i = 0; i < this.data.length; i++) {
            // Calculate silhouette score for each instance
            let inst2 = this.data[i];
            if (cid == inst2.centroid) {
                //dist += this.dist_euclidean(inst, inst2);
                dist += this.km.dist_func(inst, inst2);
                cnt++;
            }
        }

        return dist / cnt;
    }
}

/** ------------------------------------------------------

Implementation of DBSCAN clustering algorithm.
See: http://ros-developer.com/2017/12/09/density-based-spatial-clustering-dbscan-with-python-code/

--------------------------------------------------------- */

class DBScan {
    constructor(eps, min_pts, distf) {
        this.data = [];
        this.cores = [];
        this.clusters = [];
        this.eps = eps;
        this.min_pts = min_pts;
        global_seed = 42;
        
        // Distance function
        if (distf == "0") {
            this.dist_func = this.dist_euclidean;
        }
        else if(distf == "1") {
            this.dist_func = this.dist_manhattan;
        }
        else if(distf == "2") {
            this.dist_func = this.dist_chebyshev;
        }
        else {
            throw("Unknown distance function: " + distf);
        }
    }

    // Returns number of clusters
    no_clusters() {
        return this.clusters.length;
    }
    
    // Sets if this algorithm has iterable training phase
    iterable() {
        return false;
    }

    // Returns the neighbors within eps distance from the specified instance
    get_neighbors(P) {
        let neighbors = [];

        for (let i = 0; i < this.data.length; i++) {
            let N = this.data[i];
            if (this.dist_func(P, N) <= this.eps) {
                neighbors.push(N);
            }
        }

        return neighbors;
    }

    // Runs the DBSCAN algorithm
    run_dbscan() {
        this.clusters = [];

        for (let i = 0; i < this.data.length; i++) {
            let P = this.data[i];
            if (P.status == DBInstance.UNVISITED) {
                P.status = DBInstance.VISITED;
                let N = this.get_neighbors(P);
                if (N.length < this.min_pts) {
                    P.status = DBInstance.NOISE;
                }
                else {
                    P.is_core = true;
                    let C = new DBCluster(this.clusters.length + 1);
                    this.clusters.push(C);
                    this.expand_cluster(P, N, C);
                }
            }
        }
    }

    // Expands a cluster with new instances
    expand_cluster(P, N, C) {
        C.add(P);
        for (let i = 0; i < N.length; i++) {
            let Pi = N[i];
            if (Pi.status == DBInstance.UNVISITED) {
                Pi.status = DBInstance.VISITED;
                let Ni = this.get_neighbors(Pi);
                if (Ni.length >= this.min_pts) {
                    Pi.is_core = true;
                    this.merge(N, Ni);
                }
            }
            if (!Pi.is_member) {
                C.add(Pi);
            }
        }
    }

    // Merges two arrays of instances
    merge(N, Ni) {
        for (let i = 0; i < Ni.length; i++) {
            N.push(Ni[i]);
        }
    }

    // Trains the clustering algorithm
    train(data) {
        data.shuffle();

         // Add data to internal array
        for (let i = 0; i < data.no_examples(); i++) {
            let e = new DBInstance(data.x[i]);
            this.data.push(e);
        }

        // Find core instances
        this.run_dbscan();
    }

    // Predicts a list of instances
    predict(instances) {
        let pred = [];
        for (let i = 0; i < instances.length; i++) {
            let inst = instances[i];
            pred.push(this.classify(inst));
        }
        return pred;
    }
    
    // Classifies which cluster an instance belongs to
    classify(i) {
        let inst = new DBInstance(i);

        for (let j = 0; j < this.clusters.length; j++) {
            let C = this.clusters[j];
            for (let i = 0; i < C.points.length; i++) {
                let N = C.points[i];
                if (N.is_core) {
                    if (this.dist_func(inst, N) <= this.eps) {
                        return C.label;
                    }
                }
            }
        }

        return 0;
    }

    // Returns the markers to be rendered, nothing in this case
    get_markers() {
        let m = [];

        for (let i = 0; i < this.data.length; i++) {
            let inst = this.data[i];
            if (inst.is_core) {
                m.push(inst.x);
            }
        }
        
        return m;
    }
    
    // Calculates distance (Euclidean) between two instances
    dist_euclidean(inst1, inst2) {
        let sumSq = 0;
        for (let i = 0; i < inst1.no_attr(); i++) {
            sumSq += Math.pow(inst1.x[i] - inst2.x[i], 2);
        }
        sumSq = Math.sqrt(sumSq);
        return sumSq;
    }

    // Calculates Manhattan distance between two instances
    dist_manhattan(inst1, inst2) {
        let sum = 0;
        for (let i = 0; i < inst1.no_attr(); i++) {
            sum += Math.abs(inst1.x[i] - inst2.x[i]);
        }
        return sum;
    }

    // Calculates Chebyshev distance between two instances
    dist_chebyshev(inst1, inst2) {
        let best_v = 0;
        for (let i = 0; i < inst1.no_attr(); i++) {
            let v = Math.abs(inst1.x[i] - inst2.x[i]);
            if (v > best_v) {
                best_v = v;
            }
        }
        return best_v;
    }
}

/**
    Holds a DBSCAN cluster of instances.
*/
class DBCluster {
    constructor(label) {
        this.points = [];
        this.label = label;
    }

    add(P) {
        this.points.push(P);
        P.is_member = true;
    }
}

/**
    Holds a dataset instance.
*/
class DBInstance {
    constructor(x) {
        this.x = x;
        this.status = DBInstance.UNVISITED;
        this.is_member = false;
        this.is_core = false;
    }

    no_attr() {
        return this.x.length;
    }
}

DBInstance.UNVISITED = 0;
DBInstance.VISITED = 1;
DBInstance.NOISE = 2;

/** ------------------------------------------------------

Implementation of Mean-Shift clustering algorithm.
See: https://pythonprogramming.net/mean-shift-from-scratch-python-machine-learning-tutorial/

--------------------------------------------------------- */

class MeanShift {
    constructor(bandwidth, distf, weightf) {
        this.data = [];
        this.centroids = [];
        this.bandwidth = bandwidth;
        this.weightf = weightf;
        global_seed = 42;
        
        // Distance function
        if (distf == "0") {
            this.dist_func = this.dist_euclidean;
        }
        else if(distf == "1") {
            this.dist_func = this.dist_manhattan;
        }
        else if(distf == "2") {
            this.dist_func = this.dist_chebyshev;
        }
        else {
            throw("Unknown distance function: " + distf);
        }

        // Current training iteration
        this.current_iter = 0;
        this.max_iter = 100;
        // Training done
        this.training_done = false;
    }

    // Returns number of clusters
    no_clusters() {
        return this.centroids.length;
    }
    
    // Sets if this algorithm has iterable training phase
    iterable() {
        return true;
    }
  
    // Init all data points as centroids
    init() {
        for (let i = 0; i < this.data.length; i++) {
            let inst = this.data[i];
            let c = new MSCentroid(inst.x);
            this.centroids.push(c);
        }
    }

    // Trains the clustering algorithm
    train(data) {    
        // Add data to internal array
        for (let i = 0; i < data.no_examples(); i++) {
            let e = new MSInstance(data.x[i], i);
            this.data.push(e);
        }

        this.init();
    }

    // Checks if the training is done or not
    done() {
        return this.training_done;
    }
    
    // Returns the current iteration
    current_iteration() {
        return this.current_iter;
    }
    
    // Executes all training iterations
    iterate_all() {
        while(!this.training_done) {
            this.iterate();
        }
    }

    // Default weight (none) for instances during mean shift
    default_weight(distance) {
        return 1;
    }

    // Gaussian kernel (more weight to close instances) for instances during mean shift
    gaussian_kernel_weight(distance) {
        let val = ( 1 / (this.bandwidth * Math.sqrt(2 * Math.PI))) * Math.exp(-0.5 * Math.pow(distance / this.bandwidth, 2));
        return val;
    }

    // Checks if centroid assignment has changed
    updated(old_n, new_n) {
        let o = [];
        let n = [];
        for (let i = 0; i < old_n.length; i++) {
            o.push(old_n.id);
        }
        for (let i = 0; i < new_n.length; i++) {
            n.push(new_n.id);
        }
        o.sort();
        n.sort();

        if (o.length != n.length) {
            return true;
        }
        for (let i = 0; i < o.length; i++) {
            if (o[i] != n[i]) {
                return true;
            }
        }
        return false;
    }

    // Find neighbors within the bandwidth of this centroid
    find_neighbors(ctr) {
        let weight_func = this.gaussian_kernel_weight;

        let neighbors = [];
        let new_x = new Array(ctr.no_attr()).fill(0);
        let den = 0;

        for (let i = 0; i < this.data.length; i++) {
            let inst = this.data[i];
            let dist = this.dist_func(inst, ctr);
            // Instance is within bandwidth distance
            if (dist <= this.bandwidth) {
                neighbors.push(inst);

                let w = 1;
                if (this.weightf == 1) {
                    w = this.gaussian_kernel_weight(dist);
                }

                // Update new x
                for (let a = 0; a < ctr.no_attr(); a++) {
                    new_x[a] += inst.x[a] * w;
                }
                den += w;
            }
        }

        // Check if updated
        let upd = this.updated(neighbors, ctr.neighbors);

        // Set neighbors
        ctr.neighbors = neighbors;

        // Average center point values
        for (let a = 0; a < ctr.no_attr(); a++) {
            new_x[a] /= den;
        }

        // Set new center point
        ctr.x = new_x;

        return upd;
    }

    // Remove duplicates to find unique clusters
    unique() {
        let new_centroids = [];

        // Iterate over all centroids
        for (let i = 0; i < this.centroids.length; i++) {
            let c1 = this.centroids[i];

            // Iterate over the new centroid list without duplicates
            let found = false;
            for (let j = 0; j < new_centroids.length; j++) {
                let c2 = new_centroids[j];
                // Check if distance is below a min distance
                let d = this.dist_func(c1, c2);
                if (d <= 0.2) {
                    // Centroids are close - merge them
                    found = true;
                    c2.merge(c1);
                    break;
                }
            }
            // New centroid - add it
            if (!found) {
                c1.set_assigned();
                new_centroids.push(c1);
            }
        }

        // Set new centroids
        this.centroids = new_centroids;

        // Set label
        for (let i = 0; i < this.centroids.length; i++) {
            this.centroids[i].label = i + 1;
            this.centroids[i].move_to_center();
        }
    }
    
    // Executes one training iteration
    iterate() {
        let old_x = [];
        let new_x = [];
        let updated = false;
        // Calculate neighbors for each centroid
        for (let c = 0; c < this.centroids.length; c++) {
            let ctr = this.centroids[c];
            old_x.push(ctr.x); // Old centroid center
            let upd = this.find_neighbors(ctr);
            if (upd) {
                updated = upd;
            }
            new_x.push(ctr.x); // Updated centroid center
        }
        
        // Stop training if no new assignments were made
        // or if max iterations are reached
        if (!updated || this.current_iter >= this.max_iter) {
            this.training_done = true;
            // Remove duplicate centroids to create
            // nice clusters
            this.unique();
        }
        this.current_iter++;
    }
    
    // Predicts a list of instances
    predict(instances) {
        let pred = [];
        for (let i = 0; i < instances.length; i++) {
            let inst = instances[i];
            pred.push(this.classify(inst));
        }
        return pred;
    }
    
    // Classifies which cluster an instance belongs to
    classify(i) {
        let inst = new MSInstance(i);
        inst.centroid = 0;
        inst.dist = this.dist_func(inst, this.centroids[0]);

        // Calculate distance to each centroid
        for (let c = 1; c < this.centroids.length; c++) {
            let dist = this.dist_func(inst, this.centroids[c]);
            if (dist < inst.dist) {
                inst.dist = dist;
                inst.centroid = c;
            }
        }
        
        return this.centroids[inst.centroid].label;
    }

    // Returns the markers to be rendered, in this case
    // the centroids
    get_markers() {
        let m = [];
        for (let c = 0; c < this.centroids.length; c++) {
            m.push(this.centroids[c].x);
        }
        return m;
    }
    
    // Calculates distance (Euclidean) between an instance and a centroid
    dist_euclidean(inst, c) {
        let sumSq = 0;
        for (let i = 0; i < c.no_attr(); i++) {
            sumSq += Math.pow(inst.x[i] - c.x[i], 2);
        }
        sumSq = Math.sqrt(sumSq);
        return sumSq;
    }

    // Calculates Manhattan distance between an instance and a centroid
    dist_manhattan(inst, c) {
        let sum = 0;
        for (let i = 0; i < c.no_attr(); i++) {
            sum += Math.abs(inst.x[i] - c.x[i]);
        }
        return sum;
    }

    // Calculates Chebyshev distance between an instance and a centroid
    dist_chebyshev(inst, c) {
        let best_v = 0;
        for (let i = 0; i < c.no_attr(); i++) {
            let v = Math.abs(inst.x[i] - c.x[i]);
            if (v > best_v) {
                best_v = v;
            }
        }
        return best_v;
    }
}

/**
    Holds a dataset instance.
*/
class MSInstance {
    constructor(x, id) {
        this.x = x;
        this.id = id;
        this.assigned = false;
    }

    // Sets this instance as assigned to a cluster
    set_assigned() {
        this.assigned = true;
    }
}

/**
    Centroid class for K-Means.
*/
class MSCentroid {
    // Constructor
    constructor(x) {
        this.x = x;
        this.label = -1;
        this.neighbors = [];
    }

    // Number of attributes
    no_attr() {
        return this.x.length;
    }

    // Check assignments for this centroid. Already assigned
    // instances are removed.
    set_assigned() {
        let new_neighbors = [];
        for (let i = 0; i < this.neighbors.length; i++) {
            let inst = this.neighbors[i];
            if (!inst.assigned) {
                inst.set_assigned();
                new_neighbors.push(inst);
            }
        }
        this.neighbors = new_neighbors;
    }

    // Add all neighbors from another cluster to this cluster
    merge(c2) {
        for (let i = 0; i < c2.neighbors.length; i++) {
            let ninst = c2.neighbors[i]; 
            // Instance not assigned - add it
            if (!ninst.assigned) {
                ninst.set_assigned();
                this.neighbors.push(ninst);
            }
        }
    }

    // Move this centroid to the center of all assigned neighbors
    move_to_center() {
        let new_x = new Array(this.no_attr()).fill(0);

        for (let i = 0; i < this.neighbors.length; i++) {
            let inst = this.neighbors[i];
            // Update new x
            for (let a = 0; a < this.no_attr(); a++) {
                new_x[a] += inst.x[a];
            }
        }
        
        // Average center point values
        for (let a = 0; a < this.no_attr(); a++) {
            new_x[a] /= this.neighbors.length;
        }

        // Set new center point
        this.x = new_x;
    }
}

/** ------------------------------------------------------

Functions for rendering dataset and decision boundaries.

--------------------------------------------------------- */

// Init variables
var cellw = 5;
var canvas;
var ctx;

/**
    Clears the drawing canvas.
*/
function clear() {
    document.getElementById("clusters").innerHTML = "&nbsp;";
    document.getElementById("citer").innerHTML = "&nbsp;";
    ctx.clearRect(0, 0, canvas.width, canvas.height);
}

/**
    Inits the drawing canvas.
*/
function init() {
    canvas = document.getElementById('can');
    ctx = canvas.getContext("2d");
}

/**
    Draws the decision boundaries map.
*/
function draw_map(map) {
    for (let i = 0; i < map.length; i++) {
        let x1 = parseInt(i % 100);
        let x2 = parseInt(i / 100);
        drawcell(x1, x2, map[i]);
    }
}

/*
    Draws a filled cell with a different color for each class value.
*/
function drawcell(x, y, val) {
    let x1 = x * cellw;
    let y1 = y * cellw;
    
    // Select color based on class value
    let color = "#FFFFFF";
    if (val == 1) color = "#FFDBC2"; // red
    if (val == 2) color = "#C2DBFF"; // blue
    if (val == 3) color = "#DBFFC2"; // green
    if (val == 4) color = "#FAFC83"; // yellow
    if (val == 5) color = "#F7D4F3"; // pink
    if (val == 6) color = "#CCCCCC"; // gray
    if (val == 7) color = "#C3F4F3"; // cyan
    if (val == 8) color = "#CE6BF2"; // purple

    if (val == 9) color = "#DDB9A0"; // darker red
    if (val == 10) color = "#A0B9DD"; // darker blue
    if (val == 11) color = "#B9DDA0"; // darker green
    if (val == 12) color = "#D8DA61"; // darker yellow
    if (val == 13) color = "#D5B2D1"; // darker pink
    if (val == 14) color = "#AAAAAA"; // darker gray
    if (val == 15) color = "#A1D2D1"; // darker cyan
    if (val == 16) color = "#AC49D0"; // darker purple

    if (val == 17) color = "#BB9780"; // dark red
    if (val == 18) color = "#8097BB"; // dark blue
    if (val == 19) color = "#97BB80"; // dark green
    if (val == 20) color = "#B6B840"; // dark yellow
    if (val == 21) color = "#B390B0"; // dark pink
    if (val == 22) color = "#888888"; // dark gray
    if (val == 23) color = "#80B0B0"; // dark cyan
    if (val == 24) color = "#8A27B0"; // dark purple

    if (val == 25) color = "#666666"; // grey
    if (val == 26) color = "#FF6666"; // red
    if (val == 27) color = "#66FF66"; // green
    if (val == 28) color = "#6666FF"; // blue
    if (val == 29) color = "#444444"; // darker grey
    if (val == 30) color = "#DD4444"; // darker red
    if (val == 31) color = "#44DD44"; // darker green
    if (val == 32) color = "#4444DD"; // darker blue

    if (val > 32) color = "#EEEEEE"; // default color if more clusters than 32
    
    // Draw square
    ctx.beginPath();
    ctx.fillStyle = color;
    ctx.fillRect(x1, y1, cellw, cellw);
    ctx.closePath();
}

/**
    Draws the data points from the dataset.
*/
function draw_labels(data, opt) {
    for (let i = 0; i < data.no_examples(); i++) {
        let xe = data.x[i];
        let x1 = (xe[0] - opt[2]) / opt[0] * 100;
        let x2 = (xe[1] - opt[3]) / opt[1] * 100;
        draw_label(x1, x2);
    }
}

/**
    Draws a single data point from the dataset.
*/
function draw_label(x, y) {
    let x1 = x * cellw;
    let y1 = y * cellw;
    
    // Draw filled circle
    let r = cellw / 2;
    let c = cellw / 2;
    ctx.beginPath();
    ctx.fillStyle = "#000000";
    ctx.arc(x1 + c, y1 + c, r, 0, 2 * Math.PI, false);
    ctx.fill();
    ctx.closePath();
}


/**
    Draws markers, for example clusters in K-Means.
*/
function draw_markers(m, opt, msize) {
    for (let i = 0; i < m.length; i++) {
        let xe = m[i];
        let x1 = (xe[0] - opt[2]) / opt[0] * 100;
        let x2 = (xe[1] - opt[3]) / opt[1] * 100;
        draw_marker(x1, x2, msize);
    }
}

/**
    Draws a single marker.
*/
function draw_marker(x, y, w) {
    let x1 = x * cellw;
    let y1 = y * cellw;
    
    // Draw rectangle border
    let r = w / 2;
    ctx.beginPath();
    ctx.fillStyle = "#801103";
    ctx.rect(x1, y1, w, w);
    ctx.fill();
    ctx.closePath();

    // Draw filled rectangle
    r = w / 2 - 1;
    ctx.beginPath();
    ctx.fillStyle = "#f0351d";
    ctx.rect(x1 + 1, y1 + 1, w - 2, w - 2);
    ctx.fill();
    ctx.closePath();
}