Adds a new chart point to this item.
        
        :param      x | <variant>
                    y | <variant>
552596
def addPoint( self, x, y ):
        
        self._points.append((x, y))
        self._dirty = True
494796
public void add(double x, double y)
    {
        if (count >= xarr.length)
        {
            grow();
        }
        xarr[count] = x;
        yarr[count++] = y;
        minX = Math.min(minX, x);
        minY = Math.min(minY, y);
        maxX = Math.max(maxX, x);
        maxY = Math.max(maxY, y);
    }
794051
function(evt, x, y) {

        if (!this.can('vertexAdd')) return;

        // Store the index at which the new vertex has just been placed.
        // We'll be update the very same vertex position in `pointermove()`.
        var vertexIdx = this.addVertex({ x: x, y: y }, { ui: true });
        this.eventData(evt, {
            action: 'vertex-move',
            vertexIdx: vertexIdx
        });
    }
199082
def add_chart_part(self, chart_type, chart_data):
        
        chart_part = ChartPart.new(chart_type, chart_data, self.package)
        rId = self.relate_to(chart_part, RT.CHART)
        return rId
304490
def add_lnTo(self, x, y):
        
        lnTo = self._add_lnTo()
        pt = lnTo._add_pt()
        pt.x, pt.y = x, y
        return lnTo
1363927
def setPoint(self, x, group, y):
        
        if x == -1:
            # silence window
            self.plot([0],[y], symbol='o')
        else:
            yindex = self.groups.index(group)
            xdata, ydata = self.lines[yindex].getData()
            if ydata is None:
                xdata = [x]
                ydata = [y]
            else:
                xdata = np.append(xdata, x)
                ydata = np.append(ydata, y)
            self.lines[yindex].setData(xdata, ydata)
6926
def move(self, x, y):
        
        if self.brush_on:
            for lx, ly in line(self.pos_x, self.pos_y, x, y):
                self.set(lx, ly)

        self.pos_x = x
        self.pos_y = y
692224
public void addPoint(float x, float y) {
    	if (hasVertex(x,y) && (!allowDups)) {
    		return;
    	}
    	
        ArrayList tempPoints = new ArrayList();
        for(int i=0;i<points.length;i++) {
            tempPoints.add(new Float(points[i]));
        }
        tempPoints.add(new Float(x));
        tempPoints.add(new Float(y));
        int length = tempPoints.size();
        points = new float[length];
        for(int i=0;i<length;i++) {
            points[i] = ((Float)tempPoints.get(i)).floatValue();
        }
        if(x > maxX) {
            maxX = x;
        }
        if(y > maxY) {
            maxY = y;
        }
        if(x < minX) {
            minX = x;
        }
        if(y < minY) {
            minY = y;
        }
        findCenter();
        calculateRadius();
        
        pointsDirty = true;
    }
16261
public void addItem(Point coordinates, Drawable item) {
	assertEDT();
	if (coordinates == null || item == null) {
	    throw new IllegalArgumentException("Coordinates and added item cannot be null");
	}
	log.trace("[addItem] New item added @ {}", coordinates);
	getPanelAt(coordinates).addModel(item);
	getPanelAt(coordinates).repaint();

    }
1128122
def add_xy(self, x, y):
        
        self.imodel.add_xy(self._pre_x(x), self._pre_y(y))
889364
def appendData(self, xdata, ydata, color='b', legendstr=None):
        
        item = self.plot(xdata, ydata, pen=color)
        if legendstr is not None:
            self.legend.addItem(item, legendstr)
        return item
234140
public int addPoint(double x, double y) {
		int pointIndex;

		if (this.pointCoordinates == null) {
			this.pointCoordinates = new double[] {x, y};
			this.partIndexes = null;
			pointIndex = 0;
		} else {
			double[] pts = new double[this.pointCoordinates.length + 2];
			System.arraycopy(this.pointCoordinates, 0, pts, 0, this.pointCoordinates.length);
			pointIndex = pts.length - 2;
			pts[pointIndex] = x;
			pts[pointIndex + 1] = y;
			this.pointCoordinates = pts;
			pts = null;

			pointIndex /= 2;
		}

		fireShapeChanged();
		fireElementChanged();

		return pointIndex;
	}
521861
public void addPoint(double x, double y) {
        numItems++;
        double xMinusMeanX = x - meanx;
        double yMinusMeanY = y - meany;
        sumsq += xMinusMeanX * yMinusMeanY * (numItems - 1) / numItems;
        meanx += xMinusMeanX / numItems;
        meany += yMinusMeanY / numItems;
    }
645436
def store_chart(x_pos, y_pos, dx, dy)   # :nodoc:
    record   = 0x1002     # Record identifier.
    length   = 0x0010     # Number of bytes to follow.
    # x_pos               # X pos of top left corner.
    # y_pos               # Y pos of top left corner.
    # dx                  # X size.
    # dy                  # Y size.

    header = [record, length].pack('vv')
    data   = [x_pos].pack('V')
    data  += [y_pos].pack('V')
    data  += [dx].pack('V')
    data  += [dy].pack('V')

    append(header, data)
  end
1244252
def addRasterPoints(self, xdata, repnum, plotname=None):
        
        if plotname is None:
            plotname = self.responsePlots.keys()[0]
        ydata = np.ones_like(xdata)*repnum
        self.responsePlots[plotname].appendData('raster', xdata, ydata)
1186733
function addPoint(type, x, y)
				{
					var rpt = new mxPoint(x, y);
					rpt.type = type;
					
					actual.push(rpt);
					var curr = (state.routedPoints != null) ? state.routedPoints[actual.length - 1] : null;
					
					return curr == null || curr.type != type || curr.x != x || curr.y != y;
				}
512693
def add_data_point(self, x, y, size, number_format=None):
        
        data_point = BubbleDataPoint(self, x, y, size, number_format)
        self.append(data_point)
        return data_point