| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| (function (global, factory) { |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('echarts')) : |
| typeof define === 'function' && define.amd ? define(['exports', 'echarts'], factory) : |
| (factory((global.dataTool = {}),global.echarts)); |
| }(this, (function (exports,echarts) { 'use strict'; |
| |
| /** |
| * @module zrender/core/util |
| */ |
| |
| // 用于处理merge时无法遍历Date等对象的问题 |
| var arrayProto = Array.prototype; |
| var nativeMap = arrayProto.map; |
| |
| |
| /** |
| * Those data types can be cloned: |
| * Plain object, Array, TypedArray, number, string, null, undefined. |
| * Those data types will be assgined using the orginal data: |
| * BUILTIN_OBJECT |
| * Instance of user defined class will be cloned to a plain object, without |
| * properties in prototype. |
| * Other data types is not supported (not sure what will happen). |
| * |
| * Caution: do not support clone Date, for performance consideration. |
| * (There might be a large number of date in `series.data`). |
| * So date should not be modified in and out of echarts. |
| * |
| * @param {*} source |
| * @return {*} new |
| */ |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {*} target |
| * @param {*} source |
| * @param {boolean} [overwrite=false] |
| */ |
| |
| |
| /** |
| * @param {Array} targetAndSources The first item is target, and the rests are source. |
| * @param {boolean} [overwrite=false] |
| * @return {*} target |
| */ |
| |
| |
| /** |
| * @param {*} target |
| * @param {*} source |
| * @memberOf module:zrender/core/util |
| */ |
| |
| |
| /** |
| * @param {*} target |
| * @param {*} source |
| * @param {boolean} [overlay=false] |
| * @memberOf module:zrender/core/util |
| */ |
| |
| |
| |
| |
| |
| |
| /** |
| * 查询数组中元素的index |
| * @memberOf module:zrender/core/util |
| */ |
| |
| |
| /** |
| * 构造类继承关系 |
| * |
| * @memberOf module:zrender/core/util |
| * @param {Function} clazz 源类 |
| * @param {Function} baseClazz 基类 |
| */ |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {Object|Function} target |
| * @param {Object|Function} sorce |
| * @param {boolean} overlay |
| */ |
| |
| |
| /** |
| * Consider typed array. |
| * @param {Array|TypedArray} data |
| */ |
| |
| |
| /** |
| * 数组或对象遍历 |
| * @memberOf module:zrender/core/util |
| * @param {Object|Array} obj |
| * @param {Function} cb |
| * @param {*} [context] |
| */ |
| |
| |
| /** |
| * 数组映射 |
| * @memberOf module:zrender/core/util |
| * @param {Array} obj |
| * @param {Function} cb |
| * @param {*} [context] |
| * @return {Array} |
| */ |
| function map(obj, cb, context) { |
| if (!(obj && cb)) { |
| return; |
| } |
| if (obj.map && obj.map === nativeMap) { |
| return obj.map(cb, context); |
| } |
| else { |
| var result = []; |
| for (var i = 0, len = obj.length; i < len; i++) { |
| result.push(cb.call(context, obj[i], i, obj)); |
| } |
| return result; |
| } |
| } |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {Array} obj |
| * @param {Function} cb |
| * @param {Object} [memo] |
| * @param {*} [context] |
| * @return {Array} |
| */ |
| |
| |
| /** |
| * 数组过滤 |
| * @memberOf module:zrender/core/util |
| * @param {Array} obj |
| * @param {Function} cb |
| * @param {*} [context] |
| * @return {Array} |
| */ |
| |
| |
| /** |
| * 数组项查找 |
| * @memberOf module:zrender/core/util |
| * @param {Array} obj |
| * @param {Function} cb |
| * @param {*} [context] |
| * @return {*} |
| */ |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {Function} func |
| * @param {*} context |
| * @return {Function} |
| */ |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {Function} func |
| * @return {Function} |
| */ |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {*} value |
| * @return {boolean} |
| */ |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {*} value |
| * @return {boolean} |
| */ |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {*} value |
| * @return {boolean} |
| */ |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {*} value |
| * @return {boolean} |
| */ |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {*} value |
| * @return {boolean} |
| */ |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {*} value |
| * @return {boolean} |
| */ |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {*} value |
| * @return {boolean} |
| */ |
| |
| |
| /** |
| * Whether is exactly NaN. Notice isNaN('a') returns true. |
| * @param {*} value |
| * @return {boolean} |
| */ |
| |
| |
| /** |
| * If value1 is not null, then return value1, otherwise judget rest of values. |
| * Low performance. |
| * @memberOf module:zrender/core/util |
| * @return {*} Final value |
| */ |
| |
| |
| |
| |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {Array} arr |
| * @param {number} startIndex |
| * @param {number} endIndex |
| * @return {Array} |
| */ |
| |
| |
| /** |
| * Normalize css liked array configuration |
| * e.g. |
| * 3 => [3, 3, 3, 3] |
| * [4, 2] => [4, 2, 4, 2] |
| * [4, 3, 2] => [4, 3, 2, 3] |
| * @param {number|Array.<number>} val |
| * @return {Array.<number>} |
| */ |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {boolean} condition |
| * @param {string} message |
| */ |
| |
| |
| /** |
| * @memberOf module:zrender/core/util |
| * @param {string} str string to be trimed |
| * @return {string} trimed string |
| */ |
| |
| |
| /** |
| * Set an object as primitive to be ignored traversing children in clone or merge |
| */ |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| /** |
| * This is a parse of GEXF. |
| * |
| * The spec of GEXF: |
| * https://gephi.org/gexf/1.2draft/gexf-12draft-primer.pdf |
| */ |
| |
| function parse(xml) { |
| var doc; |
| if (typeof xml === 'string') { |
| var parser = new DOMParser(); |
| doc = parser.parseFromString(xml, 'text/xml'); |
| } |
| else { |
| doc = xml; |
| } |
| if (!doc || doc.getElementsByTagName('parsererror').length) { |
| return null; |
| } |
| |
| var gexfRoot = getChildByTagName(doc, 'gexf'); |
| |
| if (!gexfRoot) { |
| return null; |
| } |
| |
| var graphRoot = getChildByTagName(gexfRoot, 'graph'); |
| |
| var attributes = parseAttributes(getChildByTagName(graphRoot, 'attributes')); |
| var attributesMap = {}; |
| for (var i = 0; i < attributes.length; i++) { |
| attributesMap[attributes[i].id] = attributes[i]; |
| } |
| |
| return { |
| nodes: parseNodes(getChildByTagName(graphRoot, 'nodes'), attributesMap), |
| links: parseEdges(getChildByTagName(graphRoot, 'edges')) |
| }; |
| } |
| |
| function parseAttributes(parent) { |
| return parent ? map(getChildrenByTagName(parent, 'attribute'), function (attribDom) { |
| return { |
| id: getAttr(attribDom, 'id'), |
| title: getAttr(attribDom, 'title'), |
| type: getAttr(attribDom, 'type') |
| }; |
| }) : []; |
| } |
| |
| function parseNodes(parent, attributesMap) { |
| return parent ? map(getChildrenByTagName(parent, 'node'), function (nodeDom) { |
| |
| var id = getAttr(nodeDom, 'id'); |
| var label = getAttr(nodeDom, 'label'); |
| |
| var node = { |
| id: id, |
| name: label, |
| itemStyle: { |
| normal: {} |
| } |
| }; |
| |
| var vizSizeDom = getChildByTagName(nodeDom, 'viz:size'); |
| var vizPosDom = getChildByTagName(nodeDom, 'viz:position'); |
| var vizColorDom = getChildByTagName(nodeDom, 'viz:color'); |
| // var vizShapeDom = getChildByTagName(nodeDom, 'viz:shape'); |
| |
| var attvaluesDom = getChildByTagName(nodeDom, 'attvalues'); |
| |
| if (vizSizeDom) { |
| node.symbolSize = parseFloat(getAttr(vizSizeDom, 'value')); |
| } |
| if (vizPosDom) { |
| node.x = parseFloat(getAttr(vizPosDom, 'x')); |
| node.y = parseFloat(getAttr(vizPosDom, 'y')); |
| // z |
| } |
| if (vizColorDom) { |
| node.itemStyle.normal.color = 'rgb(' + [ |
| getAttr(vizColorDom, 'r') | 0, |
| getAttr(vizColorDom, 'g') | 0, |
| getAttr(vizColorDom, 'b') | 0 |
| ].join(',') + ')'; |
| } |
| // if (vizShapeDom) { |
| // node.shape = getAttr(vizShapeDom, 'shape'); |
| // } |
| if (attvaluesDom) { |
| var attvalueDomList = getChildrenByTagName(attvaluesDom, 'attvalue'); |
| |
| node.attributes = {}; |
| |
| for (var j = 0; j < attvalueDomList.length; j++) { |
| var attvalueDom = attvalueDomList[j]; |
| var attId = getAttr(attvalueDom, 'for'); |
| var attValue = getAttr(attvalueDom, 'value'); |
| var attribute = attributesMap[attId]; |
| |
| if (attribute) { |
| switch (attribute.type) { |
| case 'integer': |
| case 'long': |
| attValue = parseInt(attValue, 10); |
| break; |
| case 'float': |
| case 'double': |
| attValue = parseFloat(attValue); |
| break; |
| case 'boolean': |
| attValue = attValue.toLowerCase() === 'true'; |
| break; |
| default: |
| } |
| node.attributes[attId] = attValue; |
| } |
| } |
| } |
| |
| return node; |
| }) : []; |
| } |
| |
| function parseEdges(parent) { |
| return parent ? map(getChildrenByTagName(parent, 'edge'), function (edgeDom) { |
| var id = getAttr(edgeDom, 'id'); |
| var label = getAttr(edgeDom, 'label'); |
| |
| var sourceId = getAttr(edgeDom, 'source'); |
| var targetId = getAttr(edgeDom, 'target'); |
| |
| var edge = { |
| id: id, |
| name: label, |
| source: sourceId, |
| target: targetId, |
| lineStyle: { |
| normal: {} |
| } |
| }; |
| |
| var lineStyle = edge.lineStyle.normal; |
| |
| var vizThicknessDom = getChildByTagName(edgeDom, 'viz:thickness'); |
| var vizColorDom = getChildByTagName(edgeDom, 'viz:color'); |
| // var vizShapeDom = getChildByTagName(edgeDom, 'viz:shape'); |
| |
| if (vizThicknessDom) { |
| lineStyle.width = parseFloat(vizThicknessDom.getAttribute('value')); |
| } |
| if (vizColorDom) { |
| lineStyle.color = 'rgb(' + [ |
| getAttr(vizColorDom, 'r') | 0, |
| getAttr(vizColorDom, 'g') | 0, |
| getAttr(vizColorDom, 'b') | 0 |
| ].join(',') + ')'; |
| } |
| // if (vizShapeDom) { |
| // edge.shape = vizShapeDom.getAttribute('shape'); |
| // } |
| |
| return edge; |
| }) : []; |
| } |
| |
| function getAttr(el, attrName) { |
| return el.getAttribute(attrName); |
| } |
| |
| function getChildByTagName(parent, tagName) { |
| var node = parent.firstChild; |
| |
| while (node) { |
| if ( |
| node.nodeType !== 1 |
| || node.nodeName.toLowerCase() !== tagName.toLowerCase() |
| ) { |
| node = node.nextSibling; |
| } |
| else { |
| return node; |
| } |
| } |
| |
| return null; |
| } |
| |
| function getChildrenByTagName(parent, tagName) { |
| var node = parent.firstChild; |
| var children = []; |
| while (node) { |
| if (node.nodeName.toLowerCase() === tagName.toLowerCase()) { |
| children.push(node); |
| } |
| node = node.nextSibling; |
| } |
| |
| return children; |
| } |
| |
| |
| var gexf = (Object.freeze || Object)({ |
| parse: parse |
| }); |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| /* |
| * A third-party license is embeded for some of the code in this file: |
| * The method "quantile" was copied from "d3.js". |
| * (See more details in the comment of the method below.) |
| * The use of the source code of this file is also subject to the terms |
| * and consitions of the license of "d3.js" (BSD-3Clause, see |
| * </licenses/LICENSE-d3>). |
| */ |
| |
| /** |
| * Linear mapping a value from domain to range |
| * @memberOf module:echarts/util/number |
| * @param {(number|Array.<number>)} val |
| * @param {Array.<number>} domain Domain extent domain[0] can be bigger than domain[1] |
| * @param {Array.<number>} range Range extent range[0] can be bigger than range[1] |
| * @param {boolean} clamp |
| * @return {(number|Array.<number>} |
| */ |
| |
| |
| /** |
| * Convert a percent string to absolute number. |
| * Returns NaN if percent is not a valid string or number |
| * @memberOf module:echarts/util/number |
| * @param {string|number} percent |
| * @param {number} all |
| * @return {number} |
| */ |
| |
| |
| /** |
| * (1) Fix rounding error of float numbers. |
| * (2) Support return string to avoid scientific notation like '3.5e-7'. |
| * |
| * @param {number} x |
| * @param {number} [precision] |
| * @param {boolean} [returnStr] |
| * @return {number|string} |
| */ |
| |
| |
| /** |
| * asc sort arr. |
| * The input arr will be modified. |
| * |
| * @param {Array} arr |
| * @return {Array} The input arr. |
| */ |
| function asc(arr) { |
| arr.sort(function (a, b) { |
| return a - b; |
| }); |
| return arr; |
| } |
| |
| /** |
| * Get precision |
| * @param {number} val |
| */ |
| |
| |
| /** |
| * @param {string|number} val |
| * @return {number} |
| */ |
| |
| |
| /** |
| * Minimal dicernible data precisioin according to a single pixel. |
| * |
| * @param {Array.<number>} dataExtent |
| * @param {Array.<number>} pixelExtent |
| * @return {number} precision |
| */ |
| |
| |
| /** |
| * Get a data of given precision, assuring the sum of percentages |
| * in valueList is 1. |
| * The largest remainer method is used. |
| * https://en.wikipedia.org/wiki/Largest_remainder_method |
| * |
| * @param {Array.<number>} valueList a list of all data |
| * @param {number} idx index of the data to be processed in valueList |
| * @param {number} precision integer number showing digits of precision |
| * @return {number} percent ranging from 0 to 100 |
| */ |
| |
| |
| // Number.MAX_SAFE_INTEGER, ie do not support. |
| |
| |
| /** |
| * To 0 - 2 * PI, considering negative radian. |
| * @param {number} radian |
| * @return {number} |
| */ |
| |
| |
| /** |
| * @param {type} radian |
| * @return {boolean} |
| */ |
| |
| |
| /* eslint-enable */ |
| |
| /** |
| * @param {string|Date|number} value These values can be accepted: |
| * + An instance of Date, represent a time in its own time zone. |
| * + Or string in a subset of ISO 8601, only including: |
| * + only year, month, date: '2012-03', '2012-03-01', '2012-03-01 05', '2012-03-01 05:06', |
| * + separated with T or space: '2012-03-01T12:22:33.123', '2012-03-01 12:22:33.123', |
| * + time zone: '2012-03-01T12:22:33Z', '2012-03-01T12:22:33+8000', '2012-03-01T12:22:33-05:00', |
| * all of which will be treated as local time if time zone is not specified |
| * (see <https://momentjs.com/>). |
| * + Or other string format, including (all of which will be treated as loacal time): |
| * '2012', '2012-3-1', '2012/3/1', '2012/03/01', |
| * '2009/6/12 2:00', '2009/6/12 2:05:08', '2009/6/12 2:05:08.123' |
| * + a timestamp, which represent a time in UTC. |
| * @return {Date} date |
| */ |
| |
| |
| /** |
| * Quantity of a number. e.g. 0.1, 1, 10, 100 |
| * |
| * @param {number} val |
| * @return {number} |
| */ |
| |
| |
| /** |
| * Exponent of the quantity of a number |
| * e.g., 1234 equals to 1.234*10^3, so quantityExponent(1234) is 3 |
| * |
| * @param {number} val non-negative value |
| * @return {number} |
| */ |
| |
| |
| /** |
| * find a “nice” number approximately equal to x. Round the number if round = true, |
| * take ceiling if round = false. The primary observation is that the “nicest” |
| * numbers in decimal are 1, 2, and 5, and all power-of-ten multiples of these numbers. |
| * |
| * See "Nice Numbers for Graph Labels" of Graphic Gems. |
| * |
| * @param {number} val Non-negative value. |
| * @param {boolean} round |
| * @return {number} |
| */ |
| |
| |
| /** |
| * This code was copied from "d3.js" |
| * <https://github.com/d3/d3/blob/9cc9a875e636a1dcf36cc1e07bdf77e1ad6e2c74/src/arrays/quantile.js>. |
| * See the license statement at the head of this file. |
| * @param {Array.<number>} ascArr |
| */ |
| function quantile(ascArr, p) { |
| var H = (ascArr.length - 1) * p + 1; |
| var h = Math.floor(H); |
| var v = +ascArr[h - 1]; |
| var e = H - h; |
| return e ? v + e * (ascArr[h] - v) : v; |
| } |
| |
| /** |
| * Order intervals asc, and split them when overlap. |
| * expect(numberUtil.reformIntervals([ |
| * {interval: [18, 62], close: [1, 1]}, |
| * {interval: [-Infinity, -70], close: [0, 0]}, |
| * {interval: [-70, -26], close: [1, 1]}, |
| * {interval: [-26, 18], close: [1, 1]}, |
| * {interval: [62, 150], close: [1, 1]}, |
| * {interval: [106, 150], close: [1, 1]}, |
| * {interval: [150, Infinity], close: [0, 0]} |
| * ])).toEqual([ |
| * {interval: [-Infinity, -70], close: [0, 0]}, |
| * {interval: [-70, -26], close: [1, 1]}, |
| * {interval: [-26, 18], close: [0, 1]}, |
| * {interval: [18, 62], close: [0, 1]}, |
| * {interval: [62, 150], close: [0, 1]}, |
| * {interval: [150, Infinity], close: [0, 0]} |
| * ]); |
| * @param {Array.<Object>} list, where `close` mean open or close |
| * of the interval, and Infinity can be used. |
| * @return {Array.<Object>} The origin list, which has been reformed. |
| */ |
| |
| |
| /** |
| * parseFloat NaNs numeric-cast false positives (null|true|false|"") |
| * ...but misinterprets leading-number strings, particularly hex literals ("0x...") |
| * subtraction forces infinities to NaN |
| * |
| * @param {*} v |
| * @return {boolean} |
| */ |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| /** |
| * See: |
| * <https://en.wikipedia.org/wiki/Box_plot#cite_note-frigge_hoaglin_iglewicz-2> |
| * <http://stat.ethz.ch/R-manual/R-devel/library/grDevices/html/boxplot.stats.html> |
| * |
| * Helper method for preparing data. |
| * |
| * @param {Array.<number>} rawData like |
| * [ |
| * [12,232,443], (raw data set for the first box) |
| * [3843,5545,1232], (raw datat set for the second box) |
| * ... |
| * ] |
| * @param {Object} [opt] |
| * |
| * @param {(number|string)} [opt.boundIQR=1.5] Data less than min bound is outlier. |
| * default 1.5, means Q1 - 1.5 * (Q3 - Q1). |
| * If 'none'/0 passed, min bound will not be used. |
| * @param {(number|string)} [opt.layout='horizontal'] |
| * Box plot layout, can be 'horizontal' or 'vertical' |
| * @return {Object} { |
| * boxData: Array.<Array.<number>> |
| * outliers: Array.<Array.<number>> |
| * axisData: Array.<string> |
| * } |
| */ |
| var prepareBoxplotData = function (rawData, opt) { |
| opt = opt || []; |
| var boxData = []; |
| var outliers = []; |
| var axisData = []; |
| var boundIQR = opt.boundIQR; |
| var useExtreme = boundIQR === 'none' || boundIQR === 0; |
| |
| for (var i = 0; i < rawData.length; i++) { |
| axisData.push(i + ''); |
| var ascList = asc(rawData[i].slice()); |
| |
| var Q1 = quantile(ascList, 0.25); |
| var Q2 = quantile(ascList, 0.5); |
| var Q3 = quantile(ascList, 0.75); |
| var min = ascList[0]; |
| var max = ascList[ascList.length - 1]; |
| |
| var bound = (boundIQR == null ? 1.5 : boundIQR) * (Q3 - Q1); |
| |
| var low = useExtreme |
| ? min |
| : Math.max(min, Q1 - bound); |
| var high = useExtreme |
| ? max |
| : Math.min(max, Q3 + bound); |
| |
| boxData.push([low, Q1, Q2, Q3, high]); |
| |
| for (var j = 0; j < ascList.length; j++) { |
| var dataItem = ascList[j]; |
| if (dataItem < low || dataItem > high) { |
| var outlier = [i, dataItem]; |
| opt.layout === 'vertical' && outlier.reverse(); |
| outliers.push(outlier); |
| } |
| } |
| } |
| return { |
| boxData: boxData, |
| outliers: outliers, |
| axisData: axisData |
| }; |
| }; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| var version = '1.0.0'; |
| |
| // For backward compatibility, where the namespace `dataTool` will |
| // be mounted on `echarts` is the extension `dataTool` is imported. |
| // But the old version of echarts do not have `dataTool` namespace, |
| // so check it before mounting. |
| if (echarts.dataTool) { |
| echarts.dataTool.version = version; |
| echarts.dataTool.gexf = gexf; |
| echarts.dataTool.prepareBoxplotData = prepareBoxplotData; |
| } |
| |
| exports.version = version; |
| exports.gexf = gexf; |
| exports.prepareBoxplotData = prepareBoxplotData; |
| |
| }))); |
| //# sourceMappingURL=dataTool.js.map |