किसी और अगर यदि prolog में बाकी खंड C/C++

Question

ग में भाषा के लिए इसी तरह मैं की तरह कुछ है:

if(cond1) 
{} 
else if(cond2) 
{} 
else 
{} 

यह कैसे संभव Prolog में है?

Answer 1

(cond1 -> 
    consequent1 
; cond2 -> 
    consequent2 
; 
    alternative 
) 

रिकॉर्ड के लिए, यह एक सशर्त कहा जाता है।

Answer 2

( If1 -> Then1 
; If2 -> Then2 
; ... 
; otherwise 
). 

ध्यान दें कि यदि-तो-और कुछ ही आवश्यक है यदि आप अलग अलग खंड में पैटर्न मिलान द्वारा अलग अलग परिस्थितियों व्यक्त नहीं कर सकते। पैटर्न मिलान द्वारा व्यक्त किया जा सकता है कि सब कुछ पैटर्न मिलान द्वारा व्यक्त किया जाना चाहिए, क्योंकि यह आम तौर पर अधिक सामान्य और अधिक कुशल कोड की ओर जाता है।

Answer 3

प्रोलॉग में आंशिक रूप से (जैसा कि @mat द्वारा नोट किया गया है) खोजना वास्तव में आसान नहीं है, वहां एक बेवकूफ विकल्प है। आप here एसडब्ल्यूआई-प्रोलॉग दस्तावेज पा सकते हैं, हालांकि बहुत अधिक स्पष्ट रूप से, यह सटीक है। मैं एक प्रासंगिक बिंदु का हवाला देते हैं:

कृपया ध्यान दें कि (यदि -> फिर) के रूप में कार्य (यदि -> फिर; असफल), अगर हालत में विफल रहता है निर्माण असफल रही है। यह असामान्य अर्थशास्त्र आईएसओ और सभी डी-फैक्टो प्रोलॉग मानकों का हिस्सा है।

Answer 4

->/2 केवल तभी आवश्यक है जब आप एक निश्चित निर्धारणा लागू करना चाहते हैं। यह स्थानीय कट की तरह कार्य करता है। लेकिन यदि आप चाहते हैं कि आपका कोड कुछ गैर-निर्धारणा बनाए रखता है, तो ->/2 का उपयोग करना आवश्यक नहीं है। इस प्रकार>/2 - बिना

boolean listOfBool(Object obj) { 
    if (obj instanceof ConsCell) { 
     if (((ConsCell)ob).head() instanceof Boolean) { 
      return listOfBool(((ConsCell)ob).tail()); 
     } else { 
      return false; 
     } 
    } else if (obj == null) { 
     return true; 
    } else { 
     return false; 
    } 

}

यह Prolog में कोडित किया जा सकता है:

% bool(+Bool) 
% bool(-Bool) 
bool(0). 
bool(1). 

% list_of_bool(+List) 
% list_of_bool(-List) 
list_of_bool(L) :- 
    (L = [X|Y], bool(X), list_of_bool(Y); 
    L = []). 

लाभ अब है कि यह कर सकते हैं है

निम्नलिखित अनिवार्य कोड ले लो बूलियन के सूचियों और बूलियन की सूचियां उत्पन्न करने के लिए उपयोग किया जाना चाहिए:

?- list_of_bool([0,1,0]). 
Yes 
?- list_of_bool([0,1,2]). 
No 
?- List=[_,_,_], list_of_bool(List). 
List = [0, 0, 0] ; 
List = [0, 0, 1] ; 
List = [0, 1, 0] ; 
List = [0, 1, 1] Etc.. 

आम तौर पर संयोजन (;)/2 को एकाधिक खंडों पर वितरित किया जा सकता है। यदि यह एकीकरण (=)/2 को सिर में ले जाने के साथ जोड़ा जाता है, तो कुछ गति प्राप्त की जा सकती है, क्योंकि भविष्यवाणी आमतौर पर अनुक्रमणित करने के लिए बेहतर है।

यहाँ list_of_bool का एक वैकल्पिक सूत्रीकरण कैसा दिखेगा कैसे नष्ट करने से है (;)/2 और (=)/2:

% list_of_bool2(+List) 
% list_of_bool2(-List) 
list_of_bool2([X|Y]) :- bool(X), list_of_bool2(Y). 
list_of_bool2([]). 

ऊपर काम करता है ठीक उसी (यह वास्तव में बेहतर है, काम करता है के बाद से पहली क्वेरी में कोई विकल्प नहीं बिंदु छोड़ दिया है, क्या (;)/2 आमतौर पर बिना पता नहीं लगा होगा (->)/2):

?- list_of_bool2([0,1,0]). 
Yes 
?- list_of_bool2([0,1,2]). 
No 
?- List=[_,_,_], list_of_bool(List). 
List = [0, 0, 0] ; 
List = [0, 0, 1] ; 
List = [0, 1, 0] ; 
List = [0, 1, 1] Etc.. 

यह भी है कि कैसे Prolog शुरू किया जा सकता। नियमों के साथ केवल और कोई संयोजन (;)/2 और कोई एकीकरण (=)/2 नहीं है। बाद में दो अंतर्निहित हॉर्न क्लॉज में पहले से ही हैं।

मान लीजिए आप बिना एक Prolog है (;)/2 और कोई (=)/2, और आप एक कट पारदर्शी जरूरत नहीं है, इस प्रकार है/2, तो आप इन निर्माणों खुद के द्वारा निर्धारित कर सकते हैं() :

X = X. 

(A ; _) :- A. 
(_ ; B) :- B. 

अलविदा

हॉर्न खण्ड
http://en.wikipedia.org/wiki/Horn_clause