आपके गणितज्ञ उपकरण बैग में क्या है? [बन्द है]

Question

हम सभी जानते हैं कि गणितज्ञ महान है, लेकिन इसमें अक्सर महत्वपूर्ण कार्यक्षमता का अभाव होता है। आप Mathematica के साथ किस तरह के बाहरी पैकेज / टूल / संसाधन का उपयोग करते हैं?

मैं उन मुख्य संसाधनों को शामिल करने के लिए (और किसी और को भी ऐसा करने के लिए आमंत्रित) करूंगा, जो वैज्ञानिक अनुसंधान में सामान्य प्रयोज्यता पर केंद्रित हैं और जो संभव हो उतने लोग उपयोगी होंगे। कुछ भी योगदान करने के लिए स्वतंत्र महसूस करें, यहां तक ​​कि छोटे कोड स्निपेट (जैसा कि मैंने एक समयबद्ध दिनचर्या के लिए नीचे किया था)।

इसके अलावा, Mathematica 7 में अनैच्छिक और उपयोगी विशेषताएं और इससे परे कि आप खुद को पाए, या कुछ कागज / साइट से खोदे गए हैं, आपका स्वागत है।

कृपया कोई संक्षिप्त विवरण या टिप्पणी शामिल करें कि कोई चीज महान क्यों है या यह किस उपयोगिता प्रदान करती है। यदि आप अमेजन पर किताबों के साथ सहबद्ध लिंक से लिंक करते हैं, तो कृपया लिंक के बाद अपना नाम डालकर, इसका उल्लेख करें।

---

पैकेज:

1. LevelSchemeएक पैकेज है जो बहुत अच्छे दिखने वाले भूखंडों का उत्पादन करने के लिए गणितज्ञ की क्षमता का विस्तार करता है। मैं इसका इस्तेमाल किसी और चीज के लिए नहीं करता हूं, तो फ्रेम / कुल्हाड़ियों की टिक पर ज्यादा सुधार के लिए। इसका नवीनतम संस्करण SciDraw कहलाता है, और इसे इस साल किसी भी समय रिलीज़ किया जाएगा।
2. डेविड पार्क Presentation Package(यूएस $ 50 - अपडेट के लिए कोई शुल्क नहीं)
3. जेरेमी माइकलसन grassmannOpsपैकेज ग्रैस्समैन चर और ऑपरेटरों के साथ बीजीय और पथरी करने के लिए संसाधन प्रदान करता है जिनके गैर तुच्छ संबंध हैं।
4. जॉन ब्राउन का GrassmannAlgebraपैकेज और ग्रैसमैन और क्लिफोर्ड अल्जेब्रा के साथ काम करने के लिए किताब।
5. RISC (रिसर्च इंस्टीट्यूट फॉर सिम्बोलिक कॉम्पटेशन) में मैथमेटिका (और अन्य भाषाओं) के लिए विभिन्न प्रकार के पैकेज डाउनलोड के लिए उपलब्ध हैं। विशेष रूप से, एल्गोरिथम संयोजन समूह के सॉफ़्टवेयर पृष्ठ पर प्रतीकात्मक सिद्धिकरण , और प्रतीकात्मक योग, अंतर समीकरणों आदि के लिए पैकेजों की भीड़ के लिए प्रमेय है ।

उपकरण:

1. MASHडैनियल रीव्स की उत्कृष्ट पर्ल स्क्रिप्ट अनिवार्य रूप से गणितज्ञ v7 के लिए स्क्रिप्टिंग समर्थन प्रदान करती है। (अब -scriptविकल्प के साथ Mathematica 8 के रूप में बनाया गया है।)
2. एक alternate Mathematica shellGNU रीडलाइन इनपुट के साथ (अजगर का उपयोग करके, * केवल निक्स)
3. ColourMaths पैकेज आपको अभिव्यक्ति के कुछ हिस्सों को नेत्रहीन रूप से चुनने और उन्हें हेरफेर करने की अनुमति देता है। http://www.dbaileyconsultancy.co.uk/colour_maths/colour_maths.html

संसाधन:

1. MathSourceयदि विभिन्न अनुप्रयोगों के लिए संकीर्ण नोटबुक हैं तो वुल्फराम की अपनी रिपॉजिटरी में बहुत उपयोगी है। इसके अलावा अन्य अनुभागों की भी जाँच करें

   • Current Documentation,
   • Courseware व्याख्यान के लिए,
   • और Demos, अच्छी तरह से, डेमो के लिए।

2. मेथेमेटिका Wikibook ।

पुस्तकें:

1. गणितज्ञ प्रोग्रामिंग: लियोनिद शिफरीन ( web, pdf) द्वारा एक उन्नत परिचय एक पढ़ा जाना चाहिए यदि आप गणितज्ञों के लिए लूप्स से अधिक कुछ भी करना चाहते हैं । हमें Leonidयहाँ सवालों के जवाब देने में खुशी होती है।
2. मेथेमेटिका साथ क्वांटम तरीके जेम्स एफ Feagin द्वारा ( अमेज़न )
3. स्टीफन वोल्फ्राम ( अमेजन ) द्वारा गणितज्ञ पुस्तक ( web)
4. शाउम की रूपरेखा ( अमेज़न )
5. स्टेन वैगन ( अमेजन ) द्वारा गणित में एक्शन के 600 पेज - स्वच्छ उदाहरण के लिए और मैथमेटिका संस्करण 7 तक जाता है। विज़ुअलाइज़ेशन तकनीक विशेष रूप से अच्छी हैं, आप उनमें से कुछ को लेखक के देख सकते हैं Demonstrations Page।
6. रिचर्ड गेलॉर्ड ( pdf) द्वारा मैथमैटिक प्रोग्रामिंग फंडामेंटल्स - मैथेमेटिका प्रोग्रामिंग के बारे में आपको जो भी जानने की जरूरत है, उसका एक अच्छा संक्षिप्त परिचय।
7. ओ मैरेली 2010 832 पृष्ठों द्वारा प्रकाशित सैल मैंगो द्वारा गणितज्ञ कुकबुक। - प्रसिद्ध ओ'रिली कुकबुक शैली में लिखा गया: समस्या - समाधान। इंटरमीडिएट के लिए।
8. गणितज्ञ, 3 एड के साथ विभेदक समीकरण। मार्शे एल। एबेल, जेम्स पी। ब्रसेल्सटन - 893 पृष्ठों द्वारा एल्सेवियर 2004 एम्स्टर्डम शुरुआती के लिए, एक ही समय में डीईएस और गणितज्ञ को हल करना सीखें।

अनिर्दिष्ट (या दुर्लभ रूप से प्रलेखित) विशेषताएं:

7. Mathematica कीबोर्ड शॉर्टकट को कैसे कस्टमाइज़ करें। देखते हैं this question।
8. माथमेटिका के अपने कार्यों के पैटर्न और कार्यों का निरीक्षण कैसे करें। देखthis answer
9. Mathematica में GraphPlots के लिए लगातार आकार कैसे प्राप्त करें? देखते हैं this question।
10. गणितज्ञों के साथ दस्तावेजों और प्रस्तुतियों का उत्पादन कैसे करें। देखते हैं this question।

Comments

गणितज्ञ 8 बेहतर शेल स्क्रिप्ट एकीकरण के साथ बाहर है। wolfram.com/mathematica/new-in-8/mathematica-shell-scripts

— जोशुआ मार्टेल

LevelScheme के लिए +1। थोड़ा धीमा है, कभी-कभी। लेकिन, इसमें टिक मार्क बनाने के लिए एक सेंस विधि है, और इसके बाद ग्राफिक्स के लिए जर्नल योग्य लेआउट बनाना आसान है Grid, या इसके बारे में कुछ भी।

— rcollyer

जैसा कि इस सवाल पर टिप्पणी में एलेक्सी द्वारा प्रस्तावित stackoverflow.com/questions/5152551/… , मैंने यहाँ Mathematica के लिए टैग का नाम प्रस्तावित किया: meta.stackexchange.com/questions/81152/… । यदि आप सहमत हैं तो कृपया एक बार देख लें और आगे बढ़ें। मैं इसे यहाँ पोस्ट करता हूँ क्योंकि यह प्रश्न यहाँ के Mma समुदाय में बहुत अधिक पसंदीदा है।

— बजे डॉ। बिसरिसेर

सभी, यह प्रश्न वास्तव में सभी सामान्य कारणों से सामुदायिक विकि होना चाहिए: इसका कोई सही उत्तर नहीं है और यह किसी भी चीज़ की तुलना में अधिक सूची में है। मैं उन सभी से माफी मांगता हूं जिन्होंने इस प्रश्न की प्रतिष्ठा से हाथ मिलाया है।

— रंगरेल

इस प्रश्न के ये उत्तर रचनात्मक हैं, इसे फिर से खोला जाना चाहिए।

— एमआर

Answer 1

मैं उल्लेख किया है इस से पहले, लेकिन उपकरण मैं सबसे उपयोगी लगते हैं की एक आवेदन पत्र है Reapऔर Sowजो की नकल करता है / के व्यवहार का विस्तार GatherBy:

