गणित

Question

में फ़ाइलों को लिखते समय स्वरूपण संख्या यह संख्या स्वरूपण के संबंध में this प्रश्न जारी है, और मेरे पहले question से संबंधित टेक्स्ट फ़ाइलों में बहुत विशिष्ट गणित आउटपुट प्राप्त करने के बारे में है।

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

1. उच्च परिशुद्धता "को प्रदूषित करता है" जो बहुत मुश्किल है ज़रूरत से ज़्यादा अंकों के साथ अपने परिणामों से छुटकारा पाने के:

   In[1] := b = SetPrecision[7, 50]; a = Pi/b 
   Out[1] := 0.44879895051282760549466334046850041202816705705358654585356351318683091518373`50. 
   In[2] := InputForm @ N[a, 6] 
   Out[2] := 0.44879895051282760549466334046850041203`6. 
   

   जहां मैं वास्तव में केवल ०.४४८७९९ की जरूरत है।

2. कभी-कभी परिशुद्धता को इंगित करने वाला नंबर भी दूषित हो जाता है और मुझे 4.72642364528438598726943'5.9999999999999999999999 जैसे मान मिलते हैं जहां मुझे आमतौर पर सटीकता की आवश्यकता नहीं होती है और 4.72642 पर्याप्त होगा।

इनमें से दोनों फ़ाइल आकार के लिए महत्वपूर्ण ओवरहेड पेश करते हैं, और हार्ड डिस्क संग्रहण सस्ता होने पर, फ़ाइल आकार में बाद में फ़ाइलों को मैथमैटिका में लोड करते समय एक बड़ा अंतर होता है।

तो, के साथ, जैसे, aa कि एक अनियमित सरणी में 50 अंकों मनमाना परिशुद्धता संख्या में शामिल है, शुरू करने वहाँ एक रास्ता में बनाया मुझे एक पाठ फ़ाइल है कि इस

aa = {{2.0437`4, 4.7276`4, ...}, ...} 

की तरह कुछ पढ़ता था पाने के लिए है EDIT: स्पष्टीकरण के लिए, मुझे संख्याओं के प्रदर्शन या संख्याओं की परिशुद्धता को ट्रैक करने या संख्याओं की सटीकता को बदलने के साथ समस्या नहीं है। मुझे किस समस्या का सामना करना पड़ रहा है यह नियंत्रित कर रहा है कि फ़ाइल में कितनी संख्या लिखी गई है।

N, NumberForm, OutputForm, InputForm, *Form, आदि का उपयोग करना, सभी Save के साथ ठीक से काम नहीं करते। और Save एकमात्र निर्यात विकल्प है जो मुझे लगता है कि प्रतीक और सरणी संरचना निर्यात करता है। स्वरूपण को नियंत्रित करने के लिए Export और Put* का उपयोग बेहतर रूप से नियंत्रित करने के लिए किया जा सकता है लेकिन उनमें प्रतीक शामिल नहीं है (और Export के मामले में सरणी संरचना भी खो जाती है)।

Answer 1

क्या आपको वास्तव में 2.0437`4 जैसी चीजों की आवश्यकता है, या मशीन डबल 2.0437 पर्याप्त होगी? यदि उत्तरार्द्ध तो आप

N[SetPrecision[values,6]] 

मशीन डबल्स पर कॉरर्स करने के लिए कुछ कर सकते हैं जो अधिकतर (दशमलव) छह दशमलव अंक दिखाएंगे।

एक संभावित लाभ इसे पढ़ने में है। आपकी सरणी अब मशीन युगल होगी, इसलिए पैक करने योग्य। मुझे यकीन नहीं है कि स्वचालित रूप से पैक प्राप्त करें या आयात करें, लेकिन डेवलपर 'टोपीएडएड्रे ऐसा करेगा।

--- संपादित 2011-02-11 ---

अब मैंने देखा है कि क्या गलत हो सकता है ...

यहाँ एक उदाहरण के लिए, अपने बाद में इनपुट का उपयोग कर रहा है और एक कुछ अन्य जो मुझे आशा है कि प्रतिनिधि होंगे।

aa = {7.469702041097916467293771347613073888816285869`15.\ 
    954589770191005*^-51, 5555.22222222222222222223, 
    .00000000002222222222222222222222222227777777777777, N[E, 22]^33} 

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

In[39]:= 
    InputForm[ToString[ 
     NumberForm[N[aa], 6, 
     NumberFormat :> (If[#3 != "", Row[{#1, "*^", #3}], #1] &)]]] 

Out[39]//InputForm= 
"{7.4697*^-51, 5555.22, 2.22222*^-11, 2.14644*^14}" 

ध्यान दें कि अभिव्यक्ति रूपांतरण इस पर ठीक काम करता है।

In[40]:= 
    InputForm[ToExpression[ 
     ToString[NumberForm[N[aa], 6, 
     NumberFormat :> (If[#3 != "", Row[{#1, "*^", #3}], #1] &)]]]] 

Out[40]//InputForm= 
{7.4697*^-51, 5555.22, 2.22222*^-11, 2.14644*^14} 

--- अंत संपादित करें ---

डैनियल Lichtblau Wolfram अनुसंधान

Answer 2

OutputForm अतिरिक्त अंक से छुटकारा पाने के लिए आपका मित्र है। यदि आप बैकटिक या precisions की जरूरत नहीं है आप एक स्ट्रिंग में हैक कर सकता है, हालांकि यह

f[x_,n_]:=StringJoin[ToString[OutputForm[N[x,n]]],"`",ToString[Round[Precision[N[x,n]]]]]; 

वैकल्पिक रूप से बदसूरत है, सरल उपाय है:

FormatList[l_,n_]:=OutputForm[N[#,n]]&//@l; 

संपादित करें: दूसरा समाधान नहीं करता है काम नहीं लग रहा है; अनंतिम ठीक

FormatList[l_,n_]:=OutputForm[N[#,n]&//@l]; 

Answer 3

है मैं आपकी समस्या का एक प्रत्यक्ष समाधान नहीं है, लेकिन मैं एक सुझाव है कि अन्य तरीकों से सहायक हो सकता है की क्या ज़रूरत है।

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

NumberMarks विकल्प InputForm et al के साथ आप बैकटिक्स और परिशुद्धता को भी दबा सकते हैं। यदि आप वास्तव में परिशुद्धता को कम करने में रुचि रखते हैं, तो मुझे लगता है कि N का उपयोग करने का तरीका है।

Answer 4

यहाँ

मेरा इच्छित, यानी, ज़रूरत से ज़्यादा अंक त्यागने के लिए मजबूर कर रहा मेथेमेटिका के एक बहुत ही kludgy तरीका है ।

aa = {7.469702041097916467293771347613073888816285869`15.954589770191005*^-51, ...}; 
list = RealDigits[N[aa, 6]]; 
bb = Thread @ #1*10.^(#2 - #3) &[FromDigits /@ First /@ list, 
          Last /@ list, 
          First /@ Dimensions /@ First /@ list]; 
InputForm @ bb 

{7.469700000000001*^-51, ...} 

जो पहले से ही एक सुधार है लेकिन अभी भी आवश्यकतानुसार चरित्र गणना की तुलना में दो गुना अधिक है।

संपादित करें: और हम एक विजेता है:

list = Transpose @ {FromDigits /@ First /@ #, 
        Last /@ #, 
        First /@ Dimensions /@ First /@ #}& @ RealDigits[N[aa, 6]]; 
bb = ToExpression[ToString[#1] <> ".*^" <> ToString[#2 - #3]] & @@@ list; 
InputForm @ bb 

{7.4697`*^-51, ...}