set bend length

        :param x: new bend length to be assigned, [m]
        :return: None
960221
def setBendLength(self, x):
        
        if x != self.bend_length:
            self.bend_length = x
            self.refresh = True
245831
def concatenate_offset(self, X):
        
        return np.c_[np.ones((X.shape[0], 1)), X]
580428
def x(value, adjust = 1)
      return value if letter?

      width_ratio = value / PAGE_SIZES[:letter].width
      (width_ratio * @page_size.width) - adjust
    end
375160
def set_size(self, pt=None, px=None):
        

        assert (pt, px) != (None, None)

        if pt is not None:
            self.__init__(pt, self.font_name)
        else:
            self.__init__(self.px_to_pt(px), self.font_name)
765081
def set_xylims(self, limits, axes=None):
        
        if self.panel is not None:
            self.panel.set_xylims(limits, axes=axes)
1232832
def emg_var(X):
    '''  '''
    segment_width = X.shape[1]
    return np.sum(X * X, axis=1) / (segment_width - 1)
838181
def sizeHint(self, option, index):
        
        size = super(XTreeWidgetDelegate, self).sizeHint(option, index)
        
        tree = self.parent()
        item = tree.itemFromIndex(index)
        
        try:
            fixed_height = item.fixedHeight()
        except:
            fixed_height = 0
        
        if fixed_height:
            size.setHeight(fixed_height)
        
        return size
107152
def CBO_X(self, **kwargs):
        '''
        
        '''
        return (self.unstrained.CBO_X(**kwargs) +
                self.CBO_strain_shift(**kwargs))
316391
def set_position(self, x, y):
        
        self.attributes['x'] = str(x)
        self.attributes['y'] = str(y)
1153164
def xfrange(stop, start=None, step=1.0):
    
    if not step:
        raise ValueError('step must be non-zero')
    if start is None:
        start, stop = 0.0, stop * 1.0
    else:
        # swap when all args are used
        stop, start = start * 1.0, stop * 1.0
    cur = start
    while cur < stop:
        yield cur
        cur += step
1190656
def setNotches( self, notches ):
        
        self._rulerType = XChartRuler.Type.Custom
        self._notches = notches
107594
public final function setX(float $x): self {
        $this->coordinates[self::X] = $this->gf
                ->getPrecisionModel()
                ->makePrecise($x);
        return $this;
    }
473139
def configure(self, x0, axis):
        
        self.x0 = x0
        self.axis = axis
1065519
def setXlimits(self, lims):
        
        self.responseSignalPlot.setXlim(lims)
        self.stimSignalPlot.setXlim(lims)
89142
def qx(mt, x):
    
    if x < len(mt.qx):
        return mt.qx[x]
    else:
        return 0
509323
def X_length(self, new_window_length):
        """"""
        self.parent.value('window_length', new_window_length)
        self.parent.overview.update_position()
544424
def setxy(self):
        
        self._edge_inverter()
        self._detect_alignment_conflicts()
        inf = float('infinity')
        # initialize vertex coordinates attributes:
        for l in self.layers:
            for v in l:
                self.grx[v].root  = v
                self.grx[v].align = v
                self.grx[v].sink  = v
                self.grx[v].shift = inf
                self.grx[v].X     = None
                self.grx[v].x     = [0.0]*4
        curvh = self.dirvh # save current dirvh value
        for dirvh in xrange(4):
            self.dirvh = dirvh
            self._coord_vertical_alignment()
            self._coord_horizontal_compact()
        self.dirvh = curvh # restore it
        # vertical coordinate assigment of all nodes:
        Y = 0
        for l in self.layers:
            dY = max([v.view.h/2. for v in l])
            for v in l:
                vx = sorted(self.grx[v].x)
                # mean of the 2 medians out of the 4 x-coord computed above:
                avgm = (vx[1]+vx[2])/2.
                # final xy-coordinates :
                v.view.xy = (avgm,Y+dY)
            Y += 2*dY+self.yspace
        self._edge_inverter()