Cómo forzar C# binary int division a devolver un doble?

Question

Cómo forzar doble x = 3/2; para devolver 1.5 en x sin el sufijo D o el casting? ¿Hay algún tipo de sobrecarga del operador que pueda hacerse? O alguna opción de compilador?

Sorprendentemente, no es tan simple de añadir el casting o sufijo por la siguiente razón:

usuarios de negocios necesitan para escribir y depurar sus propias fórmulas. Actualmente, C# se está utilizando como un DSL (lenguaje específico de dominio) en el sentido de que estos usuarios no son ingenieros en informática. Entonces, todo lo que saben es cómo editar y crear algunos tipos de clases para mantener sus "reglas comerciales", que generalmente son solo fórmulas matemáticas.

Pero siempre asumen que el doble x = 3/2; devolverá x = 1.5 , sin embargo, en C# que devuelve 1.

A. Siempre olvidan esto, pierden el tiempo depurando, llámame para obtener asistencia técnica y lo solucionamos. B. piensan que es muy feo y perjudica la legibilidad de sus reglas comerciales.

Como ya sabe, las DSL deben ser más como un lenguaje natural.

Sí. Estamos planeando mudarnos a Boo y construir un DSL basado en él, pero eso es más adelante.

¿Existe una solución simple para hacer doble x = 3/2; ¿devuelve 1.5 por algo externo a la clase por lo que es invisible para los usuarios?

Gracias! Wayne

Answer 1

No, no hay ninguna solución que puede hacer 3/2 retorno 1.5.

La única solución teniendo en cuenta sus limitaciones es desalentar a los usuarios a utilizar literales en la fórmula. Anímalos a usar constantes. O, si realmente necesitan usar literales, aliéntelos a usar literales con un punto decimal.

Answer 2

simple, si no me equivoco:

double x = 3D/2D; 

Answer 3

Una solución sería escribir un método que haga esto por ellos y enseñarles a usarlo. Tu método siempre tomará dobles y la respuesta siempre tendrá la cantidad correcta de decimales.

Answer 4

No estoy bastante seguro, pero creo que se puede conseguir un doble, con 3.0/2.0 Pero si usted piensa 0,0 simplemente como otra forma de sufijación entonces no es la respuesta también :-)

Answer 5

Tal vez puede probar RPN Expression Parser Class por ahora o bcParser? Estas son bibliotecas de análisis de expresiones muy pequeñas.

Me gustan los lenguajes fuertes y estáticos para mi propio trabajo, pero no creo que sean adecuados para principiantes que no tienen interés en convertirse en profesionales.

Así que tengo que decir que lamentablemente su elección de C# podría no haber sido la mejor para esa audiencia.

Boo parece estar tipicamente escrito a. ¿Has pensado en incorporar un motor Javascript, Python u otro motor de tipado dinámico? Por lo general, estos no son tan difíciles de conectar a una aplicación existente y usted tiene la ventaja de contar con una gran cantidad de documentación existente.

Answer 6

¿Quizás un método de extensión en int32?

Answer 7

Procesa las fórmulas antes de pasarlas al compilador C#. Haga algo como:

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

Para convertir literales enteros a dobles literales.

De forma alternativa, puede usar una máquina de estado simple para rastrear si está o no en un literal de cadena o un comentario en lugar de reemplazar ciegamente, pero para fórmulas simples creo que una expresión regular será suficiente.

Answer 8

trata de hacerlo de esta manera:

double result = (double) 3/2; 

resultado = 1,5

Answer 9

Nunca

nunca se dicen ... El (doble) 3/2 solución se ve bien ...

pero falló para 4 + 5/6

prueba esto: donó al dominio público para ser utilizado libremente por SymbolicComputation.com.
Es alfa pero puede probarlo, solo lo he ejecutado en algunas pruebas, mi sitio y software deberían estar listos pronto. Utiliza Roslyn de Microsoft, pondrá una 'd' después de cada número si todo va bien. Roslyn también es alfa, pero analizará un poco de 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(); 
    }