के लिए कंप्यूटर बीजगणित लघु संस्करण: मुझे कुछ क्लोजर कोड में दिलचस्पी है जो मुझे एक्स (जैसे क्रमपरिवर्तन, घूर्णन) के परिवर्तनों को निर्दिष्ट करने की अनुमति देगा जिसके अंतर्गत फ़ंक्शन f (x) का मान invariant है, ताकि मैं कुशलतापूर्वक एक्स के अनुक्रम उत्पन्न कर सकता हूं जो आर = एफ (एक्स) को संतुष्ट करता है। क्लोजर के लिए कंप्यूटर बीजगणित में कुछ विकास है? (एक छोटी सी) उदाहरणक्लोजर
(defn #^{:domain #{3 4 7}
:range #{0,1,2}
:invariance-group :full}
f [x] (- x x))
मैं कह सकते हैं के लिए (preimage च # {0}) और यह कुशलतापूर्वक वापसी होगी # {3 4 7}। स्वाभाविक रूप से, यह कोडोडन को सही ढंग से एनोटेट करने में भी सक्षम होगा। कोई सुझाव?
लंबा संस्करण: मुझे एक विशिष्ट समस्या है जो मुझे क्लोजर के लिए कंप्यूटर बीजगणित के विकास के बारे में जानने में रूचि रखती है। क्या कोई मुझे इस तरह के एक परियोजना के लिए इंगित कर सकते हैं? मेरी विशिष्ट समस्या में उन शब्दों के सभी संयोजनों को ढूंढना शामिल है जो एफ (x) = r को संतुष्ट करते हैं, जहां एफ रैंकिंग फ़ंक्शन है और एक सकारात्मक पूर्णांक है। मेरे विशेष मामले में एफ को
एफ (x) = f (x [0]) + f (x [1]) + ... f (x [N-1])
के रूप में गणना की जा सकती हैइसके अलावा मेरे पास अलग-अलग सेट एस = {s_i} का सेट है, जैसे कि f (a) = f (b) ए, बी में एस, एस में एस। तो सभी एक्स उत्पन्न करने की एक रणनीति जैसे कि एफ (एक्स) = आर को एफ के इस कारक पर भरोसा करना चाहिए और प्रत्येक s_i के तहत f का आविष्कार होना चाहिए। शब्दों में, मैं उन साइटों के सभी क्रमपरिवर्तनों की गणना करता हूं जिनमें एस के तत्व होते हैं जो कि योग को जोड़ते हैं और उन्हें प्रत्येक s_i में तत्वों के सभी संयोजनों के साथ लिखें। यह निम्न में काफी ढीली किया जाता है:
(use 'clojure.contrib.combinatorics)
(use 'clojure.contrib.seq-utils)
(defn expand-counter [c]
(flatten (for [m c] (let [x (m 0) y (m 1)] (repeat y x)))))
(defn partition-by-rank-sum [A N f r]
(let [M (group-by f A)
image-A (set (keys M))
;integer-partition computes restricted integer partitions,
;returning a multiset as key value pairs
rank-partitions (integer-partition r (disj image-A 0))
]
(apply concat (for [part rank-partitions]
(let [k (- N (reduce + (vals part)))
rank-map (if (pos? k) (assoc part 0 k) part)
all-buckets (lex-permutations (expand-counter rank-map))
]
(apply concat (for [bucket all-buckets]
(let [val-bucket (map M bucket)
filled-buckets (apply cartesian-product val-bucket)]
(map vec filled-buckets)))))))))
यह काम किया हो जाता है लेकिन अंतर्निहित चित्र याद करते हैं। उदाहरण के लिए, यदि सहयोगी ऑपरेशन एक योग के बजाय एक उत्पाद था तो मुझे भागों को फिर से लिखना होगा।
2013 से [Expresso] (https://github.com/clojure-numerics/expresso) देखें। – Zaz