Lines Matching refs:left
42 all the symbols are used, there are exactly zero possible bit patterns left
126 left: number of available bit patterns at length len
132 left: 2..syms - 1, but only the evens (so syms == 8 -> 2, 4, 6)
135 syms == 2 is not saved since that immediately leads to a single code. left
137 the current length, which is double the number at the previous length. left
138 ends at syms-1 since left == syms immediately results in a single code.
139 (left > sym is not allowed since that would result in an incomplete code.)
156 to the num[] array as described above for the (syms, left, len) triplet.
237 local inline size_t map(int syms, int left, int len) {
239 (left >> 1) - 1) * (g.max - 1) +
258 // through max inclusive, coding syms symbols, with left bit patterns of length
261 local big_t count(int syms, int left, int len) {
263 if (syms == left)
267 assert(syms > left && left > 0 && len < g.max);
270 size_t index = map(syms, left, len);
277 int least = (left << 1) - syms;
283 // no limit to the code length, this would become: most = left - 1)
284 int most = (((code_t)left << (g.max - len)) - syms) /
290 got = count(syms - use, (left - use) << 1, len + 1);
305 // bit vector to indicate visiting this state. Each (syms,len,left) state has a
308 local int been_here(int syms, int left, int len, int mem, int rem) {
309 // point to vector for (syms,left,len), bit in vector for (mem,rem)
310 size_t index = map(syms, left, len);
357 // Examine all possible codes from the given node (syms, len, left). Compute
361 local void examine(int syms, int left, int len, int mem, int rem) {
363 if (syms == left) {
365 g.code[len] = left;
368 while (rem < left) {
369 left -= rem;
373 assert(rem == left);
386 left = 1 << g.max;
389 left -= g.code[bits];
390 assert((left & 1) == 0);
391 left >>= 1;
396 syms, g.root + 1, ((1 << g.root) - left) << 1);
409 if (been_here(syms, left, len, mem, rem))
414 int least = (left << 1) - syms;
420 // no limit to the code length, this would become: most = left - 1)
421 int most = (((code_t)left << (g.max - len)) - syms) /
436 examine(syms - use, (left - use) << 1, len + 1,
450 // intermediate code states (syms, left, len). For each completed code,
464 for (int left = 2; left < n; left += 2) {
467 size_t index = map(n, left, g.root + 1);
469 examine(n, left, g.root + 1, 1 << g.root, 0);
473 if (g.num[index - 1] && n <= left << 1)
474 examine((n - left) << 1, (n - left) << 1, g.root + 1,