static ALWAYS_INLINE void deblock_edge_luma_c( pixel *pix, intptr_t xstride, int alpha, int beta, int8_t tc0 )
{
    int p2 = pix[-3*xstride];
    int p1 = pix[-2*xstride];
    int p0 = pix[-1*xstride];
    int q0 = pix[ 0*xstride];
    int q1 = pix[ 1*xstride];
    int q2 = pix[ 2*xstride];

    if( abs( p0 - q0 ) < alpha && abs( p1 - p0 ) < beta && abs( q1 - q0 ) < beta )
    {
        int tc = tc0;
        int delta;
        if( abs( p2 - p0 ) < beta )
        {
            if( tc0 )
                pix[-2*xstride] = p1 + x264_clip3( (( p2 + ((p0 + q0 + 1) >> 1)) >> 1) - p1, -tc0, tc0 );
            tc++;
        }
        if( abs( q2 - q0 ) < beta )
        {
            if( tc0 )
                pix[ 1*xstride] = q1 + x264_clip3( (( q2 + ((p0 + q0 + 1) >> 1)) >> 1) - q1, -tc0, tc0 );
            tc++;
        }

        delta = x264_clip3( (((q0 - p0 ) * 4) + (p1 - q1) + 4) >> 3, -tc, tc );
        pix[-1*xstride] = x264_clip_pixel( p0 + delta );    /* p0' */
        pix[ 0*xstride] = x264_clip_pixel( q0 - delta );    /* q0' */
    }
}

;-----------------------------------------------------------------------------
; void add8x8_idct8( uint8_t *p_dst, int16_t dct[8][8] )
;-----------------------------------------------------------------------------
%macro ADD8x8_IDCT8 0
cglobal add8x8_idct8, 2,2,11
    add r0, 4*FDEC_STRIDE
    pxor m7, m7
    TAIL_CALL .skip_prologue, 0
cglobal_label .skip_prologue
    SWAP 7, 9
    movdqa  m0, [r1+0x00]
    movdqa  m1, [r1+0x10]
    movdqa  m2, [r1+0x20]
    movdqa  m3, [r1+0x30]
    movdqa  m4, [r1+0x40]
    movdqa  m5, [r1+0x50]
    movdqa  m6, [r1+0x60]
    movdqa  m7, [r1+0x70]
    IDCT8_1D      w,0,1,2,3,4,5,6,7,8,10
    TRANSPOSE8x8W 0,1,2,3,4,5,6,7,8
    paddw         m0, [pw_32] ; rounding for the >>6 at the end
    IDCT8_1D      w,0,1,2,3,4,5,6,7,8,10
    DIFFx2 m0, m1, m8, m9, [r0-4*FDEC_STRIDE], [r0-3*FDEC_STRIDE]
    DIFFx2 m2, m3, m8, m9, [r0-2*FDEC_STRIDE], [r0-1*FDEC_STRIDE]
    DIFFx2 m4, m5, m8, m9, [r0+0*FDEC_STRIDE], [r0+1*FDEC_STRIDE]
    DIFFx2 m6, m7, m8, m9, [r0+2*FDEC_STRIDE], [r0+3*FDEC_STRIDE]
    STORE_IDCT m1, m3, m5, m7
    ret
%endmacro ; ADD8x8_IDCT8

double x = -p/2 + sqrt(p*p/4 - q)

CC>Ну т.е. ты в итоге со мной согласился что "Имена надо давать внятные"

