Returns the values of the given axis from all the datasets within
        this chart.
        
        :param      axis | <str>
        
        :return     [<variant>, ..]
976432
def values(self, axis):
        
        output = []
        for dataset in self.datasets():
            output += dataset.values(axis)
        
        return output
1109480
def gantry_axes(cls) -> Tuple['Axis', 'Axis', 'Axis', 'Axis']:
        
        return (cls.X, cls.Y, cls.Z, cls.A)
1233530
def removeAxis(self, axis):
        
        if not isinstance(axis, XChartAxis):
            axis = self.axis(nativestring(axis))
        
        try:
            self._axes.remove(axis)
        except ValueError:
            pass
1218986
def _collectAxisPoints(self):
        
        for l, (value, deltaName) in self.items():
            location = Location(l)
            name = location.isOnAxis()
            if name is not None and name is not False:
                if name not in self._axes:
                    self._axes[name] = []
                if l not in self._axes[name]:
                    self._axes[name].append(l)
        return self._axes
645831
def axis_names(self) -> Tuple[str, ...]:
        """"""
        default = ["axis{0}".format(i) for i in range(self.ndim)]
        return tuple(self._meta_data.get("axis_names", None) or default)
402495
def get_timeseries(self, *args, **kwargs):
        
        import predix.data.timeseries
        ts = predix.data.timeseries.TimeSeries(*args, **kwargs)
        return ts
781713
def axis(self, name):
        
        for axis in self.axes():
            if axis.name() == name:
                return axis
        return None
281923
def _get_projection_axes(self, *axes: AxisIdentifier) -> Tuple[Tuple[int, ...], Tuple[int, ...]]:
        
        axes = [self._get_axis(ax) for ax in axes]
        if not axes:
            raise ValueError("No axis selected for projection")
        if len(axes) != len(set(axes)):
            raise ValueError("Duplicate axes in projection")
        invert = list(range(self.ndim))
        for axis in axes:
            invert.remove(axis)
        axes = tuple(axes)
        invert = tuple(invert)
        return axes, invert
91601
public float getAxisValue(int axis) {
        switch (axis) {
            case AXIS_X:
                return x;
            case AXIS_Y:
                return y;
            case AXIS_PRESSURE:
                return pressure;
            case AXIS_SIZE:
                return size;
            case AXIS_TOUCH_MAJOR:
                return touchMajor;
            case AXIS_TOUCH_MINOR:
                return touchMinor;
            case AXIS_TOOL_MAJOR:
                return toolMajor;
            case AXIS_TOOL_MINOR:
                return toolMinor;
            case AXIS_ORIENTATION:
                return orientation;
            default: {
                if (axis < 0 || axis > 63) {
                    throw new IllegalArgumentException("Axis out of range.");
                }
                final long bits = mPackedAxisBits;
                final long axisBit = 1L << axis;
                if ((bits & axisBit) == 0) {
                    return 0;
                }
                final int index = Long.bitCount(bits & (axisBit - 1L));
                return mPackedAxisValues[index];
            }
        }
    }
36748
def axes(self):
        """"""
        axes = self.element.findall(GML_NS + 'axis')
        return [Axis(axis.find(GML_NS + 'CoordinateSystemAxis')) for
                axis in axes]
74481
def _get_axis_data(self, bunch, dim, cluster_id=None, load_all=None):
        
        if dim in self.attributes:
            return self.attributes[dim](cluster_id, load_all=load_all)
        masks = bunch.get('masks', None)
        assert dim not in self.attributes  # This is called only on PC data.
        s = 'ABCDEFGHIJ'
        # Channel relative index.
        c_rel = int(dim[:-1])
        # Get the channel_id from the currently-selected channels.
        channel_id = self.channel_ids[c_rel % len(self.channel_ids)]
        # Skup the plot if the channel id is not displayed.
        if channel_id not in bunch.channel_ids:  # pragma: no cover
            return None
        # Get the column index of the current channel in data.
        c = list(bunch.channel_ids).index(channel_id)
        # Principal component: A=0, B=1, etc.
        d = s.index(dim[-1])
        if masks is not None:
            masks = masks[:, c]
        return Bunch(data=bunch.data[:, c, d],
                     masks=masks,
                     )
619633
def values(self, index):
        
        values = []
        for i in xrange(self.num_instances):
            inst = self.get_instance(i)
            values.append(inst.get_value(index))
        return numpy.array(values)
265483
function (e) {
		var coordinates = {
				xAxis: [],
				yAxis: []
			};

		each(this.chart.axes, function (axis) {
			coordinates[axis.isXAxis ? 'xAxis' : 'yAxis'].push({
				axis: axis,
				value: axis.toValue(e[axis.horiz ? 'chartX' : 'chartY'])
			});
		});
		return coordinates;
	}
1371202
def _get_plane_axes(self, axis):
        
        return [self._get_axis(axi)
                for axi in self._get_plane_axes_index(axis)]
677362
def get_projection(self, axis):
        
        scale = axis.dot(self) / axis.dot(axis)
        return axis * scale
392303
def bounds(self, axis, view=None):
        
        if view is None:
            view = self
        if axis not in self._vshare.bounds:
            self._vshare.bounds[axis] = self._compute_bounds(axis, view)
        return self._vshare.bounds[axis]
1362709
def datasetItems(self):
        
        out = {}
        for item in self.items():
            if isinstance(item, XChartDatasetItem):
                out[item.dataset()] = item
        return out