2009-06-03 24 views
8

मैं योजना में वर्गबद्ध समीकरण की जड़ें खोजने के लिए एक प्रोग्राम लिखना चाहता हूं। मैंने कुछ बाइंडिंग के लिए एलईटी का इस्तेमाल किया।योजना में जाने का उपयोग

(define roots-with-let 
    (λ (a b c) 
    (let ((4ac (* 4 a c)) 
      (2a (* 2 a)) 
      (discriminant (sqrt (- (* b b) (4ac))))) 
     (cons (/ (+ (- b) discriminant) 2a) 
      (/ (- (- b) discriminant) 2a))))) 

मैं 4ac साथ विभेदक परिभाषित के बाद से मैं (* 4 a c) नहीं चाहता था।

expand: unbound identifier in module in: 4ac .

मेरा प्रश्न कैसे करते है का मूल्यांकन (क्या आदेश) है: भले ही मैं (4ac (* 4 a c)) परिभाषित किया है, यह मेरे इस त्रुटि दे रहा है? और अगर मुझे 4ac मेरे let में चाहिए तो क्या मुझे एक और आंतरिक let लिखना चाहिए? क्या ऐसा करने के लिए इससे अच्छा तरीका है?

+1

यह एसआईसीपी व्याख्यान/पुस्तक से एक उदाहरण है! – Nishant

उत्तर

27

let के बजाय let* का उपयोग करें।

let* बाएं से दाएं चर बांधता:

let और let* के बीच अंतर निम्नलिखित है। इससे पहले बाइंडिंग का उपयोग नए बाध्यकारी में दाएं (या नीचे) में किया जा सकता है।

दूसरी ओर let सरल लैम्ब्डा अमूर्त के लिए के रूप में वाक्यात्मक चीनी (या मैक्रो) के बारे में सोचा जा सकता है:

(let ((a exp1) 
     (b exp2)) 
    exp) 

आप एक special let-construct (let* की आवश्यकता होगी

((lambda (a b) 
    exp) 
exp1 exp2) 
+1

क्या आप दोनों के बीच मूल्यांकन आदेश के अंतर पर टिप्पणी कर सकते हैं? – unj2

+0

http://www.r6rs.org/final/html/r6rs/r6rs-Z-H-14.html#node_sec_11.4।6 – Javier

+2

यह मूल्यांकन आदेश के बारे में (केवल) नहीं है, यह ज्यादातर दायरे के बारे में है। सादे में, प्रत्येक चर का दायरा केवल अभिव्यक्ति है, बाइंडिंग नहीं। चलो *, प्रत्येक चर का दायरा अभिव्यक्ति और स्वयं के बाद हर बाध्यकारी है। – Javier

3

के बराबर है) यहां चलिए परिभाषा के अंदर चर एक-दूसरे को संदर्भित करते हैं।

यह बल्कि एक अभिव्यक्ति का मूल्यांकन करने की तुलना में एक गुंजाइश को परिभाषित करने की एक समस्या है (सामान्य let -definitions में, मूल्यांकन के क्रम मायने नहीं रखता क्योंकि मूल्यों एक दूसरे को उपयोग नहीं कर सकते)

8
  • 4ac है एक वैरिएबल वैल्यू वाला वैरिएबल, इसलिए (4 एसी) सार्थक नहीं है।

  • एलईटी सभी चर को बांधता है, लेकिन चर के लिए गणनाओं में चर का उपयोग नहीं किया जा सकता है।

यह काम नहीं करता:

(let ((a 1) (b 1) (c (* a b))) 
    c) 

उपयोग:

(let ((a 1) (b 1)) 
    (let ((c (* a b))) 
    c)) 

ऊपर एक परिचय और पहले लश्कर के साथ बी। दूसरे में दोनों एक लेट और बी अब सी

या गणना करने के लिए इस्तेमाल किया जा सकता:

(let* ((a 1) (b 1) (c (* a b))) 
    c) 
2

जब आप का उपयोग करते हैं, बाइंडिंग निकायों में से किसी में दिखाई नहीं देते हैं। इसके बजाय * दें और विवरण के लिए आरएनआरएस दस्तावेज़ देखें।

संबंधित मुद्दे