Writing value in the cell of x+1 and y+1 position
        :param x: line index
        :param y: coll index
        :param value: value to be written
        :return:
356483
def write_cell(self, x, y, value):
        
        x += 1
        y += 1
        self._sheet.update_cell(x, y, value)
1062375
def point2pos(self, point):
        """"""
        row = self._vim.eval('byte2line({})'.format(point))
        col = self._vim.eval('{} - line2byte({})'.format(point, row))
        return (int(row), int(col))
1001725
def X(self, value):
        """"""
        if isinstance(value, (int, float,
                              long, types.NoneType)):
            self._x = value
741607
function sameValue(x, y) {
        if (x === y) {
            // 0 === -0, but they are not identical
            return x !== 0 || 1 / x === 1 / y;
        }

        // NaN !== NaN, but they are identical.
        // NaNs are the only non-reflexive value, i.e., if x !== x,
        // then x is a NaN.
        // isNaN is broken: it converts its argument to number, so
        // isNaN('foo') => true
        return x !== x && y !== y;
    }
767361
def set(self, x, y):
        
        x = normalize(x)
        y = normalize(y)
        col, row = get_pos(x, y)

        if type(self.chars[row][col]) != int:
            return

        self.chars[row][col] |= pixel_map[y % 4][x % 2]
699887
def write(self, *args, **kwargs):
        

        if args:
            kwargs = dict(zip(self.header, args))
        for header in kwargs:
            cell = kwargs[header]
            if not isinstance(cell, tuple):
                cell = (cell,)
            self.write_cell(self._row, self.header.index(header), *cell)
        self._row += 1
103395
def setCell(self, x, y, v):
        """"""
        self.cells[y][x] = v
1094701
def set_text(self, x, y, text):
        
        col, row = get_pos(x, y)

        for i,c in enumerate(text):
            self.chars[row][col+i] = c
289982
def text(self, x, y, text):
        
        for i, char in enumerate(text):
            self.point(x + i, y, char)
969164
def get_value_by_xy(self, x, y):
        
        if x < self.xMin or x > self.xMax or y < self.yMin or y > self.yMax:
            return None
            # raise ValueError("The x or y value must be within the Min and Max!")
        else:
            row = self.nRows - int(numpy.ceil((y - self.yMin) / self.dx))
            col = int(numpy.floor((x - self.xMin) / self.dx))
            value = self.data[row][col]
            if value == self.noDataValue:
                return None
            else:
                return value
561942
def prox_line(xy, step):
    """"""
    return np.concatenate((prox_xline(xy[0], step), prox_yline(xy[1], step)))
90855
public void setCorner(int index, double x, double y) {
        if (index <= 0) {
            this.x1 = x;
            this.y1 = y;
        } else if (index == 1) {
            this.x2 = x;
            this.y2 = y;
        } else if (index == 2) {
            this.x3 = x;
            this.y3 = y;
        } else if (index >= 3) {
            this.x4 = x;
            this.y4 = y;
        }
        calcG();
    }
104226
def set(self, x, y, value):
        
        xBase = int(x) * self.xScale
        yBase = int(y) * self.yScale
        for xOffset in range(self.xScale):
            for yOffset in range(self.yScale):
                self.data[yBase + yOffset, xBase + xOffset] = value
1136968
def compute_y(self, coefficients, num_x):
        
        y_vals = []

        for x in range(1, num_x + 1):
            y = sum([c * x ** i for i, c in enumerate(coefficients[::-1])])
            y_vals.append(y)

        return y_vals
797880
def setPosition(self, poiID, x, y):
        
        self._connection._beginMessage(
            tc.CMD_SET_POI_VARIABLE, tc.VAR_POSITION, poiID, 1 + 8 + 8)
        self._connection._string += struct.pack("!Bdd", tc.POSITION_2D, x, y)
        self._connection._sendExact()
85120
def y0(x, context=None):
    
    return _apply_function_in_current_context(
        BigFloat,
        mpfr.mpfr_y0,
        (BigFloat._implicit_convert(x),),
        context,
    )
815195
def add_value(self, value, index_point):
        """"""
        if index_point not in self.index:
            self.values.append(value)
            self.index.append(index_point)