How to use floatToIndex method in fast-check-monorepo

Best JavaScript code snippet using fast-check-monorepo

math.ts

Source:math.ts

...8export const MAX_VALUE_32 = 2 ** 127 * (1 + (2 ** 23 - 1) / 2 ** 23)9/** @internal */10export const EPSILON_32 = 2 ** -2311/** @internal */12const INDEX_POSITIVE_INFINITY_32 = 2139095040 // floatToIndex(MAX_VALUE_32) + 1;13/** @internal */14const INDEX_NEGATIVE_INFINITY_32 = -2139095041 // floatToIndex(-MAX_VALUE_32) - 115export function safeFloatToIndex(f: number, label: string): I.IO<unknown, never, number> {16  const conversionTrick = 'you can convert any double to a 32-bit float by using `new Float32Array([myDouble])[0]`'17  const errorMessage    = 'fc.floatNext constraints.' + label + ' must be a 32-bit float - ' + conversionTrick18  if (Number.isNaN(f) || (Number.isFinite(f) && (f < -MAX_VALUE_32 || f > MAX_VALUE_32))) {19    return I.die(new Error(errorMessage))20  }21  const index = floatToIndex(f)22  if (!Number.isInteger(index)) {23    return I.die(new Error(errorMessage))24  }25  return I.succeed(index)26}27export function decomposeFloat(f: number): { exponent: number, significand: number } {28  // 1 => significand 0b1   - exponent 1 (will be preferred)29  //   => significand 0b0.1 - exponent 230  const maxSignificand = 1 + (2 ** 23 - 1) / 2 ** 2331  for (let exponent = -126; exponent !== 128; ++exponent) {32    const powExponent    = 2 ** exponent33    const maxForExponent = maxSignificand * powExponent34    if (Math.abs(f) <= maxForExponent) {35      return { exponent, significand: f / powExponent }36    }37  }38  return { exponent: Number.NaN, significand: Number.NaN }39}40export function floatToIndex(f: number): number {41  if (f === Number.POSITIVE_INFINITY) {42    return INDEX_POSITIVE_INFINITY_3243  }44  if (f === Number.NEGATIVE_INFINITY) {45    return INDEX_NEGATIVE_INFINITY_3246  }47  const { exponent, significand } = decomposeFloat(f)48  if (Number.isNaN(exponent) || Number.isNaN(significand) || !Number.isInteger(significand * 0x800000)) {49    return Number.NaN50  }51  if (f > 0 || (f === 0 && 1 / f === Number.POSITIVE_INFINITY)) {52    return indexInFloatFromDecomp(exponent, significand)53  } else {54    return -indexInFloatFromDecomp(exponent, -significand) - 1...

FloatHelpers.spec.ts

Source:FloatHelpers.spec.ts

