mdarray-sol 0.1.0-java

data/node_modules/dc/src/errors.js

@@ -0,0 +1,28 @@
+dc.errors = {};
+
+dc.errors.Exception = function (msg) {
+    var _msg = msg || 'Unexpected internal error';
+
+    this.message = _msg;
+
+    this.toString = function () {
+        return _msg;
+    };
+    this.stack = (new Error()).stack;
+};
+dc.errors.Exception.prototype = Object.create(Error.prototype);
+dc.errors.Exception.prototype.constructor = dc.errors.Exception;
+
+dc.errors.InvalidStateException = function () {
+    dc.errors.Exception.apply(this, arguments);
+};
+
+dc.errors.InvalidStateException.prototype = Object.create(dc.errors.Exception.prototype);
+dc.errors.InvalidStateException.prototype.constructor = dc.errors.InvalidStateException;
+
+dc.errors.BadArgumentException = function () {
+    dc.errors.Exception.apply(this, arguments);
+};
+
+dc.errors.BadArgumentException.prototype = Object.create(dc.errors.Exception.prototype);
+dc.errors.BadArgumentException.prototype.constructor = dc.errors.BadArgumentException;

data/node_modules/dc/src/events.js

@@ -0,0 +1,37 @@
+dc.events = {
+    current: null
+};
+
+/**
+ * This function triggers a throttled event function with a specified delay (in milli-seconds).  Events
+ * that are triggered repetitively due to user interaction such brush dragging might flood the library
+ * and invoke more renders than can be executed in time. Using this function to wrap your event
+ * function allows the library to smooth out the rendering by throttling events and only responding to
+ * the most recent event.
+ * @name events.trigger
+ * @memberof dc
+ * @example
+ * chart.on('renderlet', function(chart) {
+ *     // smooth the rendering through event throttling
+ *     dc.events.trigger(function(){
+ *         // focus some other chart to the range selected by user on this chart
+ *         someOtherChart.focus(chart.filter());
+ *     });
+ * })
+ * @param {Function} closure
+ * @param {Number} [delay]
+ */
+dc.events.trigger = function (closure, delay) {
+    if (!delay) {
+        closure();
+        return;
+    }
+
+    dc.events.current = closure;
+
+    setTimeout(function () {
+        if (closure === dc.events.current) {
+            closure();
+        }
+    }, delay);
+};

data/node_modules/dc/src/filters.js

