if h<=360:
            h=360
            self.resize(w,h)
        if w<=640:
            w = 640
            self.resize(w, h)
10510
def resizeEvent(self, evt=None):

        w = self.width()
        h = self.height()
        '''
        
        '''

        step = (w * 94 / 100) / 5
        foot = h * 3 / 48
30707
function(w) {
    if(w.length === 0) { return {}; } // ... ;s
    var maxv = w[0];
    var minv = w[0];
    var maxi = 0;
    var mini = 0;
    var n = w.length;
    for(var i=1;i<n;i++) {
      if(w[i] > maxv) { maxv = w[i]; maxi = i; } 
      if(w[i] < minv) { minv = w[i]; mini = i; } 
    }
    return {maxi: maxi, maxv: maxv, mini: mini, minv: minv, dv:maxv-minv};
  }
792667
@Override protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    super.onSizeChanged(w, h, oldw, oldh);

    setupBounds(w, h);
    setupPaints();
    invalidate();
  }
759525
function resize(w, h) {
         // parent consctructor, resize camera rect
         this._super(me.Renderable, "resize", [w, h]); // disable damping while resizing


         this.smoothFollow = false; // update bounds

         var level = me.levelDirector.getCurrentLevel();
         this.setBounds(0, 0, Math.max(w, level ? level.width : 0), Math.max(h, level ? level.height : 0)); // reset everthing

         this.setDeadzone(w / 6, h / 6);
         this.update();
         this.smoothFollow = true;
         me.event.publish(me.event.VIEWPORT_ONRESIZE, [this.width, this.height]);
         return this;
       }
765861
function fixHues(h1, h2) {
        var diff = Math.abs(NAMED_HUE_INDEX[h1] - NAMED_HUE_INDEX[h2]);
        if (diff !== 1 && diff !== 5) {
            return false;
        }

        var result = {
            h1: h1,
            h2: h2
        };
        if (h1 === 0 && h2 === 300) {
            result.h1 = 360;
        } else if (h2 === 0 && h1 === 300) {
            result.h2 = 360;
        }
        return result;
    }
972257
function resize(w, h) {
         this._super(me.Renderable, "resize", [this.repeatX ? Infinity : w, this.repeatY ? Infinity : h]);
       }
1086590
def _set_hwxy_attrs(attr):
        
        bbox = attr['bbox']
        attr['x0'] = bbox[0]
        attr['x1'] = bbox[2]
        attr['y0'] = bbox[1]
        attr['y1'] = bbox[3]
        attr['height'] = attr['y1'] - attr['y0']
        attr['width'] = attr['x1'] - attr['x0']
        return attr
1150933
def on_window_height_value_changed(self, hscale):
        
        val = hscale.get_value()
        self.settings.general.set_int('window-height', int(val))
590467
def resize(self, newWidth = 0, newHeight = 0):
        
        self.height = newHeight
        self.width = newWidth
394880
public final void resize(float width, float height) {
        if (width < 0) {
            width = 0;
        }
        if (height < 0) {
            height = 0;
        }
        if (mWidth != width || mHeight != height) {
            mWidth = width;
            mHeight = height;
            onResize(width, height);
        }
    }
571021
private static double limitHprime(double hPrime) {
        hPrime /= 360.0;
        final double limited = 360.0 * (hPrime - floor(hPrime));

        if (limited < -180.0) {
            return limited + 360.0;
        } else if (limited > 180.0) {
            return limited - 360.0;
        } else {
            return limited;
        }
    }
529164
private void updateErrorContainerSize(double w, double errorContainerHeight) {
        errorContainerClip.setWidth(w);
        errorContainerClip.setHeight(errorContainerHeight);
        resize(w, errorContainerHeight);
    }
479625
def resize(self, new_size):
        
        if new_size == len(self):
            return
        else:
            self._saved = LimitedSizeDict(size_limit=2**5)
            new_arr = zeros(new_size, dtype=self.dtype)
            if len(self) <= new_size:
                new_arr[0:len(self)] = self
            else:
                new_arr[:] = self[0:new_size]
                
            self._data = new_arr._data
111177
def resize(self):
        
        yext = self.m - len(self.y)
        xext = self.n - len(self.x)
        if yext > 0:
            yzeros = zeros(yext, 1)
            yones = ones(yext, 1)
            self.y = matrix([self.y, yzeros], (self.m, 1), 'd')
            self.g = matrix([self.g, yzeros], (self.m, 1), 'd')
            self.uy = matrix([self.uy, yones], (self.m, 1), 'd')
            self.zymin = matrix([self.zymin, yones], (self.m, 1), 'd')
            self.zymax = matrix([self.zymax, yones], (self.m, 1), 'd')
        if xext > 0:
            xzeros = zeros(xext, 1)
            xones = ones(xext, 1)
            self.x = matrix([self.x, xzeros], (self.n, 1), 'd')
            self.f = matrix([self.f, xzeros], (self.n, 1), 'd')
            self.ux = matrix([self.ux, xones], (self.n, 1), 'd')
            self.zxmin = matrix([self.zxmin, xones], (self.n, 1), 'd')
            self.zxmax = matrix([self.zxmax, xones], (self.n, 1), 'd')
3051
protected void adjustHomographSign( AssociatedPair p , DMatrixRMaj H ) {
		double val = GeometryMath_F64.innerProd(p.p2, H, p.p1);

		if( val < 0 )
			CommonOps_DDRM.scale(-1, H);
	}
1270758
def HH(n):
    """"""
    if (n<=0):return Context('1')
    else:
        LL1=LL(n-1)
        HH1=HH(n-1)
        r1 = C1(3**(n-1),2**(n-1)) - LL1 - HH1
        r2 = HH1 - HH1 - HH1
        return r1 + r2
1000961
def bsp_resize(node: tcod.bsp.BSP, x: int, y: int, w: int, h: int) -> None:
    
    node.x = x
    node.y = y
    node.width = w
    node.height = h