clamp (+transform.invert (input ( y))

Scales are a convenient abstraction for a fundamental task in visualization: mapping a dimension of abstract data to a visual representation. Although most often used for position-encoding quantitative data, such as mapping a measurement in meters to a position in pixels for dots in a scatterplot, scales can represent virtually any visual encoding, such as diverging colors, stroke widths, or symbol size. Scales can also be used with virtually any type of data, such as named categorical data or discrete data that requires sensible breaks.

For continuous quantitative data, you typically want a linear scale. (For time series data, a time scale.) If the distribution calls for it, consider transforming data using a power or log scale. A quantize scale may aid differentiation by rounding continuous data to a fixed set of discrete values; similarly, a quantile scale computes quantiles from a sample population, and a threshold scale allows you to specify arbitrary breaks in continuous data.

For discrete ordinal (ordered) or categorical (unordered) data, an ordinal scale specifies an explicit mapping from a set of data values to a corresponding set of visual attributes (such as colors). The related band and point scales are useful for position-encoding ordinal data, such as bars in a bar chart or dots in an categorical scatterplot.

function scale(x) {
    return (output || (output = piecewise(domain.map(transform), range, interpolate)))(+transform(clamp(x)));
  }

  scale.invert = function(y) {
    return clamp(+transform.invert((input || (input = piecewise(range, domain.map(transform), interpolateNumber)))(y)));
  };

The following code is the fast inverse square root implementation from Quake III Arena, stripped of C preprocessor directives, but including the exact original comment text

float Q_rsqrt( float number )
{
    long i;
    float x2, y;
    const float threehalfs = 1.5F;

    x2 = number * 0.5F;
    y  = number;
    i  = * ( long * ) &y;                       // evil floating point bit level hacking
    i  = 0x5f3759df - ( i >> 1 );               // what the fuck? 
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
//    y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

    return y;
}

The algorithm was approximately four times faster than computing the square root with another method and calculating the reciprocal via floating-point division

function normalize(a, b) {
  return (b -= (a = +a))
      ? function(x) { return (x - a) / b; }
      : constant(b);
}

function bimap(domain, range, interpolate) {
  var d0 = domain[0], d1 = domain[1], r0 = range[0], r1 = range[1];
  if (d1 < d0) d0 = normalize(d1, d0), r0 = interpolate(r1, r0);
  else d0 = normalize(d0, d1), r0 = interpolate(r0, r1);
  return function(x) { return r0(d0(x)); };
}

export default function continuous(transform = identity) {
  var domain = unit,
      range = unit,
      interpolate = interpolateValue,
      clamp = identity,
      piecewise,
      output,
      input;

  function rescale() {
    piecewise = Math.min(domain.length, range.length) > 2 ? polymap : bimap;
    output = input = null;
    return scale;
  }

Когда-то жил мастер-программист, который писал неструктурированные программы. Ученик, пытаясь подражать ему, тоже стал писать неструктурированные программы. Когда ученик просил мастера оценить его труд, тот раскритиковал его за написание неструктурированных программ: "Что подходит мастеру, не подходит ученику. Ты должен постичь Дао, прежде чем переступить через структуру"

    for (shft = 8; shft >= 0; shft -=8) {
        for (i = 0; i < npixels && cc > 0; ) {
            if (*bp >= 128) {        /* run */
                if( cc < 2 )
                    break;
                rc = *bp++ + (2-128);
                b = (int16_t)(*bp++ << shft);
                cc -= 2;
                while (rc-- && i < npixels)
                    tp[i++] |= b;
            } else {            /* non-run */
                rc = *bp++;        /* nul is noop */
                while (--cc && rc-- && i < npixels)
                    tp[i++] |= (int16_t)*bp++ << shft;
            }
        }
        if (i != npixels) {

SA>export default function continuous(transform = identity) {
SA>  var domain = unit,
SA>      range = unit,
SA>      interpolate = interpolateValue,
SA>      clamp = identity,
SA>      piecewise,
SA>      output,
SA>      input;

SA>  function rescale() {
SA>    piecewise = Math.min(domain.length, range.length) > 2 ? polymap : bimap;
SA>    output = input = null;
SA>    return scale;
SA>  }
SA>

function scale(x) {
    return (output || (output = piecewise(domain.map(transform), range, interpolate)))(+transform(clamp(x)));
  }

  scale.invert = function(y) {
    return clamp(+transform.invert((input || (input = piecewise(range, domain.map(transform), interpolateNumber)))(y)));
  };

    x = *s &~ *m;
    if (x) {
        if (x & SYNCHRONOUS_MASK)
            x &= SYNCHRONOUS_MASK;
        sig = ffz(~x) + 1;
        return sig;
    }

    switch (_NSIG_WORDS) {
    default:
        for (i = 1; i < _NSIG_WORDS; ++i) {
            x = *++s &~ *++m;
            if (!x)
                continue;
            sig = ffz(~x) + i*_NSIG_BPW + 1;
            break;
        }
        break;

    case 2:
        x = s[1] &~ m[1];
        if (!x)
            break;
        sig = ffz(~x) + _NSIG_BPW + 1;
        break;

SA>Я попытался выяснить, как такое вообще попало в мастер, в ответ услышал — "Этот человек выше чем сеньор, в подробном ревью не нуждается".

Building a better computational medium. Founder @observablehq. Creator @d3. Former @nytgraphics. Pronounced BOSS-tock.

  public login({ username, password }: Authenticate): Promise<any> {
    username = username.toLowerCase();
    return new Promise((resolve, reject) => {
      return this.cognitoService
        .authenticate(username, password)
        .then(result => {
          let foundTenant = false;
          const tenants: Array<Tenant> = [];
          if (result.idToken.payload['custom:PlatformTenantId']) {
            const tenantDTO = JSON.parse(result.idToken.payload['custom:PlatformTenantId']);

            const tenantArray = tenantDTO.t;
            tenantArray.map((_, index) => {
              tenants.push({ id: tenantArray[index].id, name: '-' });
              foundTenant = true;
            });
          }

          const userName = result.idToken.payload.name ? result.idToken.payload.name : result.idToken.payload.email;
          const userEmail = result.idToken.payload.email;
          const userPhone = result.idToken.payload.phone_number ? result.idToken.payload.phone_number : '-';
          const exp = result.accessToken.payload.exp;

          const user: User = {
            name: userName,
            email: userEmail,
            phone: userPhone,
            tenants,
            selectedTenant: tenants[0],
            accessToken: result.getAccessToken().getJwtToken(),
            accessTokenExpiryTime: exp,
            userProfile: null
          };

          if (foundTenant) {
            return this.userService.userProfile(user).subscribe(
              up => {
                user.userProfile = up;
                // set the user in the local storage
                userUtil.set(user);
                // set the user in the service
                this.setUser(user);
                resolve(user);
              },
              () => {
                resolve(user);
              }
            );
          } else {
            resolve(user);
          }
        })
        .catch(err => {
          reject(err);
        });
    });
  }

clamp(+transform.invert((input || (input = piecewise(range, domain.map(transform), interpolateNumber)))(y)));

// pseudocode
if (!input)
    input = piecewise (range, domain.map (transform), interpolateNumber);

return clamp (+transform.invert (input, y))

Я жертва цепи несчастных случайностей.
Как и все мы.

  uint32 cur_hashnr;
  const uchar *cur_key;
  size_t cur_keylen;
  LF_SLIST *link;

retry:
  cursor->prev = head;
  do /* PTR() isn't necessary below, head is a dummy node */
  {
    cursor->curr = (LF_SLIST *)(*cursor->prev);
    lf_pin(pins, 1, cursor->curr);
  } while (*cursor->prev != cursor->curr && LF_BACKOFF);
  for (;;) {
    if (unlikely(!cursor->curr)) {
      return 0; /* end of the list */
    }
    do {
      /* QQ: XXX or goto retry ? */
      link = cursor->curr->link.load();
      cursor->next = PTR(link);
      lf_pin(pins, 0, cursor->next);
    } while (link != cursor->curr->link && LF_BACKOFF);
    cur_hashnr = cursor->curr->hashnr;
    cur_key = cursor->curr->key;
    cur_keylen = cursor->curr->keylen;
    if (*cursor->prev != cursor->curr) {
      (void)LF_BACKOFF;
      goto retry;
    }

for (;;)
    {
        int            ret;

        /* Fetch next row if we didn't already */
        if (TupIsNull(agg_row_slot))
        {
            if (!window_gettupleslot(agg_winobj, winstate->aggregatedupto,
                                     agg_row_slot))
                break;            /* must be end of partition */
        }

        /*
         * Exit loop if no more rows can be in frame.  Skip aggregation if
         * current row is not in frame but there might be more in the frame.
         */
        ret = row_is_in_frame(winstate, winstate->aggregatedupto, agg_row_slot);
        if (ret < 0)
            break;
        if (ret == 0)
            goto next_tuple;

        /* Set tuple context for evaluation of aggregate arguments */
        winstate->tmpcontext->ecxt_outertuple = agg_row_slot;

        [... тут еще строк 10 кода]

next_tuple:

1. Oracle
2. MySQL
3. Microsoft SQL Server
4. PostgreSQL
5. MongoDB