सी # बाइनरी इंट डिवीजन को दोबारा वापस करने के लिए कैसे मजबूर करें?

Question

डबल x = 3/2 को कैसे बल दें; डी प्रत्यय या कास्टिंग के बिना एक्स में 1.5 वापस करने के लिए? क्या कोई भी ऑपरेटर अधिभार है जिसे किया जा सकता है? या कुछ संकलक विकल्प?

आश्चर्यजनक रूप से, यह निम्न कारणों से कास्टिंग या प्रत्यय जोड़ने के लिए इतना आसान नहीं है:

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

लेकिन वे हमेशा मानते हैं कि डबल x = 3/2; x = 1.5 लौटाएगा हालांकि सी # में वापसी होगी 1.

ए वे हमेशा इसे भूल जाते हैं, बर्बाद समय डिबगिंग करते हैं, मुझे समर्थन के लिए कॉल करते हैं और हम इसे ठीक करते हैं। बी। वे सोचते हैं कि यह बहुत बदसूरत है और उनके व्यापार नियमों की पठनीयता को नुकसान पहुंचाता है।

जैसा कि आप जानते हैं, डीएसएल को प्राकृतिक भाषा की तरह अधिक होने की आवश्यकता है।

हां। हम बू को स्थानांतरित करने और इसके आधार पर एक डीएसएल बनाने की योजना बना रहे हैं, लेकिन यह सड़क से नीचे है।

क्या डबल x = 3/2 बनाने का कोई आसान समाधान है; वर्ग के बाहर बाहरी कुछ 1.5 लौटाएं ताकि यह उपयोगकर्ताओं के लिए अदृश्य हो?

धन्यवाद! वेन

Answer 1

नहीं, कोई समाधान नहीं है कि 3/2 वापसी 1.5 बना सकते हैं।

आपकी बाधाओं को ध्यान में रखते हुए एकमात्र कामकाज उपयोगकर्ताओं को फॉर्मूला में अक्षर का उपयोग करने के लिए हतोत्साहित करना है। उन्हें स्थिरांक का उपयोग करने के लिए प्रोत्साहित करें। या, यदि उन्हें वास्तव में अक्षर का उपयोग करने की आवश्यकता है, तो उन्हें दशमलव बिंदु के साथ अक्षर का उपयोग करने के लिए प्रोत्साहित करें।

Answer 2

सरल, अगर मैं गलत नहीं हूँ:

double x = 3D/2D; 

Answer 3

एक समाधान एक विधि लिख रहा होगा जो उनके लिए ऐसा करता है और उन्हें इसका उपयोग करने के लिए सिखाता है। आपकी विधि हमेशा युगल में ले जाएगी और उत्तर में हमेशा दशमलव की सही संख्या होगी।

Answer 4

मैं बहुत यकीन नहीं है, लेकिन मेरा मानना ​​है कि आप एक डबल 3.0/2.0 का उपयोग कर प्राप्त कर सकते हैं लेकिन अगर आप .0 लगता है सिर्फ प्रत्यय लगाना का एक और तरीका के रूप में तो यह जवाब

Answer 5

हो सकता है कि नहीं है भी :-) आप अब RPN Expression Parser Class को आज या bcParser पर आजमा सकते हैं? ये लाइब्रेरी पार्सिंग बहुत छोटी अभिव्यक्ति हैं।

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

तो मुझे दुर्भाग्य से कहना होगा कि दुर्भाग्यवश आपकी पसंद सी # की पसंद उन दर्शकों के लिए सबसे अच्छी नहीं हो सकती है।

बू को स्थिर रूप से टाइप किया गया प्रतीत होता है। क्या आपने जावास्क्रिप्ट इंजन, पायथन, या कुछ अन्य गतिशील रूप से टाइप किए गए इंजन को एम्बेड करने के बारे में सोचा है? आमतौर पर मौजूदा एप्लिकेशन में प्लग करना कठिन नहीं होता है और आपके पास बहुत सारे मौजूदा दस्तावेज का लाभ होता है।

Answer 6

शायद int32 पर एक extenstion विधि?

Answer 7

सी # कंपाइलर को पास करने से पहले प्रीप्रोसेस सूत्र। कुछ ऐसा करें:

formula = Regex.Replace(formula, @"(^|[\^\s\+\*\/-])(\d+)(?![DF\.])", "$1$2D") 

पूर्णांक अक्षरों को डबल अक्षरों में परिवर्तित करने के लिए।

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

Answer 8

इस तरह यह कर का प्रयास करें:

double result = (double) 3/2; 

परिणाम = 1.5

Answer 9

कभी नहीं कभी नहीं कहते हैं ... (डबल) 3/2 समाधान अच्छा लग रहा है ...

लेकिन यह 4 + 5/6

के लिए असफल रहा: सार्वजनिक डोमेन को दान किया गया ताकि सिंबलिक कॉम्प्यूटेशन डॉट कॉम द्वारा स्वतंत्र रूप से उपयोग किया जा सके।
यह अल्फा है लेकिन आप इसे आजमा सकते हैं, मैंने इसे केवल कुछ परीक्षणों पर चलाया है, मेरी साइट और सॉफ़्टवेयर जल्द ही होना चाहिए। यह माइक्रोसॉफ्ट के रोज़लिन का उपयोग करता है, अगर यह सब ठीक हो जाता है तो यह प्रत्येक नंबर के बाद 'डी' लगाएगा। Roslyn अल्फा भी है, लेकिन यह सी # के एक उचित बिट पार्स होगा।

public static String AddDSuffixesToEquation(String inEquation) 
    { 
     SyntaxNode syntaxNode = EquationToSyntaxNode(inEquation); 
     List<SyntaxNode> branches = syntaxNode.DescendentNodesAndSelf().ToList(); 
     List<Int32> numericBranchIndexes = new List<int>(); 
     List<SyntaxNode> replacements = new List<SyntaxNode>(); 
     SyntaxNode replacement; 
     String lStr; 
     Int32 L; 
     for (L = 0; L < branches.Count; L++) 
     { 
      if (branches[L].Kind == SyntaxKind.NumericLiteralExpression) 
      { 
       numericBranchIndexes.Add(L); 
       lStr = branches[L].ToString() + "d"; 
       replacement = EquationToSyntaxNode(lStr); 
       replacements.Add(replacement); 
      } 
     } 

     replacement = EquationToSyntaxNode(inEquation); 
     List<SyntaxNode> replaceMeBranches; 
     for (L = numericBranchIndexes.Count - 1; L >= 0; L--) 
     { 
      replaceMeBranches = replacement.DescendentNodesAndSelf().ToList(); 
      replacement = replacement.ReplaceNode(replaceMeBranches[numericBranchIndexes[L]],replacements[L]); 
     } 
     return replacement.ToString(); 

    } 

    public static SyntaxNode EquationToSyntaxNode(String inEquation) 
    { 
     SyntaxTree tree = EquationToSyntaxTree(inEquation); 
     return EquationSyntaxTreeToEquationSyntaxNode(tree); 
    } 

    public static SyntaxTree EquationToSyntaxTree(String inEquation) 
    { 
     return SyntaxTree.ParseCompilationUnit("using System; class Calc { public static object Eval() { return " + inEquation + "; } }"); 
    } 

    public static SyntaxNode EquationSyntaxTreeToEquationSyntaxNode(SyntaxTree syntaxTree) 
    { 
     SyntaxNode syntaxNode = syntaxTree.Root.DescendentNodes().First(x => x.Kind == SyntaxKind.ReturnStatement); 
     return syntaxNode.ChildNodes().First(); 
    }