Как заставить C# двоичное int-деление возвратить двойной?

Question

Как заставить double x = 3/2; вернуть 1,5 дюйма х без суффикса D или литья? Есть ли какая-либо перегрузка оператора, которая может быть выполнена? Или какой-то вариант компилятора?

Удивительно, но это не так просто, чтобы добавить отливку или суффикс по следующей причине:

Бизнес-пользователи должны писать и отлаживать свои собственные формулы. В настоящее время C# используется как DSL (язык, специфичный для домена), поскольку эти пользователи не являются инженерами-информатиками. Таким образом, все, что они знают, это то, как редактировать и создавать несколько типов классов для хранения своих «бизнес-правил», которые обычно являются математическими формулами.

Но они всегда предполагают, что double x = 3/2; будет возвращать x = 1,5 , однако в C#, который возвращает 1.

A. они всегда забывают об этом, отлаживая время отладки, позвоните мне для поддержки, и мы исправим его. B. Они считают, что это очень уродливо и ущемляет читаемость их бизнес-правил.

Как вы знаете, DSL должен быть больше похож на естественный язык.

Да. Мы планируем перейти к Boo и построить DSL на основе этого, но это в будущем.

Есть ли простой способ сделать двойной x = 3/2; вернуть 1.5 чем-то внешним по отношению к классу, чтобы он был невидим для пользователей?

Спасибо! Wayne

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? Это очень маленькие библиотеки разбора выражений.

Мне нравятся сильные, статически типизированные языки для моей работы, но я не думаю, что они подходят для новичков, которые не заинтересованы в том, чтобы стать профессионалами.

Так что я должен сказать, что, к сожалению, ваш выбор C# не мог быть лучшим для этой аудитории.

Boo, кажется, статически типизирован. Думали ли вы о внедрении движка Javascript, Python или какого-либо другого динамически типизированного движка? Как правило, это не так сложно подключить к существующему приложению, и у вас есть много документов.

Answer 6

Возможно, метод extenstion для int32?

Answer 7

Предварительные формулы перед передачей их компилятору C#. Сделайте что-то вроде:

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

Чтобы преобразовать целочисленные литералы в двойные литералы.

В качестве альтернативы, вы можете использовать простой конечный автомат для отслеживания того, находитесь ли вы в строчном литерале или комментарии, а не вслепую замену, но для простых формул я думаю, что регулярное выражение будет достаточным.

Answer 8

Попробуйте сделать это следующим образом:

double result = (double) 3/2; 

результат = 1,5

Answer 9

никогда не говори никогда ... The (двойной) 3/2 решение выглядит красиво ...

но это не удалось для 4 + 5/6

попробуйте следующее: пожертвовано общественному достоянию, которое будет использоваться свободно на SymbolicComput.com.
Это альфа, но вы можете попробовать, я только запускаю его на нескольких тестах, мой сайт и программное обеспечение должны скоро появиться. Он использует Microsoft Roslyn, он поместит «d» после каждого номера, если все будет хорошо. Рослин тоже альфа, но он будет разбирать честный бит C#.

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(); 
    }