Bitbybit Docs
    Preparing search index...

    Class Logic

    बूलियन और निर्णय: मानों की तुलना करना, बूलियन पलटना, थ्रेशहोल्ड द्वारा संख्याओं की सूचियों को बूलियन की सूचियों में बदलना, यादृच्छिक बूलियन निकालना, और किसी मान को गेट करना ताकि वह केवल शर्त पूरी होने पर पास हो। थ्रेशहोल्ड मेथड यह तय करने का सामान्य तरीका हैं कि पैटर्न के कौन-से आइटम को कोई फ़ीचर मिलता है और कौन-से को नहीं।

    Index

    Constructors

    create

    • बूलियन को बिना बदले आगे बढ़ाता है, ताकि मान को नाम दिया और फिर से उपयोग किया जा सके।

      उदाहरण: true -> true

      Parameters

      Returns boolean

      वही बूलियन

    • यादृच्छिक बूलियन की सूची निकालता है, हर एक दी गई संभावना के साथ true।

      उदाहरण: लंबाई 5 trueThreshold 0.7 के साथ -> शायद [true, true, false, true, true]

      Parameters

      • inputs: RandomBooleansDto

        कितने बूलियन निकालने हैं और true की प्रायिकता

      Returns boolean[]

      यादृच्छिक बूलियन

      const flags = bitbybit.logic.randomBooleans({ length: 5, trueThreshold: 0.7 });
      
    • संख्याओं को दो सीमाओं के बीच यादृच्छिक मिश्रण के साथ बूलियन में बदलता है।

      पहली सीमा से नीचे संख्या हमेशा true है, दूसरी से ऊपर हमेशा false; बीच में true की संभावना एक से दूसरी तक चरणों में गिरती है, ताकि पैटर्न तीखे स्विच के बजाय धीरे-धीरे मिटे। उदाहरण: [0.1, 0.9] सीमाओं 0.3 और 0.7 के साथ -> [true, false]

      Parameters

      • inputs: TwoThresholdRandomGradientDto

        संख्याएँ, दो थ्रेशहोल्ड और फ़ेड में कितने स्टेप हैं

      Returns boolean[]

      प्रत्येक संख्या के लिए एक बूलियन

      const fade = bitbybit.logic.twoThresholdRandomGradient({
      numbers: [0.1, 0.4, 0.6, 0.9],
      thresholdTotalTrue: 0.3,
      thresholdTotalFalse: 0.7,
      nrLevels: 10,
      });
    • संख्याओं को बूलियन में बदलता है: सीमा से नीचे true, उस पर या ऊपर false।

      inverse हर परिणाम पलटता है। उदाहरण: [0.3, 0.7, 0.5] सीमा 0.6 के साथ -> [true, false, true]

      Parameters

      • inputs: ThresholdBooleanListDto

        संख्याएँ, थ्रेशहोल्ड और क्या परिणाम को पलटना है

      Returns boolean[]

      प्रत्येक संख्या के लिए एक बूलियन

      const below = bitbybit.logic.thresholdBooleanList({ numbers: [0.3, 0.7, 0.5], threshold: 0.6, inverse: false });
      
    • संख्याओं को बूलियन में बदलता है: जब संख्या दी गई रेंज में से किसी के भीतर पड़े तब true, अन्यथा false।

      हर रेंज [min, max] है जिसमें दोनों सिरे शामिल हैं; inverse हर परिणाम पलटता है। उदाहरण: [0.2, 0.5, 0.8] रेंज [[0.3, 0.6], [0.7, 0.9]] के साथ -> [false, true, true]

      Parameters

      • inputs: ThresholdGapsBooleanListDto

        संख्याएँ, रेंज और क्या परिणाम को पलटना है

      Returns boolean[]

      प्रत्येक संख्या के लिए एक बूलियन

      const inside = bitbybit.logic.thresholdGapsBooleanList({
      numbers: [0.2, 0.5, 0.8],
      gapThresholds: [[0.3, 0.6], [0.7, 0.9]],
      inverse: false,
      });

    edit

    • बूलियन को पलटता है: true false बन जाता है और false true।

      उदाहरण: true -> false

      Parameters

      Returns boolean

      विपरीत बूलियन

    • सूची के हर बूलियन को पलटता है।

      उदाहरण: [true, false, true] -> [false, true, false]

      Parameters

      Returns boolean[]

      पलटे गए बूलियन, उसी क्रम में

    operations

    • दो मानों की एक ऑपरेटर से तुलना करता है: कम, कम या बराबर, अधिक, अधिक या बराबर, बराबर या बराबर नहीं, ढीले (==) या सख्त (===) रूप में।

      उदाहरण: 5 3 से अधिक -> true; 'hello' सख्त रूप से 'world' के बराबर -> false

      Type Parameters

      • T

      Parameters

      • inputs: ComparisonDto<T>

        दोनों मान और ऑपरेटर

      Returns boolean

      तुलना का परिणाम

      const bigger = bitbybit.logic.compare({ first: 5, second: 3, operator: Bit.Inputs.Logic.BooleanOperatorsEnum.greater });
      
    • बूलियन true होने पर मान को आगे जाने देता है और false होने पर undefined देता है।

      उदाहरण: 42 true के साथ -> 42; 42 false के साथ -> undefined

      Type Parameters

      • T

      Parameters

      • inputs: ValueGateDto<T>

        मान और वह बूलियन जो गेट खोलता है

      Returns T

      मान, या गेट बंद होने पर undefined

      const maybe = bitbybit.logic.valueGate({ value: 42, boolean: true });
      
    • दो मानों में से पहला परिभाषित मान चुनता है, ताकि दूसरा फ़ॉलबैक की तरह काम करे।

      उदाहरण: 42 और 10 -> 42; undefined और 10 -> 10

      Type Parameters

      • T
      • U

      Parameters

      • inputs: TwoValueGateDto<T, U>

        पसंदीदा मान और फ़ॉलबैक

      Returns T | U

      पहला परिभाषित मान, या दोनों अनुपस्थित होने पर undefined

      const chosen = bitbybit.logic.firstDefinedValueGate({ value1: undefined, value2: 10 });