Bode plot filters implemented in JavaScript

var BODEPLOT = (function(jQuery, Math, math, d3) {
    // ********************************
    // *** start: private functions ***
    // ********************************
    function linspace(a, b, n) {
        var every = (b-a)/(n-1),
            range = [];
        for (var i = a; i < b; i += every)
            range.push(i);
        return range.length == n ? range : range.concat(b);
    }

    function logspace(a, b, n) {
        return linspace(a, b, n).map(function(x) { return Math.pow(10, x); });
    }

    function angle(f) {
        return math.atan2(f.im, f.re);
    }

    function deg2rad(deg) {
        return deg * math.pi / 180;
    }

    function rad2deg(rad) {
        return rad * 180 / math.pi;
    }

    function mag2db(mag) {
        return 20 * Math.log10(mag);
    }

    function db2mag(db) {
        return math.pow(10, db / 20);
    }

    function purgeNulls(val) {
        return val;
    }
    // ******************************
    // *** fin: private functions ***
    // ******************************

    // ***************************
    // *** start: private vars ***
    // ***************************
    var filters = {};
    var plotFunctions = {};
    // *************************
    // *** fin: private vars ***
    // *************************

    // *********************************
    // *** start: Plot() constructor ***
    // *********************************
    function Plot(options) {
        var that = this;

        // A `settings` object, which can be overridden by `options`
        this.settings = $.extend(true, {
            'width': 600,
            'height': 250,
            'margin': { 'top': 20, 'right': 20, 'bottom': 35, 'left': 50 },
            'logspace': { 'a':-1, 'b': 4, 'n': 5000 },
            'filters': []
        }, options);
        var settings = this.settings; // shorthand for immediate use below

        this.dataMag = [];
        this.dataPhs = [];

        var width = settings.width - settings.margin.left - settings.margin.right;
        var height = settings.height - settings.margin.top - settings.margin.bottom;

        this.range = logspace(settings.logspace.a, settings.logspace.b, settings.logspace.n);

        this.x = d3.scale.log()
            .domain([this.range[0], this.range[this.range.length-1].toFixed()])
            .range([0, width]);

        this.xGrid = d3.svg.axis()
            .scale(this.x)
            .orient("bottom")
            .ticks(5)
            .tickSize(-height, -height, 0)
            .tickFormat("");

        this.magY = d3.scale.linear()
            .domain([-20, 20])
            .range([height, 0]);

        this.magXAxis1 = d3.svg.axis()
            .scale(this.x)
            .orient("bottom")
            .ticks(1,"0.1s")
            .innerTickSize(-6)
            .outerTickSize(0)
            .tickPadding(7)
            .tickFormat("");

        this.magYAxis1 = d3.svg.axis()
            .scale(this.magY)
            .orient("left")
            

$(function() {
    // *** Filters ***
    BODEPLOT.setFilter('continuous', new BODEPLOT.Filter({
        'legend1': 'Magnitude',
        'legend2': 'Phase',
        'color': 'blue',
        'plotConstraintFn': function(x, fs) { return true; },
        'filterFn': function(fs, K, wz, wp) { return { a:[K*wp*wz, K*wp], b:[wp*wz, wz] }; },
        'plotFn': 'cleadlag'
    }));
    BODEPLOT.setFilter('forwardeuler', new BODEPLOT.Filter({
        'legend1': 'Sampling',
        'legend2': 'Phase',
        'color': 'red',
        'plotConstraintFn': function(x, fs) { return x < fs/2; },
        'filterFn': function(fs, K, wz, wp) { return { a:[-K*wp, K*wp*(1 + wz/fs)], b:[-wz, wz*(1 + wp/fs)] }; },
        'plotFn': 'dleadlag'
    }));
    BODEPLOT.setFilter('backwardeuler', new BODEPLOT.Filter({
        'legend1': 'Sampling',
        'legend2': 'Phase',
        'color': 'green',
        'plotConstraintFn': function(x, fs) { return x < fs/2; },
        'filterFn': function(fs, K, wz, wp) { return { a:[K*wp*(wz/fs - 1), K*wp], b:[wz*(wp/fs - 1), wz] }; },
        'plotFn': 'dleadlag'
    }));
    BODEPLOT.setFilter('tustin', new BODEPLOT.Filter({
        'legend1': 'Sampling',
        'legend2': 'Phase',
        'color': 'yellow',
        'plotConstraintFn': function(x, fs) { return x < fs/2; },
        'filterFn': function(fs, K, wz, wp) { return { a:[K*wp*(wz/fs - 2), K*wp*(2 + wz/fs)], b:[wz*(wp/fs - 2), wz*(2 + wp/fs)] }; },
        'plotFn': 'dleadlag'
    }));

    // create a `Plot()` instance.
    var bodePlot = new BODEPLOT.Plot({
        'plotmagID': "plotmag",
        'plotphsID': "plotphs",
        filters: ['continuous', 'forwardeuler', 'backwardeuler', 'tustin']
    });

    // ***** Attach event handler to DOM elements *****
    $("#sliders input").change(function() {
        bodePlot.updateData(
            $("#slider-fs").val(),
            $("#slider-g").val(),
            $("#slider-fz").val(),
            $("#slider-fp").val()
        );
        bodePlot.redraw();
    }).eq(0).trigger('change');
});