...44  });45});46describe('floatToIndex', () => {47  it('should properly compute indexes', () => {48    expect(floatToIndex(0)).toBe(0);49    expect(floatToIndex(MIN_VALUE_32)).toBe(1);50    expect(floatToIndex(2 * MIN_VALUE_32)).toBe(2);51    expect(floatToIndex(3 * MIN_VALUE_32)).toBe(3);52    // EPSILON_32 === 1. * 2**-23 --> m = 1, e = -2353    // index(EPSILON_32) = 2**24 + (-23 - (-126) -1) * 2**2354    expect(floatToIndex(EPSILON_32)).toBe(872415232);55    // index(1 - EPSILON_32 / 2) = index(1) - 156    expect(floatToIndex(1 - EPSILON_32 / 2)).toEqual(1065353215);57    // 1 === 1. * 2**0 --> m = 1, e = 058    // index(1) = 2**24 + (0 - (-126) -1) * 2**2359    expect(floatToIndex(1)).toEqual(1065353216);60    // index(1 + EPSILON_32) = index(1) + 161    expect(floatToIndex(1 + EPSILON_32)).toEqual(1065353217);62    // index(2 - EPSILON_32) = index(2) - 1 = index(1 + (2 ** 23 - 1) * EPSILON_32)63    expect(floatToIndex(2 - EPSILON_32)).toEqual(1073741823);64    // 1 === 1. * 2**1 --> m = 1, e = 165    // index(2) = index(1) + 2**2366    expect(floatToIndex(2)).toEqual(1073741824);67    expect(floatToIndex(MAX_VALUE_32)).toBe(2139095039);68  });69  it('should properly compute negative indexes', () => {70    expect(floatToIndex(-0)).toEqual(-1);71    expect(floatToIndex(-MIN_VALUE_32)).toBe(-2);72    expect(floatToIndex(-MAX_VALUE_32)).toBe(-2139095040);73  });74  it('should properly compute indexes for infinity', () => {75    expect(floatToIndex(Number.NEGATIVE_INFINITY)).toBe(floatToIndex(-MAX_VALUE_32) - 1);76    expect(floatToIndex(Number.POSITIVE_INFINITY)).toBe(floatToIndex(MAX_VALUE_32) + 1);77  });78  it('should be able to infer index for negative float from the positive one', () => {79    fc.assert(80      fc.property(float32raw(), (f) => {81        // Arrange82        fc.pre(isNotNaN32bits(f));83        const posD = f > 0 || 1 / f > 0 ? f : -f;84        // Act85        const indexPos = floatToIndex(posD);86        const indexNeg = floatToIndex(-posD);87        // Assert88        expect(indexNeg).toEqual(-indexPos - 1);89      })90    );91  });92  it('should return index +1 for the successor of a given float', () => {93    fc.assert(94      fc.property(95        fc.integer({ min: -126, max: +127 }),96        fc.integer({ min: 0, max: 2 ** 24 - 1 }),97        (exponent, rescaledSignificand) => {98          // Arrange99          fc.pre(exponent === -126 || rescaledSignificand >= 2 ** 23); // valid100          fc.pre(exponent !== 127 || rescaledSignificand !== 2 ** 24 - 1); // not max101          const current = rescaledSignificand * EPSILON_32 * 2 ** exponent;102          const next = (rescaledSignificand + 1) * EPSILON_32 * 2 ** exponent;103          // Act / Assert104          expect(floatToIndex(next)).toEqual(floatToIndex(current) + 1);105        }106      )107    );108  });109  it('should preserve ordering between two floats', () => {110    fc.assert(111      fc.property(float32raw(), float32raw(), (fa32, fb32) => {112        // Arrange113        fc.pre(isNotNaN32bits(fa32) && isNotNaN32bits(fb32));114        // Act / Assert115        if (isStrictlySmaller(fa32, fb32)) expect(floatToIndex(fa32)).toBeLessThan(floatToIndex(fb32));116        else expect(floatToIndex(fa32)).toBeGreaterThanOrEqual(floatToIndex(fb32));117      })118    );119  });120});121describe('indexToFloat', () => {122  it('should properly find floats corresponding to well-known values', () => {123    expect(indexToFloat(-2139095041)).toBe(Number.NEGATIVE_INFINITY);124    expect(indexToFloat(-2139095040)).toBe(-MAX_VALUE_32);125    expect(indexToFloat(-1)).toBe(-0);126    expect(indexToFloat(0)).toBe(0);127    expect(indexToFloat(872415232)).toBe(EPSILON_32);128    expect(indexToFloat(2139095039)).toBe(MAX_VALUE_32);129    expect(indexToFloat(2139095040)).toBe(Number.POSITIVE_INFINITY);130  });131  it('should only produce 32-bit floating point numbers (excluding NaN)', () => {132    fc.assert(133      fc.property(fc.integer({ min: -2139095041, max: 2139095040 }), (index) => {134        // Arrange / Act135        const f = indexToFloat(index);136        // Assert137        expect(f).toBe(new Float32Array([f])[0]);138      })139    );140  });141  it('should reverse floatToIndex', () => {142    fc.assert(143      fc.property(float32raw(), (f32) => {144        // Arrange145        fc.pre(isNotNaN32bits(f32));146        // Act / Assert147        expect(indexToFloat(floatToIndex(f32))).toBe(f32);148      })149    );150  });151  it('should be reversed by floatToIndex', () => {152    fc.assert(153      fc.property(fc.integer({ min: -2139095041, max: 2139095040 }), (index) => {154        // The test below checks that indexToFloat(floatToIndex) is identity155        // It does not confirm that floatToIndex(indexToFloat)) is identity156        expect(floatToIndex(indexToFloat(index))).toBe(index);157      })158    );159  });...

float.ts

Source:float.ts

...51    // Number.NaN does not have any associated index in the current implementation52    // Finite values outside of the 32-bit range for floats cannot be 32-bit floats53    throw new Error(errorMessage);54  }55  const index = floatToIndex(f);56  if (!safeNumberIsInteger(index)) {57    // Index not being an integer means that original value was not a valid 32-bit float58    throw new Error(errorMessage);59  }60  return index;61}62/** @internal */63function unmapperFloatToIndex(value: unknown): number {64  if (typeof value !== 'number') throw new Error('Unsupported type');65  return floatToIndex(value);66}67/**68 * For 32-bit floating point numbers:69 * - sign: 1 bit70 * - significand: 23 bits71 * - exponent: 8 bits72 *73 * The smallest non-zero value (in absolute value) that can be represented by such float is: 2 ** -126 * 2 ** -23.74 * And the largest one is: 2 ** 127 * (1 + (2 ** 23 - 1) / 2 ** 23).75 *76 * @param constraints - Constraints to apply when building instances (since 2.8.0)77 *78 * @remarks Since 0.0.679 * @public80 */81export function float(constraints: FloatConstraints = {}): Arbitrary<number> {82  const {83    noDefaultInfinity = false,84    noNaN = false,85    min = noDefaultInfinity ? -MAX_VALUE_32 : safeNegativeInfinity,86    max = noDefaultInfinity ? MAX_VALUE_32 : safePositiveInfinity,87  } = constraints;88  const minIndex = safeFloatToIndex(min, 'min');89  const maxIndex = safeFloatToIndex(max, 'max');90  if (minIndex > maxIndex) {91    // Comparing min and max might be problematic in case min=+0 and max=-092    // For that reason, we prefer to compare computed index to be safer93    throw new Error('fc.float constraints.min must be smaller or equal to constraints.max');94  }95  if (noNaN) {96    return integer({ min: minIndex, max: maxIndex }).map(indexToFloat, unmapperFloatToIndex);97  }98  // In case maxIndex > 0 or in other words max > 0,99  //   values will be [min, ..., +0, ..., max, NaN]100  //               or [min, ..., max, NaN] if min > +0101  // Otherwise,102  //   values will be [NaN, min, ..., max] with max <= +0103  const minIndexWithNaN = maxIndex > 0 ? minIndex : minIndex - 1;104  const maxIndexWithNaN = maxIndex > 0 ? maxIndex + 1 : maxIndex;105  return integer({ min: minIndexWithNaN, max: maxIndexWithNaN }).map(106    (index) => {107      if (index > maxIndex || index < minIndex) return safeNaN;108      else return indexToFloat(index);109    },110    (value) => {111      if (typeof value !== 'number') throw new Error('Unsupported type');112      if (safeNumberIsNaN(value)) return maxIndex !== maxIndexWithNaN ? maxIndexWithNaN : minIndexWithNaN;113      return floatToIndex(value);114    }115  );...

Using AI Code Generation

1const { floatToIndex } = require('fast-check');2const floatToIndex = require('fast-check').floatToIndex;3const { floatToIndex } = require('fast-check');4const floatToIndex = require('fast-check').floatToIndex;5I have a problem with my code. I have a function that takes a string as an argument and returns a string with the first letter of each word capitalized. I want to use the .map() method to return a new array, but I'm not sure how to do it. Here's my code:6function titleCase(str) {7  let newStr = str.split(' ');8  return newStr.map(function(newStr) {9    return newStr[0].toUpperCase() + newStr.slice(1);10  }).join(' ');11}12titleCase("I'm a little tea pot");13  {

Using AI Code Generation

1const fc = require('fast-check');2const { floatToIndex } = require('fast-check/lib/utils/FloatArray');3const fc = require('fast-check');4const { floatToIndex } = require('fast-check/lib/utils/FloatArray');5const fc = require('fast-check');6const { floatToIndex } = require('fast-check/lib/utils/FloatArray');7const fc = require('fast-check');8const { floatToIndex } = require('fast-check/lib/utils/FloatArray');9const fc = require('fast-check');10const { floatToIndex } = require('fast-check/lib/utils/FloatArray');11const fc = require('fast-check');12const { floatToIndex } = require('fast-check/lib/utils/FloatArray');13const fc = require('fast-check');14const { floatToIndex } = require('fast-check/lib/utils/FloatArray');15const fc = require('fast-check');16const { floatToIndex } = require('fast-check/lib/utils/FloatArray');17const fc = require('fast-check');18const { floatToIndex } = require('fast-check/lib/utils/FloatArray');19const fc = require('fast-check');20const { floatToIndex } = require('fast-check/lib/utils/FloatArray');21const fc = require('fast-check');22const { floatToIndex } = require('fast-check/lib/utils/FloatArray');23const fc = require('fast-check');24const { floatToIndex } = require('fast-check/lib/utils/FloatArray');25const fc = require('fast-check');26const { floatToIndex } = require('fast

Using AI Code Generation

1const { floatToIndex } = require('fast-check');2const index = floatToIndex(1.1, 0, 2, 10);3const { floatToIndex } = require('fast-check');4const index = floatToIndex(1.1, 0, 2, 10);5  throw err;6    at Function.Module._resolveFilename (internal/modules/cjs/loader.js:880:15)7    at Function.Module._load (internal/modules/cjs/loader.js:725:27)8    at Module.require (internal/modules/cjs/loader.js:952:19)9    at require (internal/modules/cjs/helpers.js:88:18)10    at Object.<anonymous> (/Users/.../test3.js:1:15)11    at Module._compile (internal/modules/cjs/loader.js:1063:30)12    at Object.Module._extensions..js (internal/modules/cjs/loader.js:1092:10)13    at Module.load (internal/modules/cjs/loader.js:928:32)14    at Function.Module._load (internal/modules/cjs/loader.js:769:14)15    at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:72:12) {16}

Using AI Code Generation

1import {floatToIndex} from 'fast-check'2const index = floatToIndex(0.5, 1, 1000)3console.log(index)4import {indexToFloat} from 'fast-check'5const float = indexToFloat(500, 1, 1000)6console.log(float)7import {floatToIndex, indexToFloat} from 'fast-check'8const index = floatToIndex(0.5, 1, 1000)9const float = indexToFloat(index, 1, 1000)10console.log(float)11import {floatToIndex, indexToFloat} from 'fast-check'12const float = indexToFloat(floatToIndex(0.5, 1, 1000), 1, 1000)13console.log(float)14import {floatToIndex, indexToFloat} from 'fast-check'15const float = indexToFloat(floatToIndex(0.5, 1, 1000), 1, 1000)16console.log(float)17import {floatToIndex, indexToFloat} from '

Using AI Code Generation

1const fc = require('fast-check');2const floatToIndex = require('fast-check-monorepo').floatToIndex;3const random = fc.random();4const index = floatToIndex(random.nextFloat(), 100);5console.log(random.nextFloat() + " " + index);6console.log(index + " " + random.nextFloat());7console.log(random.nextFloat() + " " + index);8const fc = require('fast-check');9const floatToIndex = require('fast-check-monorepo').floatToIndex;10const random = fc.random();11const index = floatToIndex(random.nextFloat(), 100);12console.log(random.nextFloat() + " " + index);13console.log(index + " " + random.nextFloat());14console.log(random.nextFloat() + " " + index);15const fc = require('fast-check');

Using AI Code Generation

1const fc = require("fast-check");2const { floatToIndex } = require("fast-check-monorepo");3const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];4const float = fc.float({min: 0, max: 9});5fc.assert(6  fc.property(float, (float) => {7    const index = floatToIndex(float);8    return array[index] === float;9  })10);11const fc = require("fast-check");12const { floatToIndex } = require("fast-check-monorepo");13const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];14const float = fc.float({min: 0, max: 9});15fc.assert(16  fc.property(float, (float) => {17    const index = floatToIndex(float);18    return array[index] === float;19  })20);21const fc = require("fast-check");22const { floatToIndex } = require("fast-check-monorepo");23const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];24const float = fc.float({min: 0, max: 9});25fc.assert(26  fc.property(float, (float) => {27    const index = floatToIndex(float);28    return array[index] === float;29  })30);

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.