@@ -0,0 +1,124 @@
+/**
+ * The dc.js filters are functions which are passed into crossfilter to chose which records will be
+ * accumulated to produce values for the charts.  In the crossfilter model, any filters applied on one
+ * dimension will affect all the other dimensions but not that one.  dc always applies a filter
+ * function to the dimension; the function combines multiple filters and if any of them accept a
+ * record, it is filtered in.
+ *
+ * These filter constructors are used as appropriate by the various charts to implement brushing.  We
+ * mention below which chart uses which filter.  In some cases, many instances of a filter will be added.
+ *
+ * Each of the dc.js filters is an object with the following properties:
+ * * `isFiltered` - a function that returns true if a value is within the filter
+ * * `filterType` - a string identifying the filter, here the name of the constructor
+ *
+ * Currently these filter objects are also arrays, but this is not a requirement. Custom filters
+ * can be used as long as they have the properties above.
+ * @namespace filters
+ * @memberof dc
+ * @type {{}}
+ */
+dc.filters = {};
+
+/**
+ * RangedFilter is a filter which accepts keys between `low` and `high`.  It is used to implement X
+ * axis brushing for the {@link dc.coordinateGridMixin coordinate grid charts}.
+ *
+ * Its `filterType` is 'RangedFilter'
+ * @name RangedFilter
+ * @memberof dc.filters
+ * @param {Number} low
+ * @param {Number} high
+ * @return {Array<Number>}
+ * @constructor
+ */
+dc.filters.RangedFilter = function (low, high) {
+    var range = new Array(low, high);
+    range.isFiltered = function (value) {
+        return value >= this[0] && value < this[1];
+    };
+    range.filterType = 'RangedFilter';
+
+    return range;
+};
+
+/**
+ * TwoDimensionalFilter is a filter which accepts a single two-dimensional value.  It is used by the
+ * {@link dc.heatMap heat map chart} to include particular cells as they are clicked.  (Rows and columns are
+ * filtered by filtering all the cells in the row or column.)
+ *
+ * Its `filterType` is 'TwoDimensionalFilter'
+ * @name TwoDimensionalFilter
+ * @memberof dc.filters
+ * @param {Array<Number>} filter
+ * @return {Array<Number>}
+ * @constructor
+ */
+dc.filters.TwoDimensionalFilter = function (filter) {
+    if (filter === null) { return null; }
+
+    var f = filter;
+    f.isFiltered = function (value) {
+        return value.length && value.length === f.length &&
+               value[0] === f[0] && value[1] === f[1];
+    };
+    f.filterType = 'TwoDimensionalFilter';
+
+    return f;
+};
+
+/**
+ * The RangedTwoDimensionalFilter allows filtering all values which fit within a rectangular
+ * region. It is used by the {@link dc.scatterPlot scatter plot} to implement rectangular brushing.
+ *
+ * It takes two two-dimensional points in the form `[[x1,y1],[x2,y2]]`, and normalizes them so that
+ * `x1 <= x2` and `y1 <= y2`. It then returns a filter which accepts any points which are in the
+ * rectangular range including the lower values but excluding the higher values.
+ *
+ * If an array of two values are given to the RangedTwoDimensionalFilter, it interprets the values as
+ * two x coordinates `x1` and `x2` and returns a filter which accepts any points for which `x1 <= x <
+ * x2`.
+ *
+ * Its `filterType` is 'RangedTwoDimensionalFilter'
+ * @name RangedTwoDimensionalFilter
+ * @memberof dc.filters
+ * @param {Array<Array<Number>>} filter
+ * @return {Array<Array<Number>>}
+ * @constructor
+ */
+dc.filters.RangedTwoDimensionalFilter = function (filter) {
+    if (filter === null) { return null; }
+
+    var f = filter;
+    var fromBottomLeft;
+
+    if (f[0] instanceof Array) {
+        fromBottomLeft = [
+            [Math.min(filter[0][0], filter[1][0]), Math.min(filter[0][1], filter[1][1])],
+            [Math.max(filter[0][0], filter[1][0]), Math.max(filter[0][1], filter[1][1])]
+        ];
+    } else {
+        fromBottomLeft = [[filter[0], -Infinity], [filter[1], Infinity]];
+    }
+
+    f.isFiltered = function (value) {
+        var x, y;
+
+        if (value instanceof Array) {
+            if (value.length !== 2) {
+                return false;
+            }
+            x = value[0];
+            y = value[1];
+        } else {
+            x = value;
+            y = fromBottomLeft[0][1];
+        }
+
+        return x >= fromBottomLeft[0][0] && x < fromBottomLeft[1][0] &&
+               y >= fromBottomLeft[0][1] && y < fromBottomLeft[1][1];
+    };
+    f.filterType = 'RangedTwoDimensionalFilter';
+
+    return f;
+};

data/node_modules/dc/src/footer.js

@@ -0,0 +1,35 @@
+// Renamed functions
+
+dc.abstractBubbleChart = dc.bubbleMixin;
+dc.baseChart = dc.baseMixin;
+dc.capped = dc.capMixin;
+dc.colorChart = dc.colorMixin;
+dc.coordinateGridChart = dc.coordinateGridMixin;
+dc.marginable = dc.marginMixin;
+dc.stackableChart = dc.stackMixin;
+
+// Expose d3 and crossfilter, so that clients in browserify
+// case can obtain them if they need them.
+dc.d3 = d3;
+dc.crossfilter = crossfilter;
+
+return dc;}
+    if(typeof define === "function" && define.amd) {
+        define(["d3", "crossfilter"], _dc);
+    } else if(typeof module === "object" && module.exports) {
+        var _d3 = require('d3');
+        var _crossfilter = require('crossfilter2');
+        // When using npm + browserify, 'crossfilter' is a function,
+        // since package.json specifies index.js as main function, and it
+        // does special handling. When using bower + browserify,
+        // there's no main in bower.json (in fact, there's no bower.json),
+        // so we need to fix it.
+        if (typeof _crossfilter !== "function") {
+            _crossfilter = _crossfilter.crossfilter;
+        }
+        module.exports = _dc(_d3, _crossfilter);
+    } else {
+        this.dc = _dc(d3, crossfilter);
+    }
+}
+)();

data/node_modules/dc/src/geo-choropleth-chart.js