SelectEquivalents[x_List,f_:Identity, g_:Identity, h_:(#2&)]:=
   Reap[Sow[g[#],{f[#]}]&/@x, _, h][[2]];

यह मुझे किसी भी मापदंड से समूह सूचियों और उन्हें प्रक्रिया में बदलने की अनुमति देता है। जिस तरह से यह काम करता है वह यह है कि एक मानदंड फ़ंक्शन ( f) सूची में प्रत्येक आइटम को टैग करता है , फिर प्रत्येक आइटम को दूसरे आपूर्ति फ़ंक्शन ( g) द्वारा बदल दिया जाता है , और विशिष्ट आउटपुट को तीसरे फ़ंक्शन ( h) द्वारा नियंत्रित किया जाता है । यह फ़ंक्शन hदो तर्कों को स्वीकार करता है: एक टैग और एकत्रित किए गए आइटमों की एक सूची जिसमें वह टैग होता है। आइटम अपने मूल क्रम को बनाए रखते हैं, इसलिए यदि आप सेट करते हैं h = #1&तो आपको एक अनसुलझा मिलता है Union, जैसे उदाहरणों के लिए Reap। लेकिन, इसका उपयोग माध्यमिक प्रसंस्करण के लिए किया जा सकता है।

इसकी उपयोगिता के एक उदाहरण के रूप में, मैं Wannier90 के साथ काम कर रहा हूं, जो स्थानिक रूप से निर्भर हैमिल्टन को एक फाइल में आउटपुट करता है, जहां प्रत्येक लाइन मैट्रिक्स में एक अलग तत्व है, निम्नानुसार है

rx ry rz i j Re[Hij] Im[Hij]

उस सूची को मैट्रिसेस के एक सेट में बदलने के लिए, मैंने सभी उपविदों को इकट्ठा किया, जिनमें समान समन्वय होता है, तत्व जानकारी को एक नियम में बदल दिया (अर्थात {i, j} -> Re [Hij] + I Im [Hij],); फिर SparseArrayएक लाइनर के साथ एकत्रित नियमों को सभी में बदल दिया :

SelectEquivalents[hamlst, 
      #[[;; 3]] &, 
      #[[{4, 5}]] -> (Complex @@ #[[6 ;;]]) &, 
      {#1, SparseArray[#2]} &]

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

संपादित करें : यह पूरी तरह से नकल नहीं करता GatherByहै कि यह अभिव्यक्ति के कई स्तरों को बस के रूप में समूह नहीं GatherByकर सकता है। हालांकि, Mapमुझे जो भी चाहिए उसके लिए ठीक काम करता है।

उदाहरण : @ यारोस्लाव बुलटोव ने एक आत्म-निहित उदाहरण के लिए कहा है। यहाँ मेरा एक शोध है जो बहुत सरल किया गया है। तो, मान लें कि हमारे पास एक विमान में बिंदुओं का एक समूह है

In[1] := pts = {{-1, -1, 0}, {-1, 0, 0}, {-1, 1, 0}, {0, -1, 0}, {0, 0, 0}, 
 {0, 1, 0}, {1, -1, 0}, {1, 0, 0}, {1, 1, 0}}

और हम समरूपता संचालन के एक सेट द्वारा अंकों की संख्या को कम करना चाहते हैं। (जिज्ञासु के लिए, हम प्रत्येक बिंदु के छोटे समूह का निर्माण कर रहे हैं ।) इस उदाहरण के लिए, आइए z- अक्ष के बारे में चार गुना रोटेशन अक्ष का उपयोग करें

In[2] := rots = RotationTransform[#, {0, 0, 1}] & /@ (Pi/2 Range[0, 3]);

का उपयोग करते हुए SelectEquivalentsहम समूह अंक कि इन आपरेशनों के तहत छवियों के एक ही सेट का उत्पादन, वे बराबर यानी सकते हैं, निम्नलिखित का उपयोग कर

In[3] := SelectEquivalents[ pts, Union[Through[rots[#] ] ]& ] (*<-- Note Union*)
Out[3]:= {{{-1, -1, 0}, {-1, 1, 0}, {1, -1, 0}, {1, 1, 0}},
          {{-1, 0, 0}, {0, -1, 0}, {0, 1, 0}, {1, 0, 0}},
          {{0,0,0}}}

जो समतुल्य बिंदुओं वाले 3 उपविषयों का निर्माण करता है। (ध्यान दें, Unionयहां बिल्कुल महत्वपूर्ण है क्योंकि यह सुनिश्चित करता है कि एक ही छवि प्रत्येक बिंदु द्वारा निर्मित होती है। मूल रूप से, मैंने उपयोग किया था Sort, लेकिन अगर एक बिंदु एक समरूपता अक्ष पर स्थित है, तो यह उस अक्ष के रोटेशन के तहत अपरिवर्तनीय है जो स्वयं की एक अतिरिक्त छवि देता है। तो, Unionइन अतिरिक्त छवियों को समाप्त करता है। इसके अलावा,GatherBy एक ही परिणाम का उत्पादन करेगा।) इस मामले में, अंक पहले से ही एक ऐसे रूप में हैं जिसका मैं उपयोग करूंगा, लेकिन मुझे केवल प्रत्येक समूह से एक प्रतिनिधि बिंदु की आवश्यकता है और मैं एक गिनती पसंद करूंगा। समान अंक के। चूंकि, मुझे प्रत्येक बिंदु को बदलने की आवश्यकता नहीं है, मैं इसका उपयोग करता हूंIdentityदूसरे स्थान पर कार्य करें। तीसरे समारोह के लिए, हमें सावधान रहने की जरूरत है। इसके लिए दिया गया पहला तर्क घूर्णन के तहत बिंदुओं की छवियां होगी जो बिंदु {0,0,0}के लिए चार समान तत्वों की एक सूची है, और इसका उपयोग करके गिनती को फेंक दिया जाएगा। हालाँकि, दूसरा तर्क उन सभी तत्वों की एक सूची है जिनमें यह टैग है, इसलिए इसमें केवल शामिल होगा {0,0,0}। कोड में,

In[4] := SelectEquivalents[pts,  
             Union[Through[rots[#]]]&, #&, {#2[[1]], Length[#2]}& ]
Out[4]:= {{{-1, -1, 0}, 4}, {{-1, 0, 0}, 4}, {{0, 0, 0}, 1}}

ध्यान दें, यह अंतिम चरण बस के रूप में आसानी से पूरा किया जा सकता है

In[5] := {#[[1]], Length[#]}& /@ Out[3]

लेकिन, यह इसके साथ आसान है और ऊपर का कम पूर्ण उदाहरण यह देखने के लिए कि न्यूनतम कोड के साथ बहुत जटिल परिवर्तन कैसे संभव हैं।

Comments

मूल Fortran77 कोड को थैंक्सगिविंग डे 1996 पर पुनर्गठित किया गया था, और इसलिए कई वर्षों से इसे turkey.f के रूप में जाना जाता है ...: D बहुत अच्छा ग्राफिक्स BTW। मुझे फालिकोव का राक्षस याद आया ...

— डॉ। बेलिसरॉइस

@ सबिसिसरियस, मैंने इतिहास नहीं पढ़ा था, यह मज़ेदार है। मैंने अभी Wannier90 का उपयोग करना शुरू किया है, लेकिन यह कुछ सबसे अच्छा संगठित और अच्छी तरह से लिखित Fortranकोड है जो मैंने देखा है। मुझे लगभग का उपयोग करने पर विचार करता है Fortran...

— रंगरेलर

मुझे आश्चर्य है कि अगर आप कार्रवाई में SelectEquivalents का एक आत्म-निहित उदाहरण जोड़ सकते हैं

— यारोस्लाव

@ यारोस्लाव बुलटोव ने अनुरोध के अनुसार एक उदाहरण जोड़ा। मुझे बताएं क्या इससे मदद मिलती है। यदि ऐसा नहीं होता है, तो हम देखेंगे कि हम क्या कर सकते हैं।

— रॉल्कर

आपको सबसे दिलचस्प कोड स्निपेट योगदान के लिए इस "प्रश्न" का चेकमार्क मिलता है।

— टिमो

Answer 2

Mathematica नोटबुक इंटरफ़ेस के बारे में एक अच्छी बात यह है कि यह किसी भी भाषा में भावों का मूल्यांकन कर सकता है , न कि केवल Mathematica। एक सरल उदाहरण के रूप में, एक नया शेल इनपुट सेल प्रकार बनाने पर विचार करें जो मूल्यांकन के लिए ऑपरेटिंग सिस्टम शेल में निहित अभिव्यक्ति को पास करता है।

सबसे पहले, एक फ़ंक्शन को परिभाषित करें जो बाहरी शेल में एक टेक्स्ट कमांड के मूल्यांकन को दर्शाता है:

shellEvaluate[cmd_, _] := Import["!"~~cmd, "Text"]

दूसरे तर्क की आवश्यकता है और उन कारणों की अनदेखी की जाती है जो बाद में स्पष्ट हो जाएंगे। अगला, हम शेल नामक एक नई शैली बनाना चाहते हैं :

1. एक नई नोटबुक खोलें।
2. मेनू आइटम प्रारूप का चयन करें / शैलियाँ संपादित करें ...
3. संवाद में, एक शैली नाम दर्ज करें: टाइप करें Shell।
4. नई शैली के पास सेल ब्रैकेट का चयन करें।
5. मेनू आइटम सेल / एक्सप्रेशन दिखाएँ का चयन करें
6. नीचे दिए गए चरण 6 पाठ के साथ सेल अभिव्यक्ति को अधिलेखित करें।
7. एक बार फिर, मेनू आइटम सेल / शो एक्सप्रेशन का चयन करें
8. संवाद बंद करें।

निम्नलिखित सेल अभिव्यक्ति का उपयोग करें चरण 6 पाठ के :

Cell[StyleData["Shell"],
 CellFrame->{{0, 0}, {0.5, 0.5}},
 CellMargins->{{66, 4}, {0, 8}},
 Evaluatable->True,
 StripStyleOnPaste->True,
 CellEvaluationFunction->shellEvaluate,
 CellFrameLabels->{{None, "Shell"}, {None, None}},
 Hyphenation->False,
 AutoQuoteCharacters->{},
 PasteAutoQuoteCharacters->{},
 LanguageCategory->"Formula",
 ScriptLevel->1,
 MenuSortingValue->1800,
 FontFamily->"Courier"]

इस अभिव्यक्ति के अधिकांश को सीधे अंतर्निहित रूप में कॉपी किया गया था प्रोग्राम शैली के । मुख्य परिवर्तन ये रेखाएँ हैं:

 Evaluatable->True,
 CellEvaluationFunction->shellEvaluate,
 CellFrameLabels->{{None, "Shell"}, {None, None}},

Evaluatableसेल के लिए SHIFT + ENTER कार्यक्षमता सक्षम करता है। मूल्यांकन कॉल करेगाCellEvaluationFunction पासिंग सेल सामग्री और सामग्री प्रकार को तर्क के रूप में कहेगा ( shellEvaluateबाद वाले तर्क की उपेक्षा करता है)। CellFrameLabelsकेवल एक नोक है जो उपयोगकर्ता को यह बताता है कि यह सेल असामान्य है।

इस सब के साथ, अब हम एक शेल एक्सप्रेशन दर्ज कर सकते हैं और उसका मूल्यांकन कर सकते हैं:

1. उपरोक्त चरणों में बनाई गई नोटबुक में, एक खाली सेल बनाएं और सेल ब्रैकेट चुनें।
2. मेनू आइटम का चयन करें प्रारूप / शैली / शैल का ।
3. सेल में एक मान्य ऑपरेटिंग सिस्टम शेल कमांड टाइप करें (जैसे यूनिक्स पर 'ls' या विंडोज पर 'dir')।
4. SHIFT + ENTER दबाएँ।

केंद्रीय रूप से स्थित स्टाइलशीट में इस परिभाषित शैली को रखना सबसे अच्छा है। इसके अलावा, मूल्यांकन कार्य जैसे डिक्लेयरपैकेजshellEvaluate का उपयोग करके स्टब्स के रूप में सबसे अच्छा परिभाषित किया गया हैinit.m । इन दोनों गतिविधियों का विवरण इस प्रतिक्रिया के दायरे से परे है।

इस कार्यक्षमता के साथ, कोई भी नोटबुक बना सकता है जिसमें ब्याज के किसी भी सिंटैक्स में इनपुट अभिव्यक्तियाँ होती हैं। मूल्यांकन समारोह को शुद्ध गणित में लिखा जा सकता है, या मूल्यांकन के किसी भी या सभी भागों को किसी बाहरी एजेंसी को सौंप सकते हैं। ध्यान रखें कि अन्य हुक हैं जो सेल मूल्यांकन से संबंधित हैं, जैसे CellEpilog, CellPrologऔर CellDynamicExpression।

एक सामान्य पैटर्न में इनपुट अभिव्यक्ति पाठ को एक अस्थायी फ़ाइल में लिखना, फ़ाइल को किसी भाषा में संकलित करना, प्रोग्राम चलाना और आउटपुट सेल में अंतिम प्रदर्शन के लिए आउटपुट कैप्चर करना शामिल है। इस तरह के पूर्ण समाधान को लागू करते समय पता करने के लिए बहुत सारे विवरण हैं (जैसे त्रुटि संदेशों को ठीक से कैप्चर करना), लेकिन किसी को इस तथ्य की सराहना करनी चाहिए कि इस तरह की चीजों को करना न केवल संभव है, बल्कि व्यावहारिक है।

एक व्यक्तिगत नोट पर, यह इस तरह की विशेषताएं हैं जो नोटबुक इंटरफ़ेस को मेरे प्रोग्रामिंग ब्रह्मांड का केंद्र बनाती हैं।

अपडेट करें

निम्नलिखित हेल्पर फ़ंक्शन ऐसी कोशिकाओं को बनाने के लिए उपयोगी है:

evaluatableCell[label_String, evaluationFunction_] :=
  ( CellPrint[
      TextCell[
        ""
      , "Program"
      , Evaluatable -> True
      , CellEvaluationFunction -> (evaluationFunction[#]&)
      , CellFrameLabels -> {{None, label}, {None, None}}
      , CellGroupingRules -> "InputGrouping"
      ]
    ]
  ; SelectionMove[EvaluationNotebook[], All, EvaluationCell]
  ; NotebookDelete[]
  ; SelectionMove[EvaluationNotebook[], Next, CellContents]
  )

यह इस प्रकार प्रयोग किया जाता है:

shellCell[] := evaluatableCell["shell", Import["!"~~#, "Text"] &]

अब, यदि shellCell[]मूल्यांकन किया जाता है, तो इनपुट सेल को हटा दिया जाएगा और एक नए इनपुट सेल के साथ प्रतिस्थापित किया जाएगा जो शेल कमांड के रूप में इसकी सामग्री का मूल्यांकन करता है।

Comments

@WReach +100! काश मैं यह पहले से जानता था! यह बहुत उपयोगी सामान है, मेरे लिए कम से कम। साझा करने के लिए धन्यवाद!

— लियोनिड शिफरीन

यह बहुत डरावना लग रहा है! CellEvaluationFunctionमुझे लगता है कि निम्न स्तर सिंटैक्स हैकिंग के लिए इस्तेमाल किया जा सकता है।

— श्री। छिपकली

@ लियोनिड कम से कम फ्रंटएंड के लिए, वह CellEvaluationFunctionहुक है जिसकी आपको तलाश थी?

— श्री। छिपकली

इसके अलावा: एक और Cellविकल्प है जो सेल मूल्यांकन से संबंधित है - Evaluator -> "EvaluatorName"। मूल्यांकन के"EvaluatorName" माध्यम से कॉन्फ़िगर किया जा सकता का अर्थ :: कर्नेल कॉन्फ़िगरेशन विकल्प ... संवाद। मैं अभी भी नहीं जानता कि क्या यह संभव है कि इसे प्रोग्रामेटिक रूप से कॉन्फ़िगर किया जाए ... यह तकनीक Cellएक नोटबुक में अलग-अलग मैथेर्नेल का उपयोग करने की अनुमति देती है । ये MathKernels स्थापित किए गए Mathematica के विभिन्न संस्करणों से हो सकते हैं ।

— एलेक्सी पोपकोव

@Szabolcs इस तकनीक के मेरे स्वयं के सभी उपयोगों में या तो ऊपर वर्णित के रूप में एक stdin _ / _ stdout दृष्टिकोण शामिल है, या SQL क्वेरी या HTTP ऑपरेशन जैसे स्व-निहित दूरस्थ अनुरोध। आप एक पायथन आरईपीएल वेब ऐप ( इस तरह ) स्थापित करने का उपयोग कर सकते हैं और इसके साथ बातचीत कर सकते हैं Import, या शायद एक बाहरी पायथन प्रक्रिया शुरू कर सकते हैं और इसकी धाराओं के माध्यम से संचार कर सकते हैं (जैसे कि जावा प्रोसेसब्यूलेर का उपयोग करके )। मुझे यकीन है कि एक बेहतर गणित का तरीका है - एक अच्छा SO प्रश्न जैसा लगता है :)

— 13

Answer 3

टॉड गेले (वोल्फ्राम रिसर्च) मुझे सिर्फ एक अच्छी हैक भेजते हैं जो मनमाने कोड के साथ अंतर्निहित कार्यों को "लपेटने" की अनुमति देता है। मुझे लगता है कि मुझे इस उपयोगी उपकरण को साझा करना होगा। निम्नलिखित मेरे पर टॉड का जवाब है question।

एक दिलचस्प () इतिहास का एक बिट: एक अंतर्निहित फ़ंक्शन "रैपिंग" के लिए हैक की उस शैली का आविष्कार 1994 के आसपास रॉबी विलेगास और I द्वारा किया गया था, विडंबना यह है कि फ़ंक्शन संदेश के लिए, ErrorHelp नामक एक पैकेज में, जो मैंने मैथेमेटिका जर्नल के लिए लिखा था तब। तब से कई लोगों द्वारा इसका उपयोग कई बार किया जा चुका है। यह एक अंदरूनी सूत्र की चाल का एक सा है, लेकिन मुझे लगता है कि यह कहना उचित है कि यह एक अंतर्निहित फ़ंक्शन की परिभाषा में अपने कोड को इंजेक्ट करने का विहित तरीका बन गया है। यह अच्छी तरह से काम हो जाता है। आप निश्चित रूप से $ inMsg वैरिएबल को अपनी इच्छानुसार किसी भी निजी संदर्भ में रख सकते हैं।

Unprotect[Message];

Message[args___] := Block[{$inMsg = True, result},
   "some code here";
   result = Message[args];
   "some code here";
   result] /; ! TrueQ[$inMsg]

Protect[Message];

Comments

@ एसेक्स मुझे यह समझने में कठिनाइयाँ हैं। क्या आप बता सकते हैं कि यह कैसे काम करता है? कहीं एक असुरक्षित [संदेश] नहीं होना चाहिए? और क्या इस उदाहरण में अनंत पुनरावृत्ति नहीं है? तथा, ! TrueQ [$ inMsg] ब्लॉक के दायरे में परिभाषित $ inMsg के साथ समझ में आता है और ब्लॉक के बाहर अपरिभाषित है?

— Sjoerd C. de Vries

@Sjoerd मैं जो समझता हूं, वह Unprotectवास्तव में होना है, अभी बाहर था। Block(डायनेमिक स्कूपिंग) का बिंदु और $inMsgअनंत पुनरावृत्ति को रोकने के लिए है। क्योंकि $inMsgबाहर अपरिभाषित है (यह एक महत्वपूर्ण आवश्यकता है), सबसे पहले, TrueQमूल्यांकन करता है False, और हम फ़ंक्शन के शरीर में प्रवेश करते हैं। लेकिन जब हमारे पास शरीर के अंदर फ़ंक्शन कॉल होता है, तो स्थिति का मूल्यांकन करता है False(चूंकि ब्लॉक द्वारा चर को फिर से परिभाषित किया गया है)। इस प्रकार, उपयोगकर्ता-परिभाषित नियम मेल नहीं खाता है, और अंतर्निहित नियम इसके बजाय उपयोग किया जाता है।

— लियोनिद शिफरीन

@ एलोनिड थैंक्स, मैं इसे अभी प्राप्त करता हूं। बहुत चालाक!

— सोज़र्ड सी। डी। वीस

मैंने अभी पाया है कि इस तकनीक पर 1999 के डेवलपर सम्मेलन में वुल्फराम रिसर्च के रॉबी विलेगास ने चर्चा की थी। देखें "वर्किंग साथ unevaluated भाव" नोटबुक पोस्ट यहाँ । इस नोटबुक में रॉबी विल्लेगास ने "मेरे ब्लॉक ट्रिक टू कॉल इन फंक्शन्स" सबसिक्शन में इस ट्रिक पर चर्चा की।

— एलेक्सी पोपकोव

@ Mr.Wizard यह ऐसा करने का एकमात्र तरीका नहीं है। एक लंबे समय के लिए, मैंने एक ऐसे संस्करण का उपयोग किया, जहां आप DownValuesरन-टाइम पर रीडिफाइन करते हैं, आप इस पोस्ट समूहों पर देख सकते हैं। उदाहरण के लिए ( SetDelayedredefinition) । लेकिन मेरी विधि कम सुरुचिपूर्ण है, कम मजबूत है, अधिक त्रुटि-प्रवण है, और पुनरावृत्ति से तोड़ने को लागू करने के लिए बहुत कम तुच्छ बनाता है। तो, ज्यादातर स्थितियों में, @Alexey द्वारा वर्णित विधि हाथ नीचे जीतती है।

— लियोनिड शिफरीन

Answer 4

यह एक पूर्ण संसाधन नहीं है, इसलिए मैं इसे उत्तर अनुभाग में यहां फेंक रहा हूं, लेकिन मैंने इसे गति के मुद्दों का पता लगाते समय बहुत उपयोगी पाया है (जो कि दुर्भाग्य से, गणितज्ञ प्रोग्रामिंग के बारे में एक बड़ा हिस्सा है)।

timeAvg[func_] := Module[
{x = 0, y = 0, timeLimit = 0.1, p, q, iterTimes = Power[10, Range[0, 10]]},
Catch[
 If[(x = First[Timing[(y++; Do[func, {#}]);]]) > timeLimit,
    Throw[{x, y}]
    ] & /@ iterTimes
 ] /. {p_, q_} :> p/iterTimes[[q]]
];
Attributes[timeAvg] = {HoldAll};

उपयोग तो बस है timeAvg@funcYouWantToTest।

संपादित करें: श्री जादूगर ने एक सरल संस्करण प्रदान किया है, जो दूर है Throwऔर Catchपार्स करना थोड़ा आसान है:

SetAttributes[timeAvg, HoldFirst]
timeAvg[func_] := Do[If[# > 0.3, Return[#/5^i]] & @@ 
                     Timing @ Do[func, {5^i}]
                     ,{i, 0, 15}]

संपादित करें: यहाँ acl से एक संस्करण है ( यहाँ से लिया गया है ):

timeIt::usage = "timeIt[expr] gives the time taken to execute expr, \
  repeating as many times as necessary to achieve a total time of 1s";

SetAttributes[timeIt, HoldAll]
timeIt[expr_] := Module[{t = Timing[expr;][[1]], tries = 1},
  While[t < 1., tries *= 2; t = Timing[Do[expr, {tries}];][[1]];]; 
  t/tries]

Comments

फिर से किया और agin ... मेरे अपने बैग में प्रवेश करने का समय। tnx!

— डॉ। बेलिसियस

इस कोड के साथ एक समस्या (ठीक है, यह एक पूर्णतावादी का दृष्टिकोण हो सकता है) यह है कि हम कुछ ऐसा पकड़ सकते हैं जिसे हमने फेंका नहीं था, और इसे एक गलत समय परिणाम के रूप में व्याख्या करते हैं। अद्वितीय अपवाद टैग के साथ दोनों Catchका Throwउपयोग किया जाना चाहिए था।

— लियोनिड शिफरीन

टिमो, मुझे खुशी है कि आप इसे शामिल करने के लिए मेरे प्रतिपादन को पसंद करेंगे। मुझे श्रेय देने के लिए भी धन्यवाद। आप जिस तरह से मेरे कोड में सुधार कर रहे हैं, मैं उसके बारे में उत्सुक हूं। मैं अपने स्वयं के कोड में किसी विशेष दिशानिर्देश का पालन नहीं करता हूं, इसके अलावा खुद को पढ़ना आसान बनाता हूं; क्या आपके सुधार के पीछे एक विचारधारा है, या यह सिर्फ वरीयता है? गणितज्ञ सटीक कोड स्वरूपण को प्रोत्साहित नहीं करता है क्योंकि यह इनपुट को रिफ्लेक्ट करता है, लेकिन यहां कोड पोस्ट करने से मुझे इसके बारे में सोचना शुरू करना पड़ रहा है। Btw, मुझे लगता है कि आप मतलब है " Throwऔर Catch" के बजाय " Reapऔर Sow।"

— मि। छिपकली

@Simon, Mr.Wizard, मैं इस पद्धति का उपयोग समय-समय पर छोटे-छोटे कार्यों के विभिन्न संस्करणों के लिए करता हूं जिन्हें बहुत बार कहा जाता है। जरूरी नहीं कि लूप संरचना में हो, लेकिन निश्चित रूप से ऐसे निर्माणों में जो एमएमए का अनुकूलन करता है। इस संदर्भ में लूप का निष्पादन समझ में आता है और प्रदर्शन वास्तविक जीवन के अनुप्रयोग के करीब होगा। समय के लिए बड़े जटिल कार्य (शायद संपूर्ण आरंभिक कोशिकाएं), साइमन द्वारा विधि बेहतर परिणाम देगी। हालांकि सभी के लिए, मैं सापेक्ष मूल्यों में अधिक रुचि रखता हूं और किसी भी तरीके से वहां काम करना चाहिए।

— तिमू

ऐसा करने के लिए अब RepeatedTimingहै।

— मास्टरएक्सिलो

Answer 5

Internal`InheritedBlock

मैंने हाल ही में आधिकारिक समाचार समूह में डैनियल लिक्टब्लॉ के इस संदेशInternal`InheritedBlock से इस तरह के उपयोगी कार्य के अस्तित्व को सीखा है ।

जैसा कि मैंने समझा, दायरे के Internal`InheritedBlockअंदर एक आउटबाउंड फ़ंक्शन की एक प्रति पारित करने की अनुमति देता है Block:

In[1]:= Internal`InheritedBlock[{Message},
Print[Attributes[Message]];
Unprotect[Message];
Message[x___]:=Print[{{x},Stack[]}];
Sin[1,1]
]
Sin[1,1]
During evaluation of In[1]:= {HoldFirst,Protected}
During evaluation of In[1]:= {{Sin::argx,Sin,2},{Internal`InheritedBlock,CompoundExpression,Sin,Print,List}}
Out[1]= Sin[1,1]
During evaluation of In[1]:= Sin::argx: Sin called with 2 arguments; 1 argument is expected. >>
Out[2]= Sin[1,1]

मुझे लगता है कि यह फ़ंक्शन उन सभी के लिए बहुत उपयोगी हो सकता है जिन्हें अंतर्निहित कार्यों को अस्थायी रूप से संशोधित करने की आवश्यकता है!

ब्लॉक के साथ तुलना

हमें कुछ फ़ंक्शन परिभाषित करते हैं:

a := Print[b]

अब हम इस फ़ंक्शन की एक प्रति को Blockदायरे में पारित करना चाहते हैं । अनुभवहीन परीक्षण वह नहीं देता जो हम चाहते हैं:

In[2]:= Block[{a = a}, OwnValues[a]]

During evaluation of In[9]:= b

Out[2]= {HoldPattern[a] :> Null}

अब के पहले तर्क में देरी की परिभाषा का उपयोग करने की कोशिश कर रहा है Block (यह एक अनिर्दिष्ट सुविधा भी है):

In[3]:= Block[{a := a}, OwnValues[a]]
Block[{a := a}, a]

Out[3]= {HoldPattern[a] :> a}

During evaluation of In[3]:= b

हम इस मामले में देखते हैं a काम करता है लेकिन हमें दायरे के aअंदर मूल की एक प्रति नहीं मिली है Block।

अब हम कोशिश करते हैं Internal`InheritedBlock :

In[5]:= Internal`InheritedBlock[{a}, OwnValues[a]]

Out[5]= {HoldPattern[a] :> Print[b]}

हमें दायरे के aअंदर की मूल परिभाषा की एक प्रति मिल गई है Blockऔर हम इसे उस तरह से संशोधित कर सकते हैं जैसे हम वैश्विक परिभाषा को प्रभावित किए बिना चाहते हैं a!

Comments

+1 बहुत आसान! बैग में एक और उपकरण, और आपके लिए विशेषाधिकार संपादित करने के करीब 10 अंक।

— श्री। छिपकली

मेरे लिए यह जल्दी या देर से या बिना और पूर्ण मूल्यांकन के एक संस्करण के रूप में प्रकट होता है।

— user2432923

Answer 6

मैथेमेटिका एक तेज उपकरण है, लेकिन यह आपको कुछ हद तक अप्रभावित व्यवहार और गुप्त निदान संदेशों के हिमस्खलन से काट सकता है । इससे निपटने का एक तरीका इस मुहावरे के बाद के कार्यों को परिभाषित करना है:

ClearAll@zot
SetAttributes[zot, ...]
zot[a_] := ...
zot[b_ /; ...] := ...
zot[___] := (Message[zot::invalidArguments]; Abort[])

यह बहुत सारे बॉयलरप्लेट हैं, जिन्हें मैं अक्सर छोड़ देता हूं। खासकर जब प्रोटोटाइप, जो गणितज्ञ में बहुत कुछ होता है। इसलिए, मैं एक मैक्रो का उपयोग करता हूं defineजो मुझे अनुशासित रहने की अनुमति देता है, बहुत कम बॉयलरप्लेट के साथ।

इसका एक मूल उपयोग defineइस प्रकार है:

define[
  fact[0] = 1
; fact[n_ /; n > 0] := n * fact[n-1]
]

fact[5]

120

यह बहुत पहले की तरह नहीं दिखता है, लेकिन कुछ छिपे हुए लाभ हैं। प्रदान करने वाली पहली सेवा यह defineहै कि यह स्वचालित रूप से लागू होती हैClearAll से परिभाषित किए जा रहे प्रतीक है। यह सुनिश्चित करता है कि कोई बचे हुए परिभाषाएं नहीं हैं - किसी फ़ंक्शन के प्रारंभिक विकास के दौरान एक सामान्य घटना।

दूसरी सेवा यह है कि परिभाषित किया जा रहा फ़ंक्शन स्वचालित रूप से "बंद" है। इसके द्वारा मेरा मतलब है कि फ़ंक्शन एक संदेश जारी करेगा और गर्भपात करेगा यदि इसे एक तर्क सूची के साथ लागू किया जाता है जो कि किसी एक परिभाषा से मेल नहीं खाता है:

fact[-1]

define::badargs: There is no definition for 'fact' applicable to fact[-1].
$Aborted

यह प्राथमिक मूल्य है define, जो त्रुटि के एक बहुत ही सामान्य वर्ग को पकड़ता है।

एक और सुविधा परिभाषित किए जा रहे फ़ंक्शन पर विशेषताओं को निर्दिष्ट करने का एक संक्षिप्त तरीका है। चलो समारोह बनाते हैं Listable:

define[
  fact[0] = 1
; fact[n_ /; n > 0] := n * fact[n-1]
, Listable
]

fact[{3, 5, 8}]

{6, 120, 40320}

सभी सामान्य विशेषताओं के defineअतिरिक्त , एक अतिरिक्त विशेषता को स्वीकार किया जाता है जिसे कहा जाता हैOpen । यह defineफ़ंक्शन में कैच-ऑल एरर डेफिनिशन को जोड़ने से रोकता है:

define[
  successor[x_ /; x > 0] := x + 1
, Open
]

successor /@ {1, "hi"}

{2, successor["hi"]}

एक फ़ंक्शन के लिए कई विशेषताओं को परिभाषित किया जा सकता है:

define[
  flatHold[x___] := Hold[x]
, {Flat, HoldAll}
]

flatHold[flatHold[1+1, flatHold[2+3]], 4+5]

Hold[1 + 1, 2 + 3, 4 + 5]

आगे की हलचल के बिना, यहाँ की परिभाषा है define :

ClearAll@define
SetAttributes[define, HoldAll]
define[body_, attribute_Symbol] := define[body, {attribute}]
define[body:(_Set|_SetDelayed), attributes_List:{}] := define[CompoundExpression[body], attributes]
define[body:CompoundExpression[((Set|SetDelayed)[name_Symbol[___], _])..], attributes_List:{}] :=
  ( ClearAll@name
  ; SetAttributes[name, DeleteCases[attributes, Open]]
  ; If[!MemberQ[attributes, Open]
    , def:name[___] := (Message[define::badargs, name, Defer@def]; Abort[])
    ]
  ; body
  ;
  )
def:define[___] := (Message[define::malformed, Defer@def]; Abort[])

define::badargs = "There is no definition for '``' applicable to ``.";
define::malformed = "Malformed definition: ``";

प्रदर्शित कार्यान्वयन न तो अप-वैल्यूज़ और न ही करीइंग का समर्थन करता है, और न ही साधारण फ़ंक्शन परिभाषा से अधिक सामान्य पैटर्न। हालाँकि यह उपयोगी रहता है।

Comments

+1 - यह वास्तव में उपयोगी सामान है। मैं इसी तरह के उपकरणों का उपयोग कर रहा हूं। मैक्रोज़ (साथ ही आत्मनिरीक्षण और अन्य मेटा-प्रोग्रामिंग तकनीक) बहुत शक्तिशाली हो सकते हैं, लेकिन आमतौर पर मैथेमैटिका समुदाय के भीतर इसकी सराहना की जाती है, या कम से कम यह अब तक मेरी धारणा है।

— लियोनिद शिफरीन

मैंने कुछ इसी तरह की परिभाषा दी है। कई परिभाषाओं को करने के लिए CompoundExpression समर्थन के लिए +1, एबॉर्ट [] (अभी तक अधिक संदेशों की तुलना में बेहतर लगता है) और ओपन (जैसे निर्माणकर्ताओं के लिए अच्छा)।

— मास्टरएक्सिलो

Answer 7

एक खाली नोटबुक खुले बिना शुरू करें

मैथेमेटिका की शुरुआत एक खाली नोटबुक के साथ होने से मैं परेशान था। मैं एक स्क्रिप्ट के साथ इस नोटबुक को बंद कर सकता था, लेकिन यह अभी भी संक्षिप्त रूप से खुलेगा। मेरी हैक एक फाइल बनाने के लिए है Invisible.nb:

Notebook[{},Visible->False]

और इसे मेरे लिए जोड़ें Kernel\init.m:

If[Length[Notebooks["Invisible*"]] > 0, 
  NotebookClose[Notebooks["Invisible*"][[1]]]
]

SetOptions[$FrontEnd,
  Options[$FrontEnd, NotebooksMenu] /. 
    HoldPattern["Invisible.nb" -> {__}] :> Sequence[]
]

अब मैं ओपन करके मैथमैटिक शुरू करता हूं Invisible.nb

एक बेहतर तरीका हो सकता है, लेकिन इसने मुझे अच्छी सेवा दी है।

---

अनुकूलित FoldऔरFoldList

Fold[f, x] के बराबर बनाया गया है Fold[f, First@x, Rest@x]

संयोग से, मेरा मानना ​​है कि यह भविष्य के गणित के संस्करण में अपना रास्ता खोज सकता है।

आश्चर्य! यह लागू किया गया है, हालांकि यह वर्तमान में अनिर्दिष्ट है। मुझे सूचित किया गया है कि इसे 2011 में ओलिवर रूबेंकोनिग द्वारा लागू किया गया था, जाहिर तौर पर लंबे समय के बाद मैंने इसे पोस्ट नहीं किया। शुक्रिया ऑलिवर रुएबेंकोनिग!

Unprotect[Fold, FoldList]

Fold[f_, h_[a_, b__]] := Fold[f, Unevaluated @ a, h @ b]
FoldList[f_, h_[a_, b__]] := FoldList[f, Unevaluated @ a, h @ b]

(* Faysal's recommendation to modify SyntaxInformation *)
SyntaxInformation[Fold]     = {"ArgumentsPattern" -> {_, _, _.}};
SyntaxInformation[FoldList] = {"ArgumentsPattern" -> {_, _., {__}}};

Protect[Fold, FoldList]

इसे अनुमति देने के लिए अद्यतन:

SetAttributes[f, HoldAll]
Fold[f, Hold[1 + 1, 2/2, 3^3]]

f[f[1 + 1, 2/2], 3^3]

---

"गतिशील विभाजन"

Mathematica.SE पोस्ट देखें # 7512इस फ़ंक्शन के नए संस्करण के लिए ।

अक्सर मैं एक सूची को लंबाई के अनुक्रम के अनुसार विभाजित करना चाहता हूं।

छद्म कोड उदाहरण:

partition[{1,2,3,4,5,6}, {2,3,1}]

आउटपुट: {{1,2}, {3,4,5}, {6}}

मैं इसके साथ आया:

dynP[l_, p_] := 
 MapThread[l[[# ;; #2]] &, {{0} ~Join~ Most@# + 1, #} &@Accumulate@p]

मैंने इसके बाद इसे पूरा किया, जिसमें तर्क परीक्षण शामिल है:

dynamicPartition[l_List, p : {_Integer?NonNegative ..}] :=
  dynP[l, p] /; Length@l >= Tr@p

dynamicPartition[l_List, p : {_Integer?NonNegative ..}, All] :=
  dynP[l, p] ~Append~ Drop[l, Tr@p] /; Length@l >= Tr@p

dynamicPartition[l_List, p : {_Integer?NonNegative ..}, n__ | {n__}] :=
  dynP[l, p] ~Join~ Partition[l ~Drop~ Tr@p, n] /; Length@l >= Tr@p

तीसरा तर्क नियंत्रित करता है कि विभाजन विनिर्देश से परे तत्वों का क्या होता है।

---

सज़ाबोल्ट्स मैथमेटिका ट्रिक्स

मैं जो सबसे अधिक बार उपयोग करता हूं वह पेस्ट टेबुलर डेटा पैलेट है

CreatePalette@
 Column@{Button["TSV", 
    Module[{data, strip}, 
     data = NotebookGet[ClipboardNotebook[]][[1, 1, 1]];
     strip[s_String] := 
      StringReplace[s, RegularExpression["^\\s*(.*?)\\s*$"] -> "$1"];
     strip[e_] := e;
     If[Head[data] === String, 
      NotebookWrite[InputNotebook[], 
       ToBoxes@Map[strip, ImportString[data, "TSV"], {2}]]]]], 
   Button["CSV", 
    Module[{data, strip}, 
     data = NotebookGet[ClipboardNotebook[]][[1, 1, 1]];
     strip[s_String] := 
      StringReplace[s, RegularExpression["^\\s*(.*?)\\s*$"] -> "$1"];
     strip[e_] := e;
     If[Head[data] === String, 
      NotebookWrite[InputNotebook[], 
       ToBoxes@Map[strip, ImportString[data, "CSV"], {2}]]]]], 
   Button["Table", 
    Module[{data}, data = NotebookGet[ClipboardNotebook[]][[1, 1, 1]];
     If[Head[data] === String, 
      NotebookWrite[InputNotebook[], 
       ToBoxes@ImportString[data, "Table"]]]]]}

---

बाहरी डेटा को भीतर से संशोधित करें Compile

हाल ही में डैनियल लिच्ब्लाउ ने यह तरीका दिखाया जो मैंने पहले कभी नहीं देखा था। मेरी राय में इसकी उपयोगिता काफी बढ़ जाती हैCompile

ll = {2., 3., 4.};
c = Compile[{{x}, {y}}, ll[[1]] = x; y];

c[4.5, 5.6]

ll

(* Out[1] = 5.6  *)

(* Out[2] = {4.5, 3., 4.}  *)

Comments

+1 एक अच्छा संग्रह! भीतर से बाहरी संशोधनों के बारे में Compile- मेरी पूरी पोस्ट यहाँ: stackoverflow.com/questions/5246330/… , इस संभावना को गैर-तुच्छ सेटिंग में प्रदर्शित करना था (पहले से पोस्ट किए गए प्रश्न में समस्या का एक छोटा और तेज़ समाधान था) । IMO, यहाँ सबसे बड़ी जीत पास-दर-संदर्भ का अनुकरण करने और बड़े संकलित कार्यों को अधिक प्रबंधनीय और पुन: प्रयोज्य विखंडू में तोड़ने की क्षमता है।

— लियोनिद शिफरीन

आप अपनी नई परिभाषा में फोल्ड और फोल्डलिस्ट की वाक्यविन्यास जानकारी को भी समायोजित कर सकते हैं: सिंटैक्स इंफोर्मेशन [फोल्ड] = {"आर्ग्युमेंट्स पाटर्न" -> {_ ,। , _}}; सिंटैक्स इंफॉर्मेशन [फोल्डलिस्ट] = {"आर्ग्युमेंट्स पाटर्न" -> {_, _।, {_ }}};

— faysou

Answer 8

सामान्य पीडीएफ / ईएमएफ निर्यात की समस्याओं और समाधान

1) यह पूरी तरह से अनपेक्षित और अनिर्धारित है, लेकिन गणितज्ञ निर्यात करता है और स्क्रीन पर नोटबुक प्रदर्शित करने के लिए उपयोग की जाने वाली शैली परिभाषाओं के एक सेट का उपयोग करके पीडीएफ और ईपीएस प्रारूपों में ग्राफिक्स बचाता है। डिफ़ॉल्ट रूप से नोटबुक को "वर्किंग" शैली के वातावरण में स्क्रीन पर प्रदर्शित किया जाता है (जो ScreenStyleEvironmentवैश्विक $FrontEndविकल्प के लिए डिफ़ॉल्ट मान है) लेकिन "Printout"शैली के वातावरण में मुद्रित होता है (जो PrintingStyleEnvironmentवैश्विक $FrontEndविकल्प के लिए डिफ़ॉल्ट मान है)। जब कोई रिफ़र प्रारूप जैसे कि GIF और PNG या EMF प्रारूप में ग्राफिक्स का निर्यात करता है, तो Mathematica ग्राफिक्स बनाता है जो बिल्कुल वैसा ही दिखता है जैसा कि नोटबुक के अंदर दिखता है। ऐसा लगता है कि"Working"इस मामले में प्रस्तुत करने के लिए शैली पर्यावरण का उपयोग किया जाता है। लेकिन ऐसा नहीं है जब आप पीडीएफ या ईपीएस प्रारूप में कुछ भी निर्यात / सहेजते हैं! इस मामले में यह "Printout" शैली का वातावरण डिफ़ॉल्ट रूप से उपयोग किया जाता है"वर्किंग" शैली के वातावरण से बहुत गहराई से भिन्न है। सबसे पहले, शैली वातावरण सेट 80% । दूसरे, यह विभिन्न शैलियों के फ़ॉन्ट आकार के लिए अपने स्वयं के मूल्यों का उपयोग करता है और इसके परिणामस्वरूप मूल पीडीएफ स्क्रीन के साथ तुलना में जीनारेटेड पीडीएफ फाइल में असंगत फ़ॉन्ट आकार में परिवर्तन होता है। उत्तरार्द्ध को FontSize उतार-चढ़ाव कहा जा सकता है जो बहुत कष्टप्रद हैं। लेकिन खुशी से "कार्य" के लिए वैश्विक विकल्प की स्थापना करके इससे बचा जा सकता है :"Printout"MagnificationPrintingStyleEnvironment$FrontEnd

SetOptions[$FrontEnd, PrintingStyleEnvironment -> "Working"]

2) EMF प्रारूप में निर्यात करने के साथ आम समस्या यह है कि अधिकांश प्रोग्राम (केवल गणितज्ञ ) एक ऐसी फ़ाइल उत्पन्न करते हैं जो डिफ़ॉल्ट आकार में अच्छी लगती है लेकिन जब आप इसे ज़ूम इन करते हैं तो यह बदसूरत हो जाती है। ऐसा इसलिए है क्योंकि मेटाफ़ाइल्स को स्क्रीन रिज़ॉल्यूशन निष्ठा पर नमूना लिया जाता है । उत्पन्न ईएमएफ फ़ाइल की गुणवत्ता को Magnifyमूल ग्राफिकल ऑब्जेक्ट के द्वारा बढ़ाया जा सकता है ताकि मूल ग्राफिक्स के नमूने की सटीकता अधिक सटीक हो जाए। दो फाइलों की तुलना करें:

graphics1 = 
  First@ImportString[
    ExportString[Style["a", FontFamily -> "Times"], "PDF"], "PDF"];
graphics2 = Magnify[graphics1, 10];
Export["C:\\test1.emf", graphics1]
Export["C:\\test2.emf", graphics2]

यदि आप इन फ़ाइलों को Microsoft Word में सम्मिलित करते हैं और उन्हें ज़ूम इन करते हैं, तो आप देखेंगे कि पहले "a" ने इस पर sawtooth किया है, जबकि दूसरे ने नहीं किया है ( Mathematica 6 के साथ परीक्षण किया गया है )।

क्रिस डेगननImageResolution द्वारा सुझाया गया एक और तरीका (यह विकल्प कम से कम मैथमेटिका 8 से शुरू होता है ):

Export["C:\\test1.emf", graphics1]
Export["C:\\test2.emf", graphics1, ImageResolution -> 300]

3) में मेथेमेटिका हम तीन तरीकों मेटाफ़ाइल में ग्राफिक्स कन्वर्ट करने के लिए है: के माध्यम से Exportकरने के लिए "EMF"(जोरदार सिफारिश की तरीका:, उच्चतम संभव गुणवत्ता के साथ मेटाफ़ाइल) का उत्पादन के माध्यम से Save selection As...मेनू आइटम ( बहुत कम उत्पादन सटीक आंकड़ा , अनुशंसित नहीं) और के माध्यम से Edit ► Copy As ► Metafileमेनू आइटम ( मैं दृढ़ता से अनुशंसा इस मार्ग के खिलाफ )।

Answer 9

लोकप्रिय मांग से, एसओ एपीआई का उपयोग करके शीर्ष -10 एसओ उत्तरदाता भूखंड ( एनोटेशन को छोड़कर ) उत्पन्न करने के लिए कोड ।

getRepChanges[userID_Integer] :=
 Module[{totalChanges},
  totalChanges = 
   "total" /. 
    Import["http://api.stackoverflow.com/1.1/users/" <> 
      ToString[userID] <> "/reputation?fromdate=0&pagesize=10&page=1",
      "JSON"];
  Join @@ Table[
    "rep_changes" /. 
     Import["http://api.stackoverflow.com/1.1/users/" <> 
       ToString[userID] <> 
       "/reputation?fromdate=0&pagesize=10&page=" <> ToString[page], 
      "JSON"],
    {page, 1, Ceiling[totalChanges/10]}
    ]
  ]

topAnswerers = ({"display_name", 
      "user_id"} /. #) & /@ ("user" /. ("top_users" /. 
      Import["http://api.stackoverflow.com/1.1/tags/mathematica/top-\
answerers/all-time", "JSON"]))

repChangesTopUsers =
  Monitor[Table[
    repChange = 
     ReleaseHold[(Hold[{DateList[
              "on_date" + AbsoluteTime["January 1, 1970"]], 
             "positive_rep" - "negative_rep"}] /. #) & /@ 
        getRepChanges[userID]] // Sort;
    accRepChange = {repChange[[All, 1]], 
       Accumulate[repChange[[All, 2]]]}\[Transpose],
    {userID, topAnswerers[[All, 2]]}
    ], userID];

pl = DateListLogPlot[
  Tooltip @@@ 
   Take[({repChangesTopUsers, topAnswerers[[All, 1]]}\[Transpose]), 
    10], Joined -> True, Mesh -> None, ImageSize -> 1000, 
  PlotRange -> {All, {10, All}}, 
  BaseStyle -> {FontFamily -> "Arial-Bold", FontSize -> 16}, 
  DateTicksFormat -> {"MonthNameShort", " ", "Year"}, 
  GridLines -> {True, None}, 
  FrameLabel -> (Style[#, FontSize -> 18] & /@ {"Date", "Reputation", 
      "Top-10 answerers", ""})]

Comments

ब्रेट ने एक प्रश्न पोस्ट किया जो लगभग इस सटीक कोड के लिए पूछ रहा है। शायद यह सबसे उपयुक्त है, प्रश्न को फिट करने के लिए एक या दो के साथ। मैं वास्तव में इस सवाल पर विरोध के रूप में, वास्तव में दोहराए जाने योग्य होगा।

— रंगरेल

@rcollyer सही है। यह "कम्युनिटी विकी" है

— डॉ। बेलिसरियस

@ सबिसरियस मैंने इसे ब्रेट के प्रश्न के उत्तर में कॉपी किया ...

— सॉजरड सी। डे वीस

@ यहाँ अपना प्लॉट स्वतः अपडेट न करें।

— डॉ। बेलीज़ेरिक

@belisarius वास्तव में मैं उम्मीद कर रहा था कि आप उस कार्य को आप पर ले जा रहे हैं ... ;-)

— Sjoerd C. de Vries

Answer 10

कैशिंग भाव

मैं किसी भी अभिव्यक्ति को कैश करने के लिए इन कार्यों को बहुत उपयोगी मानता हूं। इन दो कार्यों के लिए यहाँ दिलचस्प बात यह है कि आयोजित अभिव्यक्ति ही हैशटेबल / प्रतीक कैश या कैशेइंडेक्स की कुंजी के रूप में उपयोग की जाती है, मैथमेटिका में जाने-माने संस्मरण की तुलना में जहां आप केवल परिणाम को कैश कर सकते हैं यदि फ़ंक्शन को एफ की तरह परिभाषित किया गया है। [x_]: = f [x] = ... तो आप किसी कोड के किसी भी भाग को कैश कर सकते हैं, यह उपयोगी है यदि किसी फ़ंक्शन को कई बार कॉल किया जाना है, लेकिन कोड के कुछ हिस्सों को फिर से जोड़ा नहीं जाना चाहिए।

इसके तर्कों को स्वतंत्र रूप से अभिव्यक्ति देने के लिए।

SetAttributes[Cache, HoldFirst];
c:Cache[expr_] := c = expr;

Ex: Cache[Pause[5]; 6]
Cache[Pause[5]; 6]

दूसरी बार अभिव्यक्ति बिना प्रतीक्षा के 6 लौटेगी।

एक उपनाम अभिव्यक्ति का उपयोग करके कैश करने के लिए जो कैश्ड अभिव्यक्ति के तर्क पर निर्भर कर सकता है।

SetAttributes[CacheIndex, HoldRest];
c:CacheIndex[index_,expr_] := c = expr;

Ex: CacheIndex[{"f",2},x=2;y=4;x+y]

यदि expr को गणना करने में कुछ समय लगता है, तो कैश्ड परिणाम को पुनः प्राप्त करने के लिए उदाहरण के लिए {"f", 2} का मूल्यांकन करना अधिक तेज़ है।

स्थानीय कैश रखने के लिए इन कार्यों की भिन्नता के लिए (अर्थात। कैश मेमोरी स्वचालित रूप से ब्लॉक निर्माण के बाहर जारी की जाती है) इस पोस्ट को देखें इंटरपोल के बार-बार कॉल से बचें

कैश्ड मूल्यों को हटाना

कैश्ड मान को हटाने के लिए जब आप किसी फ़ंक्शन की परिभाषाओं की संख्या नहीं जानते हैं। मैं मानता हूं कि परिभाषाओं में उनके तर्कों में कहीं न कहीं एक रिक्तता है।

DeleteCachedValues[f_] := 
       DownValues[f] = Select[DownValues[f], !FreeQ[Hold@#,Pattern]&];

कैश्ड मान को हटाने के लिए जब आप किसी फ़ंक्शन की परिभाषाओं की संख्या जानते हैं (थोड़ा तेज हो जाता है)।

DeleteCachedValues[f_,nrules_] := 
       DownValues[f] = Extract[DownValues[f], List /@ Range[-nrules, -1]];

यह इस तथ्य का उपयोग करता है कि किसी फ़ंक्शन की परिभाषाएं उनकी डाउनवैल्यूज़ सूची के अंत में हैं, कैश्ड मान पहले हैं।

डेटा और ऑब्जेक्ट जैसे कार्यों को संग्रहीत करने के लिए प्रतीकों का उपयोग करना

इसके अलावा यहां वस्तुओं की तरह प्रतीकों का उपयोग करने के लिए दिलचस्प कार्य हैं।

यह पहले से ही अच्छी तरह से जाना जाता है कि आप प्रतीकों में डेटा स्टोर कर सकते हैं और डाउनवैल्यूस का उपयोग करके जल्दी से उन्हें एक्सेस कर सकते हैं

mysymbol["property"]=2;

आप इस साइट पर एक पोस्ट में प्रस्तुत किए गए ड्रीव्स के आधार पर इन कार्यों का उपयोग करके एक प्रतीक की कुंजी (या गुण) की सूची तक पहुंच सकते हैं:

SetAttributes[RemoveHead, {HoldAll}];
RemoveHead[h_[args___]] := {args};
NKeys[symbol_] := RemoveHead @@@ DownValues[symbol(*,Sort->False*)][[All,1]];
Keys[symbol_] := NKeys[symbol] /. {x_} :> x;

मैं इस फ़ंक्शन का उपयोग किसी प्रतीक के डाउनवैल्यू में निहित सभी इन्फोस को प्रदर्शित करने के लिए करता हूं:

PrintSymbol[symbol_] :=
  Module[{symbolKeys},
    symbolKeys = Keys[symbol];
    TableForm@Transpose[{symbolKeys, symbol /@ symbolKeys}]
  ];

अंत में यहां एक प्रतीक बनाने का एक सरल तरीका है जो ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग में ऑब्जेक्ट की तरह व्यवहार करता है (यह सिर्फ ओओपी के सबसे बुनियादी व्यवहार को पुन: पेश करता है लेकिन मुझे वाक्यविन्यास सुरुचिपूर्ण लगता है):

Options[NewObject]={y->2};
NewObject[OptionsPattern[]]:=
  Module[{newObject},
    newObject["y"]=OptionValue[y];

    function[newObject,x_] ^:= newObject["y"]+x;
    newObject /: newObject.function2[x_] := 2 newObject["y"]+x;

    newObject
  ];

गुणों को डाउनवैल्यूस और तरीकों के रूप में संग्रहीत किया जाता है, जो कि मॉड्यूल द्वारा बनाए गए प्रतीक में विलंबित उपवाक्य के रूप में दिया जाता है। मुझे फ़ंक्शन 2 के लिए सिंटैक्स मिला, जो कि कार्यों के लिए सामान्य OO- सिंटैक्स है मैथमेटिका ट्री डेटा संरचना में ।

प्रत्येक प्रतीक के मौजूदा प्रकारों की सूची के लिए, देखें http://reference.wolfram.com/mathematica/tutorial/PatternsAndTransformationRules.html और http://www.verbeia.com/mathematica/tips/HTML/ink/Tricks_Misc_4.html ।

उदाहरण के लिए यह प्रयास करें

x = NewObject[y -> 3];
function[x, 4]
x.function2[5]

यदि आप यहां उपलब्ध InheritRules नामक पैकेज का उपयोग करके ऑब्जेक्ट इनहेरिटेंस का अनुकरण करना चाहते हैं, तो आप http://library.wolfram.com/infocenter/MathSource/671/ पर उपलब्ध हैं।

आप फ़ंक्शन परिभाषा को newObject में नहीं, बल्कि एक प्रकार के प्रतीक में भी संग्रहीत कर सकते हैं, इसलिए यदि NewObject ने टाइप किया [newObject] तो newObject के बजाय आप फ़ंक्शन और फ़ंक्शन 2 को इस तरह से परिभाषित कर सकते हैं जैसे कि NewObject (और अंदर नहीं) और पहले जैसा ही उपयोग हो। ।

function[type[object_], x_] ^:= object["y"] + x;
type /: type[object_].function2[x_] := 2 object["y"]+x;

UpValues ​​का उपयोग करें [प्रकार] यह देखने के लिए कि फ़ंक्शन और फ़ंक्शन 2 प्रकार के प्रतीक में परिभाषित किए गए हैं।

इस अंतिम सिंटैक्स के बारे में आगे के विचार यहां दिए गए हैं https://mathematica.stackexchange.com/a/999/66 ।

SelectEquivalents का बेहतर संस्करण

@ कोलर: चयनकर्ताओं को सतह पर लाने के लिए बहुत धन्यवाद, यह एक अद्भुत कार्य है। यहां अधिक संभावनाओं और विकल्पों का उपयोग करके ऊपर सूचीबद्ध SelectEquivalents का बेहतर संस्करण है, इससे इसका उपयोग करना आसान हो जाता है।

Options[SelectEquivalents] = 
   {
      TagElement->Identity,
      TransformElement->Identity,
      TransformResults->(#2&) (*#1=tag,#2 list of elements corresponding to tag*),
      MapLevel->1,
      TagPattern->_,
      FinalFunction->Identity
   };

SelectEquivalents[x_List,OptionsPattern[]] := 
   With[
      {
         tagElement=OptionValue@TagElement,
         transformElement=OptionValue@TransformElement,
         transformResults=OptionValue@TransformResults,
         mapLevel=OptionValue@MapLevel,
         tagPattern=OptionValue@TagPattern,
         finalFunction=OptionValue@FinalFunction
      }
      ,
      finalFunction[
         Reap[
            Map[
               Sow[
                  transformElement@#
                  ,
                  {tagElement@#}
               ]&
               , 
               x
               , 
               {mapLevel}
            ] 
            , 
            tagPattern
            , 
            transformResults
         ][[2]]
      ]
   ];

इस संस्करण का उपयोग कैसे किया जा सकता है, इसके उदाहरण इस प्रकार हैं:

Mathematica का उपयोग कर इकट्ठा / ठीक से इकट्ठा

आप Mathematica में PivotTable फ़ंक्शन कैसे करेंगे?

मैथेमेटिका फास्ट 2 डी बिनिंग एल्गोरिथ्म

Internal`Bag

डैनियल लिक्टब्लौ ने यहां बढ़ती सूचियों के लिए एक दिलचस्प आंतरिक डेटा संरचना का वर्णन किया है।

गणितज्ञों में चतुष्कोण लागू करना

डिबगिंग कार्य

ये दो पोस्ट डीबगिंग के लिए उपयोगी कार्यों की ओर इशारा करते हैं:

Mathematica का उपयोग करते हुए छोटे या बड़े कोड को लिखते समय डिबग कैसे करें? कार्यक्षेत्र? एमएमए डिबगर? या कुछ और? (इसे दिखाना)

/programming/5459735/the-clearest-way-to-repret-mathematicas-evaluation-fterence/5527117#5527117 (TraceView)

एक कार्यक्रम के विभिन्न हिस्सों से भाव निकालने और उन्हें एक प्रतीक में संग्रहीत करने के लिए रीप एंड सो पर आधारित एक और फ़ंक्शन है।

SetAttributes[ReapTags,HoldFirst];
ReapTags[expr_]:=
   Module[{elements},
      Reap[expr,_,(elements[#1]=#2/.{x_}:>x)&];
      elements
   ];

यहाँ एक उदाहरण है

ftest[]:=((*some code*)Sow[1,"x"];(*some code*)Sow[2,"x"];(*some code*)Sow[3,"y"]);
s=ReapTags[ftest[]];
Keys[s]
s["x"]
PrintSymbol[s] (*Keys and PrintSymbol are defined above*)

अन्य संसाधन

यहाँ सीखने के उद्देश्य के लिए दिलचस्प लिंक की एक सूची है:

गणित सीखने के संसाधनों का एक संग्रह

यहां अपडेट करें: https://mathematica.stackexchange.com/a/259/66

Comments

संबंधित: " स्मृति के साथ एक फ़ंक्शन बनाने का सबसे अच्छा तरीका "। WReach ने सरल फ़ंक्शन का एक अद्भुत उदाहरण दिया है जो न केवल इसके मूल्यों को याद रखता है, बल्कि उन्हें एक फ़ाइल में भी लिखता है और पुनः आरंभ के लिए पीछे की ओर पढ़ता है।

— एलेक्सी पोपकोव

संबंधित: " मैथमेटिका: एक प्रतीक के लिए कैश को कैसे साफ़ करें, यानी पैटर्न-डाउन डाउनवैल्यूज़ "। यह प्रश्न दिखाता है कि मानक f[x_] := f[x] = some codeसंस्मरण का उपयोग करके कैश को कैसे साफ़ किया जाए ।

— साइमन

+1 एक अच्छी सूचनात्मक सुविधा है जो कैशिंग फ़ंक्शन में परिभाषा के बाईं ओर दोहराए जाने की आवश्यकता को समाप्त करती है, जैसे c:Cache[expr_] := c = expr:।

— अपराह्न

का अच्छा संस्करण है SelectEquivalents। मुझे लगता है, मैं TagOnElementदूसरे परम डिफ़ॉल्ट के रूप में रखना चाहूंगा Identityक्योंकि यह उनमें से सबसे अधिक उपयोग किया जाता है, हालांकि। मुझे नहीं लगता कि मैं इसमें शामिल था FinalOp, या तो, क्योंकि इसे भीतर संभाला जा सकता है OpOnTaggedElems। मैं विकल्प नामों को भी छोटा करूँगा, क्योंकि उनकी लंबाई इसे टाइप करने के लिए अजीब बनाती है। प्रयास करें TagFunction, TransformElement, TransformResults, और TagPatternबजाय। दोनों, TagPatternऔर MapLevelकार्यक्षमता के महान जोड़ हैं, और एक अच्छा फिर से लिखना, समग्र रूप से।

— 19col पर रॉल्कर

आपकी टिप्पणी rcollyer के लिए धन्यवाद। मैंने इसे ध्यान में रखा और कोड की पठनीयता में सुधार किया। मैं फ़ाइनलफ़ंक्शन रखता हूं क्योंकि यह रीप के परिणाम पर संचालित होता है, उदाहरण के लिए यदि आप अपने अंतिम परिणाम को टैग द्वारा सॉर्ट करना चाहते हैं यदि आप उन्हें रखते हैं।

— faysou

Answer 11

मेरी उपयोगिता फ़ंक्शंस (मेरे पास ये एमएएसएच में निर्मित है, जो प्रश्न में वर्णित है):

pr = WriteString["stdout", ##]&;            (* More                           *)
prn = pr[##, "\n"]&;                        (*  convenient                    *)
perr = WriteString["stderr", ##]&;          (*   print                        *)
perrn = perr[##, "\n"]&;                    (*    statements.                 *)
re = RegularExpression;                     (* I wish mathematica             *)
eval = ToExpression[cat[##]]&;              (*  weren't so damn               *)
EOF = EndOfFile;                            (*   verbose!                     *)
read[] := InputString[""];                  (* Grab a line from stdin.        *)
doList[f_, test_] :=                        (* Accumulate list of what f[]    *)
  Most@NestWhileList[f[]&, f[], test];      (*  returns while test is true.   *)
readList[] := doList[read, #=!=EOF&];       (* Slurp list'o'lines from stdin. *)
cat = StringJoin@@(ToString/@{##})&;        (* Like sprintf/strout in C/C++.  *)
system = Run@cat@##&;                       (* System call.                   *)
backtick = Import[cat["!", ##], "Text"]&;   (* System call; returns stdout.   *)
slurp = Import[#, "Text"]&;                 (* Fetch contents of file as str. *)
                                            (* ABOVE: mma-scripting related.  *)
keys[f_, i_:1] :=                           (* BELOW: general utilities.      *)
  DownValues[f, Sort->False][[All,1,1,i]];  (* Keys of a hash/dictionary.     *)
SetAttributes[each, HoldAll];               (* each[pattern, list, body]      *)
each[pat_, lst_, bod_] := ReleaseHold[      (*  converts pattern to body for  *)
  Hold[Cases[Evaluate@lst, pat:>bod];]];    (*   each element of list.        *)
some[f_, l_List] := True ===                (* Whether f applied to some      *)
  Scan[If[f[#], Return[True]]&, l];         (*  element of list is True.      *)
every[f_, l_List] := Null ===               (* Similarly, And @@ f/@l         *)
  Scan[If[!f[#], Return[False]]&, l];       (*  (but with lazy evaluation).   *)

Comments

"प्रत्येक" समारोह के लिए, देखें stackoverflow.com/questions/160216/foreach-loop-in-mathematica

— dreeves

Answer 12

मेरे द्वारा उपयोग की गई एक चाल, जो आपको खराब तर्कों के साथ काम करने के तरीके का अनुकरण करने की अनुमति देती है (एक संदेश भेजकर और फिर पूरे फॉर्म को बिना शर्त लौटाते हुए) एक विक्षेप में Conditionउपयोग किए जाने पर काम करने का तरीका बताता है। यदि fooकेवल एक तर्क के साथ काम करना चाहिए:

foo[x_] := x + 1;
expr : foo[___] /; (Message[foo::argx, foo, Length@Unevaluated[expr], 1]; 
                    False) := Null; (* never reached *)

यदि आपके पास अधिक जटिल आवश्यकताएं हैं, तो तर्क सत्यापन और संदेश निर्माण को स्वतंत्र कार्य के रूप में समझना आसान है। आप Conditionकेवल उत्पन्न संदेश से परे साइड इफेक्ट्स का उपयोग करके अधिक विस्तृत चीजें कर सकते हैं , लेकिन मेरी राय में उनमें से अधिकांश "स्लीज़ी हैक" श्रेणी में आते हैं और यदि संभव हो तो उन्हें टाला जाना चाहिए।

इसके अलावा, "मेटाप्रोग्रामिंग" श्रेणी में, यदि आपके पास एक गणितज्ञ पैकेज ( .m) फ़ाइल है, तो आप फ़ाइल में लिपटे सभी भावों को प्राप्त करने के लिए "HeldExpressions"तत्व का उपयोग कर सकते हैं HoldComplete। इससे टेक्स्ट-आधारित खोजों का उपयोग करने से चीजों को ट्रैक करना बहुत आसान हो जाता है। दुर्भाग्य से, नोटबुक के साथ एक ही काम करने का कोई आसान तरीका नहीं है, लेकिन आप निम्नलिखित की तरह कुछ का उपयोग करके सभी इनपुट अभिव्यक्ति प्राप्त कर सकते हैं:

inputExpressionsFromNotebookFile[nb_String] :=
 Cases[Get[nb],
  Cell[BoxData[boxes_], "Input", ___] :>
   MakeExpression[StripBoxes[boxes], StandardForm],
  Infinity]

अंत में, आप इस तथ्य का उपयोग कर सकते हैं कि Moduleसंदर्भ प्रकारों के बराबर बनाने के लिए शाब्दिक क्लोजर का अनुकरण करता है। यहां एक सरल स्टैक (जो Conditionबोनस के रूप में त्रुटि से निपटने के लिए एक चाल का उपयोग करता है ):

ClearAll[MakeStack, StackInstance, EmptyQ, Pop, Push, Peek]
 With[{emptyStack = Unique["empty"]},
  Attributes[StackInstance] = HoldFirst;
  MakeStack[] :=
   Module[{backing = emptyStack},
    StackInstance[backing]];

  StackInstance::empty = "stack is empty";

  EmptyQ[StackInstance[backing_]] := (backing === emptyStack);

  HoldPattern[
    Pop[instance : StackInstance[backing_]]] /;
    ! EmptyQ[instance] || (Message[StackInstance::empty]; False) :=
   (backing = Last@backing; instance);

  HoldPattern[Push[instance : StackInstance[backing_], new_]] :=
   (backing = {new, backing}; instance);

  HoldPattern[Peek[instance : StackInstance[backing_]]] /;
    ! EmptyQ[instance] || (Message[StackInstance::empty]; False) :=
   First@backing]

अब आप एक सूची के तत्वों को उल्टे क्रम में एक अनावश्यक रूप से जटिल तरीके से प्रिंट कर सकते हैं!

With[{stack = MakeStack[], list},
 Do[Push[stack, elt], {elt, list}];

 While[!EmptyQ[stack],
  Print[Peek@stack];
  Pop@stack]]

Comments

HeldExpressionsसंकुल में तत्व के लिए +1 , इससे अनजान था। मैं आमतौर पर स्ट्रिंग के रूप में आयात करने गया था और तब का उपयोग कर ToExpressionके साथ HoldCompleteपिछले आर्ग के रूप में। का उपयोग कर के बारे में Conditionसंदेशों के लिए - यह कम से कम 1994 के बाद से पैकेज लिखित रूप में एक मानक तकनीक के माध्यम से दृढ़ता के बारे में किया गया है Moduleवार्स - मैं एक लंबे समय पहले Mathgroup पर उस पर पोस्ट किया है: groups.google.com/group/comp.soft- sys.math.mathematica /… (उस थ्रेड में मेरी तीसरी पोस्ट), यह एक ही पंक्तियों के साथ है और उपयोग के कुछ nontrivial उदाहरणों के लिए लिंक है।

— लियोनिद शिफरीन

@ लियोनिड शिफरीन: मैंने इस Conditionकाम को विद्या के रूप में उठाया , शायद एक सहकर्मी से, लेकिन यह महसूस नहीं किया कि यह एक मानक तकनीक थी। Moduleप्रतीकों को संदर्भ प्रकारों के रूप में उपयोग करने के बारे में लिंक दिलचस्प है!

— पिल्ले

+1, मैंने ऐसा कभी नहीं सोचा था। जितना अधिक मैं इस भाषा के बारे में सीखता हूं उतना अधिक शक्तिशाली लगता है।

— rcollyer

@Pills इस तरह से एक स्टैक करने का उद्देश्य क्या है?

— मि। छिपकली

@ Mr.Wizard: मैंने अभी सबसे सरल म्यूटेबल डेटा संरचनाओं में से एक को चुना है जो मैं तकनीक का वर्णन करने के लिए सोच सकता था।

— पिल्ले

Answer 13

संदर्भ के बिना मुद्रण प्रणाली प्रतीक परिभाषाएँ प्रचलित हुईं

contextFreeDefinition[]नीचे समारोह सबसे आम संदर्भ prepended बिना एक प्रतीक की परिभाषा मुद्रित करने के लिए प्रयास करेंगे। तब परिभाषा को वर्कबेन्च में कॉपी किया जा सकता है और पठनीयता के लिए स्वरूपित किया जाता है (इसे चुनें, राइट क्लिक करें, स्रोत -> प्रारूप)

Clear[commonestContexts, contextFreeDefinition]

commonestContexts[sym_Symbol, n_: 1] := Quiet[
  Commonest[
   Cases[Level[DownValues[sym], {-1}, HoldComplete], 
    s_Symbol /; FreeQ[$ContextPath, Context[s]] :> Context[s]], n],
  Commonest::dstlms]

contextFreeDefinition::contexts = "Not showing the following contexts: `1`";

contextFreeDefinition[sym_Symbol, contexts_List] := 
 (If[contexts =!= {}, Message[contextFreeDefinition::contexts, contexts]];
  Internal`InheritedBlock[{sym}, ClearAttributes[sym, ReadProtected];
   Block[{$ContextPath = Join[$ContextPath, contexts]}, 
    Print@InputForm[FullDefinition[sym]]]])

contextFreeDefinition[sym_Symbol, context_String] := 
 contextFreeDefinition[sym, {context}]

contextFreeDefinition[sym_Symbol] := 
 contextFreeDefinition[sym, commonestContexts[sym]]

---

withRules []

कैविएट: यह फ़ंक्शन वैरिएबल को उसी तरह से स्थानीय नहीं करता है Withऔर Moduleकरते हैं, जिसका अर्थ है कि नेस्टेड स्थानीयकरण निर्माण अपेक्षा के अनुरूप काम नहीं करेगा। प्रतिस्थापित withRules[{a -> 1, b -> 2}, With[{a=3}, b_ :> b]] करेगाa और bनेस्टेड में Withऔर Rule, जबकि Withऐसा नहीं करता है।

इस का एक संस्करण है Withकि का उपयोग करता है के बजाय नियम =और :=:

ClearAll[withRules]
SetAttributes[withRules, HoldAll]
withRules[rules_, expr_] :=
  Internal`InheritedBlock[
    {Rule, RuleDelayed},
    SetAttributes[{Rule, RuleDelayed}, HoldFirst];
    Unevaluated[expr] /. rules
  ]

प्रयोग और स्थानीयकरण चर के दौरान लिखे गए कोड को साफ करते हुए मुझे यह उपयोगी लगा। कभी-कभी मैं के रूप में पैरामीटर सूचियों के साथ समाप्त होता है{par1 -> 1.1, par2 -> 2.2} । withRulesपैरामीटर मान के साथ वैश्विक चर का उपयोग करते हुए पहले लिखे गए कोड को इंजेक्ट करना आसान है।

उपयोग कुछ इस प्रकार है With:

withRules[
  {a -> 1, b -> 2},
  a+b
]

---

Antialiasing 3 डी ग्राफिक्स

यह एंटीलिया 3 डी ग्राफिक्स के लिए एक बहुत ही सरल तकनीक है, भले ही आपके ग्राफिक्स हार्डवेयर इसे मूल रूप से समर्थन न करें।

antialias[g_, n_: 3] := 
  ImageResize[Rasterize[g, "Image", ImageResolution -> n 72], Scaled[1/n]]

यहाँ एक उदाहरण है:

ध्यान दें कि nग्राफिक्स ड्राइवर बग्स को उजागर करने या कलाकृतियों को पेश करने के लिए एक बड़े मूल्य या बड़े छवि आकार के लिए जाता है।

---

नोटबुक में अलग कार्यक्षमता है

नोटबुक की भिन्न कार्यक्षमता <<AuthorTools`पैकेज में उपलब्ध है , और कम से कम (संस्करण 8 में) अनिर्दिष्ट NotebookTools`संदर्भ में। वर्तमान में खुले दो नोटबुक को बदलने के लिए यह थोड़ा GUI है:

PaletteNotebook@DynamicModule[
  {nb1, nb2}, 
  Dynamic@Column[
    {PopupMenu[Dynamic[nb1], 
      Thread[Notebooks[] -> NotebookTools`NotebookName /@ Notebooks[]]], 
     PopupMenu[Dynamic[nb2], 
      Thread[Notebooks[] -> NotebookTools`NotebookName /@ Notebooks[]]], 
     Button["Show differences", 
      CreateDocument@NotebookTools`NotebookDiff[nb1, nb2]]}]
  ]

Comments

सभी अच्छा होगा, लेकिन यह वास्तव में चर का स्थानीयकरण नहीं करता है , जैसा कि आप a = 3; b = 4;अपने उदाहरण कॉल से पहले कहकर और फिर कॉल करके देख सकते हैं withRules। आप निम्न का उपयोग करके इसे बचा सकते हैं SetAttributes[withRules, HoldAll];withRules[rules_, expr_] := Unevaluated[expr] /. Unevaluated[rules]:। Withतत्कालीन मतभेद शब्दार्थ : 1. नियमों के खंडों का अब मूल्यांकन नहीं किया withRulesजाता Withहै। जैसा कि आंतरिक स्कैपिंग निर्माणों के साथ नामकरण टकराव को हल नहीं करता है। अंतिम एक बहुत गंभीर है - मामले के आधार पर अच्छी या बुरी चीज होना।

— लियोनिद शिफरीन

@ लॉयनिड आप पूरी तरह से सही हैं, ऐसा लगता है कि मैं पोस्ट करने से पहले कोड को ठीक से जांचना कभी नहीं सीखता ... जब मैं इसका उपयोग करता हूं तो मैं व्यावहारिक रूप से कभी भी चर को मान नहीं देता हूं, लेकिन यह एक बहुत गंभीर समस्या है, आप सही हैं। आप सही संस्करण के बारे में क्या सोचते हैं? (मैं वास्तव में नेस्टेड Withएस से निपटने के बारे में परवाह नहीं करता हूं । यह हमेशा बिल्टइन स्थानीयकरण के निर्माण के साथ काम नहीं करता है, उदाहरण के लिए With[{a=1}, Block[{a=2}, a]]। क्या आपको लगता है कि वहाँ अच्छा कारण है कि नेस्टेड Blockवहाँ स्थानीयकरण नहीं करता है, जैसे नेस्टेड Withऔर Moduleक्या?)

— शाजबोलों

@ लियोनिड मैं बस Unevaluated[rules]इसलिए इस्तेमाल नहीं किया क्योंकि मैं x -> 1+1आरएचएस का मूल्यांकन करना चाहता था ।

— शेजाबल्स

@ लियोनिड आप वास्तव में सही हैं, नेस्टेड स्थानीयकरण मुद्दा काफी गंभीर हो सकता है। मुझे लगता है कि नेस्टेड Withरों को पहचानने और से बचने के लिए आसान है, लेकिन पैटर्न नहीं हैं: With[{a = 1}, a_ -> a]localizes भीतरी aजबकि withRulesऐसा नहीं करता। क्या आप जानते हैं कि क्या मैथेमेटिका के आंतरिक स्थानीयकरण तंत्र तक पहुंचने और नए निर्माण (इसी तरह Rule) करने का कोई तरीका है जो स्थानीय भी हो? मैं शायद बाद में इस उत्तर को हटा दूंगा क्योंकि यह उपयोगी से अधिक खतरनाक है, लेकिन मैं इसके साथ थोड़ा और अधिक खेलना चाहता हूं।

— शेजाबल्क्स

मुझे लगता है कि आपका उपयोग InheritedBlockबहुत अच्छा है और समस्या को बहुत ही सुरुचिपूर्ण ढंग से हल करता है। स्कोपिंग संघर्ष के लिए, सामान्य रूप से लेक्सिकल स्कूपिंग के लिए बाइंडिंग "लेक्सिकल बाइंडिंग टाइम" में होती है, जो है - रन-टाइम से पहले, जबकि डायनेमिक स्कूपिंग रन-टाइम पर बांधता है, जो इसे समझा सकता है। आप इसके लिए इसी तरह के मामले के साथ विपरीत कर सकते हैं Module, जो एक रचनात्मक उपयोग की अनुमति देता है (उदाहरण के लिए यहां stackoverflow.com/questions/7394113/… देखें )। समस्या यह है कि Blockकुछ प्रतीक की जरूरत है ...

— लियोनिद शिफरीन

Answer 14

पुनरावर्ती शुद्ध कार्य ( #0) भाषा के गहरे कोनों में से एक प्रतीत होते हैं। यहां उनके उपयोग के गैर-तुच्छ उदाहरणों के एक जोड़े हैं, जहां यह वास्तव में उपयोगी है (ऐसा नहीं है कि वे इसके बिना नहीं किया जा सकता है)। निम्नलिखित एक रेखांकन में जुड़े घटकों को खोजने के लिए एक बहुत संक्षिप्त और यथोचित तेजी से कार्य है, कोने के जोड़े के रूप में निर्दिष्ट किनारों की एक सूची दी गई है:

ClearAll[setNew, componentsBFLS];
setNew[x_, x_] := Null;
setNew[lhs_, rhs_]:=lhs:=Function[Null, (#1 := #0[##]); #2, HoldFirst][lhs, rhs];

componentsBFLS[lst_List] := Module[{f}, setNew @@@ Map[f, lst, {2}];
   GatherBy[Tally[Flatten@lst][[All, 1]], f]];

यहाँ क्या होता है कि हम सबसे पहले प्रत्येक शीर्ष संख्या पर एक डमी चिन्ह को मैप करते हैं, और फिर एक तरीका सेट करते हैं, जो कि एक जोड़ी वर्टिस दिया जाता है {f[5],f[10]}, कहते हैं, फिर f[5]मूल्यांकन करेंगे f[10]। पुनरावर्ती शुद्ध कार्य का उपयोग एक पथ कंप्रेसर के रूप में किया जाता है (इस तरह से ज्ञापन स्थापित करने के लिए कि लंबी श्रृंखलाओं के बजाय f[1]=f[3],f[3]=f[4],f[4]=f[2], ..., जब भी घटक का एक नया "रूट" खोजा जाता है, तो संस्मरणित मान सही हो जाता है। यह एक महत्वपूर्ण गति देता है। क्योंकि हम असाइनमेंट का उपयोग करते हैं, हमें इसकी आवश्यकता है होल्डऑल, जो इस निर्माण को और भी अस्पष्ट और अधिक आकर्षक बनाता है)। यह फ़ंक्शन फ्रेड सीमन्स, ज़ाबोलक्स होर्वाट, ड्रामोरबॉब और आपके साथ वास्तव में ऑन-ऑफ-लाइन माथग्रुप चर्चा का परिणाम है। उदाहरण:

In[13]:= largeTest=RandomInteger[{1,80000},{40000,2}];

In[14]:= componentsBFLS[largeTest]//Short//Timing
Out[14]= {0.828,{{33686,62711,64315,11760,35384,45604,10212,52552,63986,  
     <<8>>,40962,7294,63002,38018,46533,26503,43515,73143,5932},<<10522>>}}

बिल्ट-इन की तुलना में यह निश्चित रूप से बहुत धीमा है, लेकिन कोड के आकार के लिए, काफी तेज अभी भी आईएमओ है।

एक अन्य उदाहरण: यहां एक पुनरावर्ती बोध है Select, जो लिंक्ड सूची और पुनरावर्ती शुद्ध कार्यों के आधार पर है:

selLLNaive[x_List, test_] :=
  Flatten[If[TrueQ[test[#1]],
     {#1, If[#2 === {}, {}, #0 @@ #2]},
     If[#2 === {}, {}, #0 @@ #2]] & @@ Fold[{#2, #1} &, {}, Reverse[x]]];

उदाहरण के लिए,

In[5]:= Block[
         {$RecursionLimit= Infinity},
         selLLNaive[Range[3000],EvenQ]]//Short//Timing

Out[5]= {0.047,{2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,
 <<1470>>,2972,2974,2976,2978,2980,2982,2984,2986,2988,2990,
  2992,2994,2996,2998,3000}}

यह ठीक से पूंछ पुनरावृत्ति नहीं है, और बड़ी सूची के लिए स्टैक (कर्नेल को क्रैश) को उड़ा देगा। यहाँ पूंछ-पुनरावर्ती संस्करण है:

selLLTailRec[x_List, test_] :=
Flatten[
 If[Last[#1] === {},
  If[TrueQ[test[First[#1]]],
   {#2, First[#1]}, #2],
  (* else *)
  #0[Last[#1],
   If[TrueQ[test[First[#1]]], {#2, First[#1]}, #2]
   ]] &[Fold[{#2, #1} &, {}, Reverse[x]], {}]];

उदाहरण के लिए,

In[6]:= Block[{$IterationLimit= Infinity},
       selLLTailRec[Range[500000],EvenQ]]//Short//Timing
Out[6]= {2.39,{2,4,6,8,10,12,14,16,18,20,22,
       <<249978>>,499980,499982,499984,499986,499988,499990,499992,
        499994,499996,499998,500000}} 

Comments

जुड़े घटकों के लिए कार्य अभी भी मेरा पसंदीदा है :-)

— शैबॉलेक्स

@Szabolcs हाँ, यह बहुत अच्छा है। आप और फ्रेड ने इसे सबसे अधिक किया, बॉबी और मैंने केवल कुछ शोधन किए, IIRC।

— लियोनिद शिफरीन 28:11

Answer 15

यह स्टेन वैगन की किताब की रेसिपी है ... इसे तब इस्तेमाल करें जब बिल्ट-इन प्लॉट सटीक की कमी के कारण गलत तरीके से व्यवहार करता है

Options[PrecisePlot] = {PrecisionGoal -> 6};
PrecisePlot[f_, {x_, a_, b_}, opts___] := Module[{g, pg},
   pg = PrecisionGoal /. {opts} /. Options[PrecisePlot];
   SetAttributes[g, NumericFunction];
   g[z_?InexactNumberQ] := Evaluate[f /. x -> z];
   Plot[N[g[SetPrecision[y, \[Infinity]]], pg], {y, a, b},
    Evaluate[Sequence @@ FilterRules[{opts}, Options[Plot]]]]];

मैं अक्सर क्रिस्टन कन्निक की निम्नलिखित चाल का उपयोग करता हूं, जब मुझे गणितज्ञ के चढ़ावों से "शब्दकोश-जैसा" व्यवहार की आवश्यकता होती है

index[downvalue_, 
   dict_] := (downvalue[[1]] /. HoldPattern[dict[x_]] -> x) // 
   ReleaseHold;
value[downvalue_] := downvalue[[-1]];
indices[dict_] := 
  Map[#[[1]] /. {HoldPattern[dict[x_]] -> x} &, DownValues[dict]] // 
   ReleaseHold;
values[dict_] := Map[#[[-1]] &, DownValues[dict]];
items[dict_] := Map[{index[#, dict], value[#]} &, DownValues[dict]];
indexQ[dict_, index_] := 
  If[MatchQ[dict[index], HoldPattern[dict[index]]], False, True];

(* Usage example: *)
(* Count number of times each subexpression occurs in an expression *)
expr = Cos[x + Cos[Cos[x] + Sin[x]]] + Cos[Cos[x] + Sin[x]]
Map[(counts[#] = If[indexQ[counts, #], counts[#] + 1, 1]; #) &, expr, Infinity];
items[counts]

जब मूल्यांकन परिणाम भ्रामक होते हैं, तो कभी-कभी यह मूल्यांकन चरणों को एक पाठ फ़ाइल में डंप करने में मदद करता है

SetAttributes[recordSteps, HoldAll];
recordSteps[expr_] :=
 Block[{$Output = List@OpenWrite["~/temp/msgStream.m"]}, 
  TracePrint[Unevaluated[expr], _?(FreeQ[#, Off] &), 
   TraceInternal -> True];
  Close /@ $Output;
  Thread[Union@
    Cases[ReadList["~/temp/msgStream.m", HoldComplete[Expression]], 
     symb_Symbol /; 
       AtomQ@Unevaluated@symb && 
        Context@Unevaluated@symb === "System`" :> 
      HoldComplete@symb, {0, Infinity}, Heads -> True], HoldComplete]
  ]

(* Usage example: *)
(* puts steps of evaluation of 1+2+Sin[5]) into ~/temp/msgStream.m *)
recordSteps[1+2+Sin[5]]

Comments

एक उपयोग नमूना बहुत अच्छा होगा। जब आपके पास समय हो तो एक पोस्ट करने का प्रयास करें।

— डॉ। बिसरिसिक

क्या आप क्रिस्टन को जानते हैं? मैं हेलसिंकी में उसके साथ एक ही समूह में काम करता था। अच्छा आदमी, छोटी सी दुनिया।

— तिमो

नहींं, वेब पर अपना कोड पाया। दरअसल, कोड में एक छोटी सी बग को ठीक करने के लिए उसे ईमेल करने की कोशिश की गई थी, लेकिन उसके वेबपेज पर ईमेल अब काम नहीं करता है

— यारोस्लाव बुलटोव

Answer 16

अपरिष्कृत कमांड-लाइन विकल्पों-batchinput-batchoutput का उपयोग करके बैच मोड में मैथबर्न को चलाना संभव है और :

math -batchinput -batchoutput < input.m > outputfile.txt

(जहां input.mnewline character के साथ बैच इनपुट फाइल खत्म हो रही है, outputfile.txtवह फाइल है जिस पर आउटपुट रीडायरेक्ट किया जाएगा)।

में Mathematica । वी> = 6 MathKernel अप्रलेखित कमांड लाइन विकल्प है:

-noicon

जो नियंत्रित करता है कि क्या मैथ कर्नेल में टास्कबार (विंडोज के तहत कम से कम) पर दृश्यमान आइकन होगा।

फ्रंटएंड (कम से कम v.5 से) में अनिर्दिष्ट कमांड-लाइन विकल्प है

-b

जो स्प्लैश-स्क्रीन को निष्क्रिय कर देता है और मैथमैटिक फ्रंट को और अधिक तेज़ी से चलाने की अनुमति देता है

और विकल्प

-directlaunch

जो तंत्र को निष्क्रिय करता है जो सिस्टम रजिस्ट्री में .nb फ़ाइलों के साथ जुड़े संस्करण को लॉन्च करने के बजाय इंस्टॉल किए गए सबसे हालिया Mathematica संस्करण को लॉन्च करता है।

ऐसा करने का एक और तरीका है :

स्थापना निर्देशिका में Mathematica.exe बाइनरी लॉन्च करने के बजाय, SystemFiles \ FrontEnd \ Binaries \ Windows में Mathematica.exe बाइनरी लॉन्च करें। पूर्व एक सरल लांचर प्रोग्राम है जो उपयोगकर्ता इंटरफ़ेस की प्रतियां चलाने के लिए नोटबुक खोलने के अनुरोधों को पुनर्निर्देशित करने के लिए सबसे कठिन प्रयास करता है। बाद वाला यूजर इंटरफेस बाइनरी ही है।

अंतिम कमांड लाइन विकल्प को वैश्विक फ्रंटएंड विकल्प के साथ संयोजित करना आसान है, VersionedPreferences->True जो विभिन्न गणितीय संस्करणों के बीच वरीयताओं को साझा करने में अक्षम करता है :

SetOptions[$FrontEnd, VersionedPreferences -> True]

(ऊपर हाल ही में स्थापित मैथमेटिका संस्करण का मूल्यांकन किया जाना चाहिए ।)

में मेथेमेटिका 8 इस प्राथमिकताएं संवाद में नियंत्रित किया जाता है, सिस्टम फलक में, सेटिंग के अंतर्गत "बनाएँ और संस्करण विशिष्ट सामने अंत प्राथमिकताएं बनाए रख" ।

अनिर्दिष्ट कुंजी -h(विंडोज के लिए कोड) का उपयोग करके फ्रंटएंड के कमांड-लाइन विकल्पों की अधूरी सूची प्राप्त करना संभव है :

SetDirectory[$InstallationDirectory <> 
   "\\SystemFiles\\FrontEnd\\Binaries\\Windows\\"];
Import["!Mathematica -h", "Text"]

देता है:

Usage:  Mathematica [options] [files]
Valid options:
    -h (--help):  prints help message
    -cleanStart (--cleanStart):  removes existing preferences upon startup
    -clean (--clean):  removes existing preferences upon startup
    -nogui (--nogui):  starts in a mode which is initially hidden
    -server (--server):  starts in a mode which disables user interaction
    -activate (--activate):  makes application frontmost upon startup
    -topDirectory (--topDirectory):  specifies the directory to search for resources and initialization files
    -preferencesDirectory (--preferencesDirectory):  specifies the directory to search for user AddOns and preference files
    -password (--password):  specifies the password contents
    -pwfile (--pwfile):  specifies the path for the password file
    -pwpath (--pwpath):  specifies the directory to search for the password file
    -b (--b):  launches without the splash screen
    -min (--min):  launches as minimized

अन्य विकल्पों में शामिल हैं:

-directLaunch:  force this FE to start
-32:  force the 32-bit FE to start
-matchingkernel:  sets the frontend to use the kernel of matching bitness
-Embedding:  specifies that this instance is being used to host content out of process

---

क्या मैथ कर्नेल और फ्रंटएंड के अन्य संभावित उपयोगी कमांड-लाइन विकल्प हैं? अगर आपको पता है तो कृपया शेयर करें

संबंधित प्रश्न ।

Comments

"मैचिंग बिटनेस?" इसका क्या मतलब है?

— Mr.Wizard

@ Mr.Wizard संभवतः इस विकल्प के विकल्प के साथ संयोजन में केवल 64-बिट सिस्टम के तहत एक समझ है -32और इसका मतलब है कि FrontEnd द्वारा उपयोग की जाने वाली MathKernel की बिटनेस ऑपरेटिंग सिस्टम (64 बिट) की बिटनेस से मेल खाएगी। ऐसा लगता है कि अन्य मामलों में यह विकल्प कुछ भी नहीं बदलेगा।

— एलेक्सी पोपकोव

Answer 17

मेरे पसंदीदा हैक छोटे कोड जनरेटिंग मैक्रोज़ हैं जो आपको मानक बॉयलरप्लेट कमांड के एक गुच्छा को एक छोटे से बदलने की अनुमति देते हैं। वैकल्पिक रूप से, आप नोटबुक खोलने / बनाने के लिए कमांड बना सकते हैं।

यहाँ मैं अपने दिन-प्रतिदिन के गणितज्ञों के वर्कफ़्लो में कुछ समय के लिए उपयोग कर रहा हूँ। मैंने पाया कि मैं खुद को बहुत कुछ दिखा रहा हूँ:

1. एक नोटबुक में एक निजी संदर्भ है, लोड पैकेज (ओं) की मुझे ज़रूरत है, इसे ऑटोसेव करें।
2. थोड़ी देर के लिए इस नोटबुक के साथ काम करने के बाद, मैं कुछ अलग-अलग नोटबुक में अपने स्वयं के निजी संदर्भ के साथ कुछ दूर खरोंच गणना करना चाहता हूं, जबकि "मुख्य" नोटबुक में उपयोग की जाने वाली परिभाषाओं तक पहुंच रहा है। क्योंकि मैंने निजी संदर्भ सेट किया है, इसके लिए $ ContextPath को मैन्युअल रूप से समायोजित करना होगा

बार-बार हाथ से यह सब करना एक दर्द है, तो चलो स्वचालित! सबसे पहले, कुछ उपयोगिता कोड:

(* Credit goes to Sasha for SelfDestruct[] *)
SetAttributes[SelfDestruct, HoldAllComplete];
SelfDestruct[e_] := (If[$FrontEnd =!= $Failed,
   SelectionMove[EvaluationNotebook[], All, EvaluationCell]; 
   NotebookDelete[]]; e)

writeAndEval[nb_,boxExpr_]:=(
    NotebookWrite[nb,  CellGroupData[{Cell[BoxData[boxExpr],"Input"]}]];
    SelectionMove[nb, Previous, Cell]; 
    SelectionMove[nb, Next, Cell];
    SelectionEvaluate[nb];
)

ExposeContexts::badargs = 
  "Exposed contexts should be given as a list of strings.";
ExposeContexts[list___] := 
 Module[{ctList}, ctList = Flatten@List@list; 
  If[! MemberQ[ctList, Except[_String]],AppendTo[$ContextPath, #] & /@ ctList, 
   Message[ExposeContexts::badargs]];
  $ContextPath = DeleteDuplicates[$ContextPath];
  $ContextPath]

    Autosave[x:(True|False)] := SetOptions[EvaluationNotebook[],NotebookAutoSave->x];

अब, एक मैक्रो बनाएं जो नोटबुक में निम्नलिखित सेल लगाने जा रहा है:

SetOptions[EvaluationNotebook[], CellContext -> Notebook]
Needs["LVAutils`"]
Autosave[True]

और यहाँ मैक्रो है:

MyPrivatize[exposedCtxts : ({__String} | Null) : Null]:=
  SelfDestruct@Module[{contBox,lvaBox,expCtxtBox,assembledStatements,strList},
    contBox = MakeBoxes[SetOptions[EvaluationNotebook[], CellContext -> Notebook]];
    lvaBox = MakeBoxes[Needs["LVAutils`"]];

    assembledStatements = {lvaBox,MakeBoxes[Autosave[True]],"(*********)"};
    assembledStatements = Riffle[assembledStatements,"\[IndentingNewLine]"]//RowBox;
    writeAndEval[InputNotebook[],contBox];
    writeAndEval[InputNotebook[],assembledStatements];
    If[exposedCtxts =!= Null,
       strList = Riffle[("\"" <> # <> "\"") & /@ exposedCtxts, ","];
       expCtxtBox = RowBox[{"ExposeContexts", "[", RowBox[{"{", RowBox[strList], "}"}], "]"}];
       writeAndEval[InputNotebook[],expCtxtBox];
      ]
 ]

अब जब मैं टाइप MyPrivatize[]करता हूं तो निजी संदर्भ बनाता है और मेरे मानक पैकेज को लोड करता है। अब एक कमांड बनाते हैं जो अपने स्वयं के निजी संदर्भ के साथ एक नया स्क्रैच नोटबुक खोलेगा (ताकि आप परिभाषाओं को खराब करने के जोखिम के बिना जंगली परित्याग के साथ वहां हैक कर सकें), लेकिन आपके वर्तमान संदर्भों तक पहुंच है।

SpawnScratch[] := SelfDestruct@Module[{nb,boxExpr,strList},
    strList = Riffle[("\"" <> # <> "\"") & /@ $ContextPath, ","];
    boxExpr = RowBox[{"MyPrivatize", "[",
        RowBox[{"{", RowBox[strList], "}"}], "]"}];
    nb = CreateDocument[];
    writeAndEval[nb,boxExpr];
]

इसके बारे में ठंडी बात यह है कि इस SelfDestructआदेश के चलते, यह चालू नोटबुक में कोई निशान नहीं छोड़ता है - जो अच्छा है, क्योंकि अन्यथा यह सिर्फ अव्यवस्था पैदा करेगा।

अतिरिक्त शैली बिंदुओं के लिए, आप इन मैक्रो का उपयोग करके कीवर्ड ट्रिगर बना सकते हैं InputAutoReplacements, लेकिन मैं इसे पाठक के लिए एक अभ्यास के रूप में छोड़ दूँगा।

Answer 18

PageWidth के साथ PutAppend -> इन्फिनिटी

में Mathematica का उपयोग करते हुए PutAppendआदेश मध्यवर्ती संगणना के परिणामों के साथ एक चल लॉग फ़ाइल बनाए रखने के लिए सबसे सरल तरीका है। लेकिन यह PageWith->78एक फ़ाइल में भावों को निर्यात करते समय डिफ़ॉल्ट सेटिंग द्वारा उपयोग करता है और इसलिए इसमें कोई गारंटी नहीं है कि प्रत्येक मध्यवर्ती आउटपुट लॉग में केवल एक पंक्ति लेगा।

PutAppendअपने आप में कोई विकल्प नहीं है, लेकिन इसके मूल्यांकन का पता लगाने से पता चलता है कि यह उस OpenAppendफ़ंक्शन पर आधारित है जिसके पास PageWithविकल्प है और SetOptionsकमांड द्वारा इसके डिफ़ॉल्ट मान को बदलने की अनुमति देता है :

In[2]:= Trace[x>>>"log.txt",TraceInternal->True]
Out[2]= {x>>>log.txt,{OpenAppend[log.txt,CharacterEncoding->PrintableASCII],OutputStream[log.txt,15]},Null}

इसलिए हम PutAppendएक बार में केवल एक लाइन को सेट करके प्राप्त कर सकते हैं :

SetOptions[OpenAppend, PageWidth -> Infinity]

---

अपडेट करें

वहाँ एक है बग संस्करण 10 (संस्करण 11.3 में तय) में शुरू की: SetOptionsअब के व्यवहार को प्रभावित करता OpenWriteहै और OpenAppend।

एक वैकल्पिक हल PutAppendस्पष्ट PageWidth -> Infinityविकल्प के साथ अपने स्वयं के संस्करण को लागू करना है :

Clear[myPutAppend]
myPutAppend[expr_, pathtofile_String] :=
 (Write[#, expr]; Close[#];) &[OpenAppend[pathtofile, PageWidth -> Infinity]]

ध्यान दें कि हम इसे इस उत्तर WriteStringमें दिखाए अनुसार भी लागू कर सकते हैं , लेकिन इस मामले में यह आवश्यक है कि अभिव्यक्ति को पूर्ववर्ती के माध्यम से परिवर्तित किया जाए ।InputFormToString[expr, InputForm]

Answer 19

मैं इसमें शामिल होने के लिए अपने एक पैकेज के माध्यम से देख रहा था, और कुछ संदेश मिले जो मैंने उस काम के चमत्कार को परिभाषित किया Debug::<some name>:। डिफ़ॉल्ट रूप से, उन्हें बंद कर दिया जाता है, इसलिए अधिक उपरि का उत्पादन न करें। लेकिन, मैं उनके साथ अपने कोड को लेट कर सकता हूं, और उन्हें चालू कर सकता हूं यदि मुझे यह पता लगाने की आवश्यकता है कि कोड का व्यवहार कैसा है।

Comments

सहायता से> संस्करण 2.0 (1991 में जारी) के बाद से, डिबग का पता ट्रेस द्वारा लगाया गया है।

— डॉ। बेलिसियस

@ काबिलेतारीफ, आप बात चूक गए। यह न तो है Debugऔर न ही Traceकाम करता है; यह मेरे द्वारा बनाए गए संदेशों का एक समूह है जो मैं अपने कोड को अपनी इच्छानुसार चालू / बंद कर सकता हूं। वे शब्द के साथ प्रीफ़ेड होते हैं Debug, उसी तरह usageफ़ंक्शन के नाम के साथ एक मेस का प्रीफ़ेड किया जाता है। यह coutc ++ कोड में स्टेटमेंट का एक गुच्छा रखने के समान कार्यक्षमता प्रदान करता है ।

— 15

मुझे क्षमा करें। मैं उलझन में पड़ गया, क्योंकि मैंने कभी "बालवाड़ी देशों के लिए नहीं" सीखने के लिए बालवाड़ी से स्नातक की उपाधि प्राप्त की: डी

— डॉ। बेलिसरियस

Answer 20

अंतर्निहित स्कोपिंग निर्माणों के बारे में मुझे परेशान करने वाली चीजों में से एक यह है कि वे एक ही बार में सभी स्थानीय चर परिभाषाओं का मूल्यांकन करते हैं, इसलिए आप उदाहरण के लिए नहीं लिख सकते हैं

With[{a = 5, b = 2 * a},
    ...
]

इसलिए कुछ समय पहले मैं WithNest नामक एक मैक्रो के साथ आया था जो आपको ऐसा करने की अनुमति देता है। मुझे यह आसान लगता है, क्योंकि यह आपको कुछ ऐसा करने के लिए बिना स्थानीय परिवर्तन के बाँधने देता है

Module[{a = 5,b},
    b = 2 * a;
    ...
]

अंत में, मुझे ऐसा करने का सबसे अच्छा तरीका एक विशेष प्रतीक का उपयोग करके बाइंडिंग की सूची पर पुनरावृत्ति करना आसान बनाने के लिए किया गया था, और मैंने इस प्रतीक को छिपाए रखने के लिए परिभाषा को अपने स्वयं के पैकेज में डाल दिया। हो सकता है कि किसी के पास इस समस्या का सरल समाधान हो?

यदि आप इसे आज़माना चाहते हैं, तो निम्नलिखित को एक फ़ाइल में डालें Scoping.m:

BeginPackage["Scoping`"];

WithNest::usage=
"WithNest[{var1=val1,var2=val2,...},body] works just like With, except that
values are evaluated in order and later values have access to earlier ones.
For example, val2 can use var1 in its definition.";

Begin["`Private`"];

(* Set up a custom symbol that works just like Hold. *)
SetAttributes[WithNestHold,HoldAll];

(* The user-facing call.  Give a list of bindings and a body that's not
our custom symbol, and we start a recursive call by using the custom
symbol. *)
WithNest[bindings_List,body:Except[_WithNestHold]]:=
WithNest[bindings,WithNestHold[body]];

(* Base case of recursive definition *)
WithNest[{},WithNestHold[body_]]:=body;

WithNest[{bindings___,a_},WithNestHold[body_]]:=
WithNest[
{bindings},
WithNestHold[With[List@a,body]]];

SyntaxInformation[WithNest]={"ArgumentsPattern"->{{__},_}};
SetAttributes[WithNest,{HoldAll,Protected}];

End[];

EndPackage[];

Comments

Janus ने इसका एक संस्करण पोस्ट किया, और MathGroup पर आपके प्रश्न का संदर्भ दिया: stackoverflow.com/questions/4190845/custom-notation-question/…

— Mr.Wizard

यह बात बताने के लिए धन्यवाद! इस सामान को देखे हुए कुछ समय हो चुका है, और इन सभी दृष्टिकोणों को देखना दिलचस्प है।

— DGrady

Answer 21

यह एक अल्बर्टो डि लुलो द्वारा लिखा गया था, (जो स्टैक ओवरफ्लो पर दिखाई नहीं देता है)।

CopyToClipboard, गणितज्ञ 7 के लिए (गणितज्ञ 8 में इसे बनाया गया है)

CopyToClipboard[expr_] := 
  Module[{nb}, 
   nb = CreateDocument[Null, Visible -> False, WindowSelected -> True];
   NotebookWrite[nb, Cell[OutputFormData@expr], All];
   FrontEndExecute[FrontEndToken[nb, "Copy"]];
   NotebookClose@nb];

मूल पोस्ट: http://forums.wolfram.com/mathgroup/archive/2010/Jun/msg00148.html

मैंने इस रूटीन को साधारण दशमलव रूप में बड़ी वास्तविक संख्याओं को क्लिपबोर्ड पर कॉपी करने के लिए उपयोगी पाया है। उदाहरण के लिएCopyToClipboard["123456789.12345"]

Cell[OutputFormData@expr] बड़े करीने से उद्धरण निकालता है।

Answer 22

यह कोड एक पैलेट बनाता है जो चयन को एक छवि के रूप में स्टैक एक्सचेंज में अपलोड करता है। विंडोज पर, एक अतिरिक्त बटन प्रदान किया जाता है जो चयन का अधिक वफादार प्रतिपादन देता है।

कोड को नोटबुक सेल में कॉपी करें और मूल्यांकन करें। फिर आउटपुट से पैलेट को पॉप आउट करें, और इसका उपयोग करके इंस्टॉल करेंPalettes -> Install Palette...

अगर आपको इससे कोई परेशानी है, तो यहाँ एक टिप्पणी पोस्ट करें। यहाँ नोटबुक संस्करण डाउनलोड करें ।

---

Begin["SOUploader`"];

Global`palette = PaletteNotebook@DynamicModule[{},

   Column[{
     Button["Upload to SE",
      With[{img = rasterizeSelection1[]},
       If[img === $Failed, Beep[], uploadWithPreview[img]]],
      Appearance -> "Palette"],

     If[$OperatingSystem === "Windows",

      Button["Upload to SE (pp)",
       With[{img = rasterizeSelection2[]},
        If[img === $Failed, Beep[], uploadWithPreview[img]]],
       Appearance -> "Palette"],

      Unevaluated@Sequence[]
      ]
     }],

   (* Init start *)
   Initialization :>
    (

     stackImage::httperr = "Server returned respose code: `1`";
     stackImage::err = "Server returner error: `1`";

     stackImage[g_] :=
      Module[
       {getVal, url, client, method, data, partSource, part, entity,
        code, response, error, result},

       getVal[res_, key_String] :=
        With[{k = "var " <> key <> " = "},
         StringTrim[

          First@StringCases[
            First@Select[res, StringMatchQ[#, k ~~ ___] &],
            k ~~ v___ ~~ ";" :> v],
          "'"]
         ];

       data = ExportString[g, "PNG"];

       JLink`JavaBlock[
        url = "http://stackoverflow.com/upload/image";
        client =
         JLink`JavaNew["org.apache.commons.httpclient.HttpClient"];
        method =
         JLink`JavaNew[
          "org.apache.commons.httpclient.methods.PostMethod", url];
        partSource =
         JLink`JavaNew[
          "org.apache.commons.httpclient.methods.multipart.\
ByteArrayPartSource", "mmagraphics.png",
          JLink`MakeJavaObject[data]@toCharArray[]];
        part =
         JLink`JavaNew[
          "org.apache.commons.httpclient.methods.multipart.FilePart",
          "name", partSource];
        part@setContentType["image/png"];
        entity =
         JLink`JavaNew[
          "org.apache.commons.httpclient.methods.multipart.\
MultipartRequestEntity", {part}, method@getParams[]];
        method@setRequestEntity[entity];
        code = client@executeMethod[method];
        response = method@getResponseBodyAsString[];
        ];

       If[code =!= 200, Message[stackImage::httperr, code];
        Return[$Failed]];
       response = StringTrim /@ StringSplit[response, "\n"];

       error = getVal[response, "error"];
       result = getVal[response, "result"];
       If[StringMatchQ[result, "http*"],
        result,
        Message[stackImage::err, error]; $Failed]
       ];

     stackMarkdown[g_] :=
      "![Mathematica graphics](" <> stackImage[g] <> ")";

     stackCopyMarkdown[g_] := Module[{nb, markdown},
       markdown = Check[stackMarkdown[g], $Failed];
       If[markdown =!= $Failed,
        nb = NotebookCreate[Visible -> False];
        NotebookWrite[nb, Cell[markdown, "Text"]];
        SelectionMove[nb, All, Notebook];
        FrontEndTokenExecute[nb, "Copy"];
        NotebookClose[nb];
        ]
       ];

     (* Returns available vertical screen space,
     taking into account screen elements like the taskbar and menu *)


     screenHeight[] := -Subtract @@
        Part[ScreenRectangle /. Options[$FrontEnd, ScreenRectangle],
         2];

     uploadWithPreview[img_Image] :=
      CreateDialog[
       Column[{
         Style["Upload image to the Stack Exchange network?", Bold],
         Pane[

          Image[img, Magnification -> 1], {Automatic,
           Min[screenHeight[] - 140, 1 + ImageDimensions[img][[2]]]},
          Scrollbars -> Automatic, AppearanceElements -> {},
          ImageMargins -> 0
          ],
         Item[
          ChoiceButtons[{"Upload and copy MarkDown"}, \
{stackCopyMarkdown[img]; DialogReturn[]}], Alignment -> Right]
         }],
       WindowTitle -> "Upload image to Stack Exchange?"
       ];

     (* Multiplatform, fixed-width version.
        The default max width is 650 to fit Stack Exchange *)
     rasterizeSelection1[maxWidth_: 650] :=
      Module[{target, selection, image},
       selection = NotebookRead[SelectedNotebook[]];
       If[MemberQ[Hold[{}, $Failed, NotebookRead[$Failed]], selection],

        $Failed, (* There was nothing selected *)

        target =
         CreateDocument[{}, WindowSelected -> False, Visible -> False,
           WindowSize -> maxWidth];
        NotebookWrite[target, selection];
        image = Rasterize[target, "Image"];
        NotebookClose[target];
        image
        ]
       ];

     (* Windows-only pixel perfect version *)
     rasterizeSelection2[] :=
      If[
       MemberQ[Hold[{}, $Failed, NotebookRead[$Failed]],
        NotebookRead[SelectedNotebook[]]],

       $Failed, (* There was nothing selected *)

       Module[{tag},
        FrontEndExecute[
         FrontEndToken[FrontEnd`SelectedNotebook[], "CopySpecial",
          "MGF"]];
        Catch[
         NotebookGet@ClipboardNotebook[] /.
          r_RasterBox :>
           Block[{},
            Throw[Image[First[r], "Byte", ColorSpace -> "RGB"], tag] /;
              True];
         $Failed,
         tag
         ]
        ]
       ];
     )
   (* Init end *)
   ]

End[];

Answer 23

मुझे यकीन है कि बहुत से लोगों ने ऐसी स्थिति का सामना किया है जहां वे कुछ सामान चलाते हैं, यह महसूस करते हुए कि यह न केवल कार्यक्रम अटक गया है, बल्कि वे पिछले 10 मिनट से भी नहीं बचा है!

संपादित करें

कुछ समय तक इससे पीड़ित रहने के बाद, मुझे एक दिन पता चला कि कोई व्यक्ति मैथमैटिक कोड के भीतर से ऑटो-सेव बना सकता है । मुझे लगता है कि इस तरह के ऑटो-सेव का उपयोग करने से मुझे अतीत में बहुत मदद मिली है, और मैंने हमेशा महसूस किया है कि संभावना ही कुछ ऐसी थी जो बहुत सारे लोगों को पता नहीं है कि वे कर सकते हैं।

मेरे द्वारा उपयोग किया गया मूल कोड सबसे नीचे है। टिप्पणियों के लिए धन्यवाद मुझे पता चला है कि यह समस्याग्रस्त है, और यह कि इसे वैकल्पिक तरीके से करना बेहतर है, का उपयोग करके ScheduledTask(जो केवल गणितज्ञ 8 में काम करेगा )।

इसके लिए कोड इस उत्तर से पाया जा सकता है Sjoerd C. de Vries (क्योंकि मुझे यकीन नहीं है कि अगर इसे यहां कॉपी करना ठीक है, तो मैं इसे केवल एक लिंक के रूप में छोड़ रहा हूं।)

---

नीचे दिए गए समाधान का उपयोग कर रहा है Dynamic। यह हर 60 सेकंड में नोटबुक को बचाएगा, लेकिन जाहिरा तौर पर केवल अगर इसकी सेल दिखाई दे रही है । मैं इसे केवल पूर्ण कारणों के लिए यहाँ छोड़ रहा हूँ। (और गणितज्ञ 6 और 7 के उपयोगकर्ताओं के लिए )

/ संपादित करें

इसे हल करने के लिए मैं एक नोटबुक की शुरुआत में इस कोड का उपयोग करता हूं:

Dynamic[Refresh[NotebookSave[]; DateString[], UpdateInterval -> 60]]

यह आपके काम को हर 60 सेकंड में बचाएगा।
मैं इसे पसंद करता हूं NotebookAutoSave[]क्योंकि यह इनपुट संसाधित होने से पहले बचाता है, और क्योंकि कुछ फाइलें इनपुट से अधिक पाठ हैं।

मैंने इसे मूल रूप से यहाँ पाया: http://en.wikipedia.org/wiki/Talk:Mathematica#Criticism

ध्यान दें कि एक बार इस लाइन को चलाने के बाद, बचत तब भी होगी जब आप अपनी फ़ाइल को बंद करते हैं और फिर से खोलते हैं (जब तक डायनेमिक अपडेट सक्षम है)।

इसके अलावा, चूंकि गणितज्ञ में कोई पूर्ववत नहीं है, इसलिए अपनी सभी सामग्री को हटाने के लिए सावधान रहें, क्योंकि बचत इसे अपरिवर्तनीय बना देगी (एहतियाती कदम के रूप में, मैं इस कोड को हर समाप्त नोटबुक से हटा देता हूं)

Comments

आप इसे एक अलग नाम (जैसे वर्तमान समय और दिनांक को फ़ाइल नाम के अंत में जोड़कर) और शायद एक विशेष निर्देशिका ("बैकअप", कहते हैं) में भी सहेज सकते हैं। यह संस्करण के एक आदिम रूप की तरह होगा।

— एसीएल

आप ऐसा कुछ कर सकते हैं NotebookSave[SelectedNotebook[], "work-" <> IntegerString[i] <> ".nb"]; i++, लेकिन मुझे लगता है कि वर्तमान नोटबुक नाम के किसी भी प्रकार का संदर्भ पुनरावर्ती बन जाएगा।

— tsvikas

मैंने सोचा था कि Dynamicऑब्जेक्ट केवल तब दिखाई देते हैं जब वे दिखाई देते हैं, इसलिए मुझे यकीन नहीं होगा कि यह विधि काम करेगी जैसे कि आप Dynamicऑब्जेक्ट को दृश्य क्षेत्र से बाहर स्क्रॉल करते हैं। फिर, मैंने कोशिश नहीं की। किसी भी मामले में, मैंने इसे केवल एक सुझाव के रूप में पेश किया।

— ac

आप इसका उपयोग करके परीक्षण कर सकते हैं Dynamic[Refresh[i++, UpdateInterval -> 1, TrackedSymbols -> {}]]। दृष्टि से वृद्धि की संख्या स्क्रॉल करें, एक मिनट प्रतीक्षा करें, वापस स्क्रॉल करें और देखें कि संख्या 60 से बढ़ाई नहीं गई है। के बारे में UpdateInterval: यह आमतौर पर संभव हो तो उपयोग किया जाता है, लेकिन यदि आपके कोड में परिवर्तन शामिल हैं, तो यह परिवर्तन एक नया ताज़ा करने से पहले ट्रिगर होता है। अंतराल समाप्त होता है। उपरोक्त लाइन को बिना आज़माएंTrackedSymbols

— Sjoerd C. de Vries

@ j0ker5 मेरे उपरोक्त कोड को आज़माएँ और आप देख सकते हैं कि UpdateInterval हमेशा अपडेट को निर्दिष्ट अंतराल के साथ रखने के लिए बाध्य नहीं करता है। यह कोड यह भी दर्शाता है कि डायनेमिक केवल तभी काम करता है जब इसमें निहित सेल दृश्यमान में दिखाई दे । यह वास्तव में उस पल को रोक देता है जब यह दृष्टि से बाहर होता है। लोग वास्तव में अपनी फ़ाइलों को बचाने के लिए इस कोड पर भरोसा नहीं करना चाहिए क्योंकि यह नहीं है। इसका खतरनाक

— सोज़ेरड सी। डी वीस

Answer 24

याद रखें कि द मैथेमेटिका बुक http://reference.wolfram.com/legacy/v5_2/ पर ऑनलाइन भी उपलब्ध है, हालांकि यह http://reference.wolfram.com पर वर्तमान दस्तावेज़ द्वारा प्रदत्त है ।

Answer 25

मुझे अपनी SystemFiles/FrontEnd/TextResources/Windows/KeyEventTranslations.trफ़ाइल में इस कीबोर्ड शॉर्टकट को जोड़ने के लिए संकुल विकसित करते समय यह वास्तव में उपयोगी लगता है ।

(* Evaluate Initialization Cells: Real useful for reloading library changes. *)

Item[KeyEvent["i", Modifiers -> {Control, Command}],
    FrontEndExecute[
        FrontEndToken[
            SelectedNotebook[],
            "EvaluateInitialization"]]],

प्रत्येक के लिए Packagename.mमैं PackagenameTest.nbपरीक्षण के लिए एक नोटबुक बनाता हूं और परीक्षण नोटबुक की पहली 2 कोशिकाओं को आरंभीकरण कोशिकाओं के रूप में सेट किया जाता है। पहली सेल में मैंने डाला

Needs["PackageManipulations`"]

बहुत उपयोगी PackageManipulations पुस्तकालय को लोड करने के लिए जो लियोनिद द्वारा लिखा गया था। दूसरी कोशिका में होता है

PackageRemove["Packagename`Private`"]
PackageRemove["Packagename`"]
PackageReload["Packagename`"]

जो सभी वास्तविक पैकेज को लोड करते हैं। ध्यान दें कि पहली दो पंक्तियाँ केवल Removeसभी प्रतीकों के लिए हैं क्योंकि मैं संदर्भों को यथासंभव स्वच्छ रखना पसंद करता हूं।

फिर एक पैकेज लिखने और परीक्षण के लिए वर्कफ़्लो कुछ इस तरह से हो जाता है।

1. में परिवर्तन सहेजें Packagename.m।
2. जाओ PackagenameTest.nbऔर करो CTRL + ALT + i।

यह पैकेज को पुनः लोड करने के लिए आरंभीकरण कोशिकाओं का कारण बनता है, जो परीक्षण को सरल बनाता है।

Answer 26

निम्नलिखित फ़ंक्शन format[expr_]का उपयोग mathematicaकिसी पृष्ठ पर फैलने वाले विकृत अभिव्यक्तियों को इंडेंट / फ़ॉर्मेट करने के लिए किया जा सकता है

indent[str_String, ob_String, cb_String, delim_String] := 
  Module[{ind, indent, f, tab}, ind = 0; tab = "    ";
   indent[i_, tab_, nl_] := nl <> Nest[tab <> ToString[#] &, "", i];
   f[c_] := (indent[ind, "", " "] <> c <> indent[++ind, tab, "\n"]) /;StringMatchQ[ob, ___ ~~ c ~~ ___];
   f[c_] := (indent[--ind, "", " "] <> c <> indent[ind, tab, "\n"]) /;StringMatchQ[cb, ___ ~~ c ~~ ___];
   f[c_] := (c <> indent[ind, tab, "\n"]) /;StringMatchQ[delim, ___ ~~ c ~~ ___];
   f[c_] := c;
   f /@ Characters@str // StringJoin];
format[expr_] := indent[expr // InputForm // ToString, "[({", "])}", ";"];

(*    
format[Hold@Module[{ind, indent, f, tab}, ind = 0; tab = "    ";
 indent[i_, tab_, nl_] := nl <> Nest[tab <> ToString[#] &, "", i];
 f[c_] := (indent[ind, "", " "] <> c <> indent[++ind, tab, "\n"]) /;StringMatchQ[ob, ___ ~~ c ~~ ___];
 f[c_] := (indent[--ind, "", " "] <> c <> indent[ind, tab, "\n"]) /;StringMatchQ[cb, ___ ~~ c ~~ ___];
 f[c_] := (c <> indent[ind, tab, "\n"]) /;StringMatchQ[delim, ___ ~~ c ~~ ___];
 f[c_] := c;
 f /@ Characters@str // StringJoin]]
*)

---

रेफरी: /codegolf/3088/indent-a-string-use-given-parentheses

Comments

आप अभ्यास में इसके लिए क्या उपयोग कर रहे हैं? आउटपुट थोड़ा बहुत "मज़ेदार" है जो आपके कोड या डेटा (सूचियों format@RandomInteger[10,{3,3}]) पर लागू होने पर या तो पठनीय हो सकता है : pastebin.com/nUT54Emq चूंकि आपके पास पहले से ही मूल बातें हैं और आप इसमें रुचि रखते हैं, तो क्या आप कोड में सुधार कर सकते हैं एक उपयोगी पठनीय स्वरूपण का उत्पादन? फिर अगला कदम एक पेस्ट बटन बनाना होगा जो अच्छी तरह से इंडेंट किए गए मैथमेटिका कोड के साथ एक इनपुट सेल बनाएगा (संभवतः टिप्पणियों को संरक्षित करना!) मेरे संबंधित प्रश्न भी देखें ।

— शैबॉलेक्स