बूलियन में

बूलियन के बारे में

R में बूलियन

सही या गलत वैल्यू को R में logical टाइप से दर्शाया जाता है. इस टाइप में केवल दो वैल्यू होती हैं: TRUE और FALSE.

TRUE
#> [1] TRUE
FALSE
#> [1] FALSE
typeof(TRUE)
#> [1] "logical"

बूलियन ऑपरेटर

R में पाँच बूलियन ऑपरेटर होते हैं.

!TRUE # FALSE (not)
TRUE && FALSE # FALSE (scalar and)
TRUE || FALSE # TRUE (scalar or)

TRUE & FALSE # FALSE (vector and)
TRUE | FALSE # TRUE (vector or)

&& और & बूलियन "और" हैं. इनका परिणाम TRUE होता है जब && के दोनों ओर वाले एक्सप्रेशन TRUE हों.

|| और | बूलियन "या" हैं. इनका परिणाम TRUE होता है जब || के किसी एक ओर वाला एक्सप्रेशन TRUE हो.

ध्यान दीजिए कि और/या ऑपरेटरों के दो सेट हैं.

• दो अक्षरों वाले वर्जन एक-एक वैल्यू पर काम करते हैं.
• एक अक्षर वाले वर्जन वेक्टर के हर एलिमेंट पर अलग-अलग काम करते हैं, और बूलियन का एक वेक्टर लौटाते हैं.

यह अंतर vector-filtering कॉन्सेप्ट में महत्वपूर्ण हो जाएगा, और वहाँ यह शायद और साफ़ भी हो जाएगा.

एक-एक वैल्यू पर & और | का इस्तेमाल ऊपर के उदाहरण में काम करता है, क्योंकि इन्हें लंबाई 1 के वेक्टर की तरह माना जाता है. इनका व्यवहार दो अक्षरों वाले ऑपरेटरों से थोड़ा अलग होता है, क्योंकि सिर्फ वही "शॉर्ट-सर्किट" करते हैं: अगर परिणाम तय करने के लिए बाईं ओर की वैल्यू काफी है, तो दाईं ओर की वैल्यू का मूल्यांकन नहीं किया जाता. इसलिए TRUE || anything हमेशा TRUE ही रहता है, चाहे anything किसी भी लॉजिकल एक्सप्रेशन को दर्शाता हो. यानी anything को नज़रअंदाज़ कर दिया जाता है.

वेक्टर (लंबाई 2 या ज़्यादा) पर && या || का इस्तेमाल करने का मतलब है कि तुलना में सिर्फ पहला एलिमेंट इस्तेमाल होता है, जिससे एक ही TRUE/FALSE मिलता है और शायद एक चेतावनी संदेश भी. यह शायद आपका इरादा नहीं था.

! बूलियन "नहीं" है. यह TRUE और FALSE वैल्यू को आपस में बदल देता है.

!TRUE
#> [1] FALSE
!FALSE
#> [1] TRUE

लंबे और ज़्यादा जटिल एक्सप्रेशनों के लिए, अपना इरादा साफ़ रखने के लिए गोल ब्रैकेट इस्तेमाल करना सबसे अच्छा है.

(TRUE || FALSE) && (FALSE && TRUE)
#> [1] FALSE

TRUE || FALSE && (FALSE && TRUE)
#> [1] TRUE

एक्सक्लूसिव ऑर (यानी A या B, लेकिन दोनों नहीं) के लिए कोई इनफिक्स ऑपरेटर नहीं है. ऐसी स्थिति में xor() फंक्शन इस्तेमाल किया जा सकता है.

xor(TRUE, FALSE)
#> [1] TRUE
xor(TRUE, TRUE)
#> [1] FALSE