স্থানাঙ্ক রূপান্তর

;; Top-level definitions are global-scope
(def dozen 12)

;; Functions create a new scope.
;; Referencing the outer variable here is a closure.
(fn [n] (* dozen n))

;; This function closure increments the counter's state
;; in the outer lexical context.
;; This way the counter can be shared between many calling contexts.

(def increment
  (let [counter (atom 0)]
    (fn [] (swap! counter inc))))

(increment)
;;=> 1
(increment)
;;=> 2

নির্দেশনা

আপনার ডিজাইন কোম্পানি মূলত ওয়েব পেজ তৈরির জন্য CSS ট্রান্সফরমেশন নিয়ে কাজ করে আসছে। কিছুটা আলোচনার পর সিদ্ধান্ত হয় যে, কিছু হিসাব গতিশীলভাবে করার জন্য Clojure ব্যবহার শুরু করা হবে। আপনার কিছু সহকর্মীর Clojure নিয়ে অভিজ্ঞতা কম, তাই আপনি {x, y} স্থানাঙ্ক জোড়ার জন্য পুনরায় ব্যবহারযোগ্য রূপান্তর তৈরি করতে একটি ফাংশন ক্লোজার ব্যবহার করার সিদ্ধান্ত নেন।

1. স্থানাঙ্ক স্থানান্তর করুন

translate2d ফাংশনটি ইমপ্লিমেন্ট করুন, যা একটি ক্লোজার ব্যবহার করে একটি স্থানাঙ্ক জোড়ার পুনরাবৃত্তিযোগ্য 2D স্থানান্তর করার জন্য একটি ফাংশন রিটার্ন করে।

(def move-coordinates-right-2px (translate2d 2 0))
(def result (move-coordinates-right-2px 4 8))
;; result => [6 8]

2. স্থানাঙ্ক স্কেল করুন

scale2d ফাংশনটি ইমপ্লিমেন্ট করুন, যা একটি ক্লোজার ব্যবহার করে একটি স্থানাঙ্ক জোড়ার পুনরাবৃত্তিযোগ্য 2D স্কেল করার জন্য একটি ফাংশন রিটার্ন করে।

এই অনুশীলনীর জন্য ধরে নিন যে স্কেলিংয়ের মান কেবল ধনাত্মক।

(def double-scale (scale2d 2 2))
(def result (double-scale 6 -3))
;; result => [12 -6]

3. রূপান্তর ফাংশন কম্পোজ করুন

পুনরাবৃত্তিযোগ্য একটি রূপান্তর করার জন্য দুটি রূপান্তর ফাংশন একত্র করুন। এটাকে প্রায়ই ফাংশন কম্পোজিশন বলা হয়, যেখানে প্রথম ফাংশন 'f(x)'-এর ফলাফল দ্বিতীয় ফাংশন 'g(x)'-এর ইনপুট হিসেবে ব্যবহৃত হয়।

(def move-coordinates-right-2px (translate2d 2 0))
(def double-coordinates (scale2d 2 2))
(def composed-transformations 
  (compose-transform move-coordinates-right-2px 
                     double-coordinates))
(def result (composed-transformations 0 1))
;; result => [4 2]

4. ফাংশনের ফলাফল সংরক্ষণ করুন

memoize-transform ফাংশনটি ইমপ্লিমেন্ট করুন। এটি মেমোইজ করার জন্য একটি ফাংশন নেয়, তারপর এমন একটি নতুন ফাংশন রিটার্ন করে যা সরবরাহ করা ফাংশনের ইনপুটগুলি মনে রাখে, যাতে শেষ রিটার্ন ভ্যালুটি "মনে রাখা" যায় এবং একই আর্গুমেন্ট দিয়ে আবার কল করা হলে কেবল একবারই হিসাব করা হয়।

মেমোইজিংকে কখনও কখনও ডাইনামিক প্রোগ্রামিং বলা হয়; এটি ব্যয়বহুল অপারেশনগুলি কেবল একবার করার সুযোগ দেয়, কারণ তাদের ফলাফল মনে রাখা হয়।

(def triple-scale (scale2d 3 3))
(def memoized-scale (memoize-transform triple-scale))

(memoized-scale 4 3)
;; => [12, 9], this is computed since it hasn't been computed before for the arguments

(memoized-scale 4 3)
;; => [12, 9], this is remembered, since it was computed already