@@ -0,0 +1,279 @@
+/**
+ * The geo choropleth chart is designed as an easy way to create a crossfilter driven choropleth map
+ * from GeoJson data. This chart implementation was inspired by
+ * {@link http://bl.ocks.org/4060606 the great d3 choropleth example}.
+ *
+ * Examples:
+ * - {@link http://dc-js.github.com/dc.js/vc/index.html US Venture Capital Landscape 2011}
+ * @class geoChoroplethChart
+ * @memberof dc
+ * @mixes dc.colorMixin
+ * @mixes dc.baseMixin
+ * @example
+ * // create a choropleth chart under '#us-chart' element using the default global chart group
+ * var chart1 = dc.geoChoroplethChart('#us-chart');
+ * // create a choropleth chart under '#us-chart2' element using chart group A
+ * var chart2 = dc.compositeChart('#us-chart2', 'chartGroupA');
+ * @param {String|node|d3.selection} parent - Any valid
+ * {@link https://github.com/mbostock/d3/wiki/Selections#selecting-elements d3 single selector} specifying
+ * a dom block element such as a div; or a dom element or d3 selection.
+ * @param {String} [chartGroup] - The name of the chart group this chart instance should be placed in.
+ * Interaction with a chart will only trigger events and redraws within the chart's group.
+ * @return {dc.geoChoroplethChart}
+ */
+dc.geoChoroplethChart = function (parent, chartGroup) {
+    var _chart = dc.colorMixin(dc.baseMixin({}));
+
+    _chart.colorAccessor(function (d) {
+        return d || 0;
+    });
+
+    var _geoPath = d3.geo.path();
+    var _projectionFlag;
+
+    var _geoJsons = [];
+
+    _chart._doRender = function () {
+        _chart.resetSvg();
+        for (var layerIndex = 0; layerIndex < _geoJsons.length; ++layerIndex) {
+            var states = _chart.svg().append('g')
+                .attr('class', 'layer' + layerIndex);
+
+            var regionG = states.selectAll('g.' + geoJson(layerIndex).name)
+                .data(geoJson(layerIndex).data)
+                .enter()
+                .append('g')
+                .attr('class', geoJson(layerIndex).name);
+
+            regionG
+                .append('path')
+                .attr('fill', 'white')
+                .attr('d', _geoPath);
+
+            regionG.append('title');
+
+            plotData(layerIndex);
+        }
+        _projectionFlag = false;
+    };
+
+    function plotData (layerIndex) {
+        var data = generateLayeredData();
+
+        if (isDataLayer(layerIndex)) {
+            var regionG = renderRegionG(layerIndex);
+
+            renderPaths(regionG, layerIndex, data);
+
+            renderTitle(regionG, layerIndex, data);
+        }
+    }
+
+    function generateLayeredData () {
+        var data = {};
+        var groupAll = _chart.data();
+        for (var i = 0; i < groupAll.length; ++i) {
+            data[_chart.keyAccessor()(groupAll[i])] = _chart.valueAccessor()(groupAll[i]);
+        }
+        return data;
+    }
+
+    function isDataLayer (layerIndex) {
+        return geoJson(layerIndex).keyAccessor;
+    }
+
+    function renderRegionG (layerIndex) {
+        var regionG = _chart.svg()
+            .selectAll(layerSelector(layerIndex))
+            .classed('selected', function (d) {
+                return isSelected(layerIndex, d);
+            })
+            .classed('deselected', function (d) {
+                return isDeselected(layerIndex, d);
+            })
+            .attr('class', function (d) {
+                var layerNameClass = geoJson(layerIndex).name;
+                var regionClass = dc.utils.nameToId(geoJson(layerIndex).keyAccessor(d));
+                var baseClasses = layerNameClass + ' ' + regionClass;
+                if (isSelected(layerIndex, d)) {
+                    baseClasses += ' selected';
+                }
+                if (isDeselected(layerIndex, d)) {
+                    baseClasses += ' deselected';
+                }
+                return baseClasses;
+            });
+        return regionG;
+    }
+
+    function layerSelector (layerIndex) {
+        return 'g.layer' + layerIndex + ' g.' + geoJson(layerIndex).name;
+    }
+
+    function isSelected (layerIndex, d) {
+        return _chart.hasFilter() && _chart.hasFilter(getKey(layerIndex, d));
+    }
+
+    function isDeselected (layerIndex, d) {
+        return _chart.hasFilter() && !_chart.hasFilter(getKey(layerIndex, d));
+    }
+
+    function getKey (layerIndex, d) {
+        return geoJson(layerIndex).keyAccessor(d);
+    }
+
+    function geoJson (index) {
+        return _geoJsons[index];
+    }
+
+    function renderPaths (regionG, layerIndex, data) {
+        var paths = regionG
+            .select('path')
+            .attr('fill', function () {
+                var currentFill = d3.select(this).attr('fill');
+                if (currentFill) {
+                    return currentFill;
+                }
+                return 'none';
+            })
+            .on('click', function (d) {
+                return _chart.onClick(d, layerIndex);
+            });
+
+        dc.transition(paths, _chart.transitionDuration()).attr('fill', function (d, i) {
+            return _chart.getColor(data[geoJson(layerIndex).keyAccessor(d)], i);
+        });
+    }
+
+    _chart.onClick = function (d, layerIndex) {
+        var selectedRegion = geoJson(layerIndex).keyAccessor(d);
+        dc.events.trigger(function () {
+            _chart.filter(selectedRegion);
+            _chart.redrawGroup();
+        });
+    };
+
+    function renderTitle (regionG, layerIndex, data) {
+        if (_chart.renderTitle()) {
+            regionG.selectAll('title').text(function (d) {
+                var key = getKey(layerIndex, d);
+                var value = data[key];
+                return _chart.title()({key: key, value: value});
+            });
+        }
+    }
+
+    _chart._doRedraw = function () {
+        for (var layerIndex = 0; layerIndex < _geoJsons.length; ++layerIndex) {
+            plotData(layerIndex);
+            if (_projectionFlag) {
+                _chart.svg().selectAll('g.' + geoJson(layerIndex).name + ' path').attr('d', _geoPath);
+            }
+        }
+        _projectionFlag = false;
+    };
+
+    /**
+     * **mandatory**
+     *
+     * Use this function to insert a new GeoJson map layer. This function can be invoked multiple times
+     * if you have multiple GeoJson data layers to render on top of each other. If you overlay multiple
+     * layers with the same name the new overlay will override the existing one.
+     * @method overlayGeoJson
+     * @memberof dc.geoChoroplethChart
+     * @instance
+     * @see {@link http://geojson.org/ GeoJSON}
+     * @see {@link https://github.com/mbostock/topojson/wiki TopoJSON}
+     * @see {@link https://github.com/mbostock/topojson/wiki/API-Reference#feature topojson.feature}
+     * @example
+     * // insert a layer for rendering US states
+     * chart.overlayGeoJson(statesJson.features, 'state', function(d) {
+     *      return d.properties.name;
+     * });
+     * @param {geoJson} json - a geojson feed
+     * @param {String} name - name of the layer
+     * @param {Function} keyAccessor - accessor function used to extract 'key' from the GeoJson data. The key extracted by
+     * this function should match the keys returned by the crossfilter groups.
+     * @return {dc.geoChoroplethChart}
+     */
+    _chart.overlayGeoJson = function (json, name, keyAccessor) {
+        for (var i = 0; i < _geoJsons.length; ++i) {
+            if (_geoJsons[i].name === name) {
+                _geoJsons[i].data = json;
+                _geoJsons[i].keyAccessor = keyAccessor;
+                return _chart;
+            }
+        }
+        _geoJsons.push({name: name, data: json, keyAccessor: keyAccessor});
+        return _chart;
+    };
+
+    /**
+     * Set custom geo projection function. See the available [d3 geo projection
+     * functions](https://github.com/mbostock/d3/wiki/Geo-Projections).
+     * @method projection
+     * @memberof dc.geoChoroplethChart
+     * @instance
+     * @see {@link https://github.com/mbostock/d3/wiki/Geo-Projections d3.geo.projection}
+     * @see {@link https://github.com/d3/d3-geo-projection Extended d3.geo.projection}
+     * @param {d3.projection} [projection=d3.geo.albersUsa()]
+     * @return {dc.geoChoroplethChart}
+     */
+    _chart.projection = function (projection) {
+        _geoPath.projection(projection);
+        _projectionFlag = true;
+        return _chart;
+    };
+
+    /**
+     * Returns all GeoJson layers currently registered with this chart. The returned array is a
+     * reference to this chart's internal data structure, so any modification to this array will also
+     * modify this chart's internal registration.
+     * @method geoJsons
+     * @memberof dc.geoChoroplethChart
+     * @instance
+     * @return {Array<{name:String, data: Object, accessor: Function}>}
+     */
+    _chart.geoJsons = function () {
+        return _geoJsons;
+    };
+
+    /**
+     * Returns the {@link https://github.com/mbostock/d3/wiki/Geo-Paths#path d3.geo.path} object used to
+     * render the projection and features.  Can be useful for figuring out the bounding box of the
+     * feature set and thus a way to calculate scale and translation for the projection.
+     * @method geoPath
+     * @memberof dc.geoChoroplethChart
+     * @instance
+     * @see {@link https://github.com/mbostock/d3/wiki/Geo-Paths#path d3.geo.path}
+     * @return {d3.geo.path}
+     */
+    _chart.geoPath = function () {
+        return _geoPath;
+    };
+
+    /**
+     * Remove a GeoJson layer from this chart by name
+     * @method removeGeoJson
+     * @memberof dc.geoChoroplethChart
+     * @instance
+     * @param {String} name
+     * @return {dc.geoChoroplethChart}
+     */
+    _chart.removeGeoJson = function (name) {
+        var geoJsons = [];
+
+        for (var i = 0; i < _geoJsons.length; ++i) {
+            var layer = _geoJsons[i];
+            if (layer.name !== name) {
+                geoJsons.push(layer);
+            }
+        }
+
+        _geoJsons = geoJsons;
+
+        return _chart;
+    };
+
+    return _chart.anchor(parent, chartGroup);
+};