ઉકેલાયેલ: બુલિયન

ચોક્કસ, અહીં જાય છે.

હાસ્કેલમાં બુલિયનની શક્તિમાં તર્ક બનાવવાની ક્ષમતા છે જે ઘણી બધી શક્યતાઓ અને પરિણામોને વ્યાખ્યાયિત કરી શકે છે. તેઓ હાસ્કેલમાં નિયંત્રણ માળખાં અને નિર્ણય લેવાનો પાયો બનાવે છે.

બુલિયન મૂલ્યોનો અસરકારક રીતે ઉપયોગ કેવી રીતે કરવો તે સમજવું તમારા કોડના તર્ક અને તમારા હાસ્કેલ પ્રોગ્રામ્સની શક્તિને વધારી શકે છે.

હાસ્કેલમાં બુલિયનની સુંદરતા

હાસ્કેલમાં બુલિયન ડેટા પ્રકાર છે. તેમાં બે મૂલ્ય કન્સ્ટ્રક્ટર છે, સાચા અને ખોટા, જે બે સત્ય મૂલ્યોને રજૂ કરતા તાર્કિક સ્થિરાંકો છે. હાસ્કેલ બુલિયન બીજગણિત માટે બૂલ પ્રકારનો ઉપયોગ કરે છે. બુલિયન તર્ક ગાણિતિક તર્કનો આધાર બનાવે છે અને તેનો ઉપયોગ ઇલેક્ટ્રિકલ એન્જિનિયરિંગ અને કોમ્પ્યુટર વિજ્ઞાનમાં થાય છે. ઉપરાંત, તેઓ ચલો અને અભિવ્યક્તિઓની તુલના કરવા માટે ઉપયોગમાં લેવાય છે.

હાસ્કેલમાં, બુલિયન લોજિક 3 કોર ઓપરેશન્સની આસપાસ કેન્દ્રિત છે: AND, OR, અને NOT. હાસ્કેલમાં, આને અનુક્રમે &&, || તરીકે સૂચવવામાં આવે છે અને નહીં. ગાણિતિક ક્રિયાઓની જેમ જ, બુલિયન કામગીરી ચોક્કસ અગ્રતા અને સહયોગી નિયમોનું પાલન કરે છે.

-- The 'AND' operation
True && True   -- evaluates to True
True && False  -- evaluates to False
False && True  -- evaluates to False
False && False -- evaluates to False

-- The 'OR' operation
True || True   -- evaluates to True
True || False  -- evaluates to True
False || True  -- evaluates to True
False || False -- evaluates to False

-- The 'NOT' operation
not True  -- evaluates to False
not False -- evaluates to True

હાસ્કેલના બુલિયન કાર્યો

બુલિયન ફંક્શન એ ફંક્શન છે જે બુલિયન ઇનપુટ લે છે અને બુલિયન આઉટપુટ પરત કરે છે. આ કાર્યો અમારી જરૂરિયાતોને આધારે જટિલ તાર્કિક કામગીરીને અમલમાં મૂકે છે અને તેનો અભિન્ન ભાગ છે હાસ્કેલમાં પ્રોગ્રામિંગ.

ચાલો હાસ્કેલના બુલિયન કાર્યોમાં ઊંડા ઉતરીએ:

પાવરફુલ પ્રોગ્રામિંગ લેંગ્વેજ હાસ્કેલ ઇન-બિલ્ટ ફંક્શન્સ ધરાવે છે જે બુલિયન મૂલ્યોને પરિમાણો તરીકે લે છે અને તેઓ જે તર્ક સાથે વ્યાખ્યાયિત કરવામાં આવ્યા છે તે મુજબ બુલિયન મૂલ્યોનું આઉટપુટ કરે છે. આ કાર્યોમાં "અને", "અથવા", અને "નહીં" શામેલ છે.

આ ફંક્શનનો ઉપયોગ કરીને આપણે બુલિયન લિસ્ટ પર લોજિકલ ઓપરેશન કરી શકીએ છીએ.

and [True, True, False] -- evaluates to False
or [True, False, False] -- evaluates to True
not True -- evaluates to False

"અને" ફંક્શન ટ્રુ પરત કરે છે જો અને માત્ર જો સૂચિમાંના તમામ ઘટકો True હોય. જો સૂચિમાં ઓછામાં ઓછું એક ઘટક સાચું હોય તો "અથવા" ફંક્શન ટ્રુ આપે છે. "નહીં" ફંક્શન ઇનપુટ બુલિયન વેલ્યુને ફ્લિપ કરે છે, જો તે સાચું હોય તો તે False અને ઊલટું બને છે.

બુલિયન લોજિકનો ઉપયોગ કરીને કન્ડિશનલ સ્ટ્રક્ચર્સ

માનો કે ના માનો, હાસ્કેલ સાથે કોડિંગમાં શરતી માળખામાં બુલિયન નિર્ણાયક ભૂમિકા ભજવે છે. હાસ્કેલમાં, if-then-else અભિવ્યક્તિનો ઉપયોગ અમારા કાર્યક્રમોમાં નિર્ણય લેવાની ક્ષમતાને રજૂ કરવા માટે થાય છે. પૂર્ણાંકના મૂલ્યના આધારે કઈ સ્ટ્રિંગ છાપવી તે નક્કી કરવા માટે બુલિયન લોજિકનો ઉપયોગ કરીને હાસ્કેલ પ્રોગ્રામનું ઉદાહરણ અહીં છે:

checkNumber :: Int -> String
ચેક નંબર n =
જો n > 10 હોય તો "દસથી વધુ"
બાકી જો n < 10 હોય તો "દસ કરતા ઓછા" બાકી "તે દસ છે" મુખ્ય = putStrLn(ચેકનંબર 10) -- તે દસ છે [/code] ઉપરના પ્રોગ્રામમાં, ચેકનંબર ઇનપુટ તરીકે પૂર્ણાંક લે છે અને પૂર્ણાંકની કિંમત પર આધાર રાખે છે , અનુરૂપ સ્ટ્રિંગ પરત કરે છે. આ નિર્ણય લેવા માટે, તે if-then-else કલમનો ઉપયોગ કરે છે જેમાં પ્રારંભિક સ્થિતિ (n > 10 અથવા n < 10) એ બુલિયન અભિવ્યક્તિ હશે જે હાસ્કેલ પ્રોગ્રામ ક્યાં તો સાચા અથવા ખોટા માટે મૂલ્યાંકન કરે છે. જો શરત સાચી હોય તો "પછી" પછીની અભિવ્યક્તિ એક્ઝિક્યુટ થાય છે; અન્યથા, જો શરત False હોય, તો "else" પછી તરત જ અભિવ્યક્તિ ચલાવવામાં આવે છે. બુલિયન તર્કનો ઉપયોગ કરીને હાસ્કેલ પ્રોગ્રામિંગમાં નિર્ણય લેવાનું આ મૂળભૂત ઉદાહરણ છે.