Cómo forzar c int # binaria división para devolver un doble?

Question

Cómo forzar doble x = 3/2; para volver en 1,5 x sin el sufijo D o de fundición? ¿Hay algún tipo de sobrecarga del operador que se puede hacer? O alguna opción de compilador?

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

Los usuarios de negocio necesitan escribir y depurar sus propias fórmulas. Actualmente C # es acostumbrarse como un DSL (lenguaje específico de dominio) en que estos usuarios no son ingenieros informáticos. Así que todo lo que saben es cómo editar y crear algunos tipos de clases para mantener sus "reglas de negocio", que son por lo general sólo fórmulas matemáticas.

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

A. que siempre se olvidan de esto, el tiempo de depuración de residuos, me llaman para la ayuda y lo arreglamos. B. piensan que es muy feo y perjudica la legibilidad de sus reglas de negocio.

Como se sabe, la necesidad de DSL para ser más como el lenguaje natural.

Sí. Estamos planeando para mover a Boo y construir una conexión DSL basado en él, sino que es por la carretera.

¿Hay una solución simple para hacer doble x = 3/2; devolver 1,5 por algo externo a la clase lo que es invisible para los usuarios?

Gracias! Wayne

Answer 1

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

La única solución teniendo en cuenta sus limitaciones es disuadir a los usuarios a utilizar los literales en la fórmula. Fomentar el uso de las constantes. O, si realmente necesitan utilizar literales, animarles a utilizar literales con un punto decimal.

Answer 2

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

pero falló para 4 + 5/6

intente lo siguiente: donado al dominio público para ser utilizado libremente por SymbolicComputation.com.
Es alfa, pero se puede probar que fuera, lo único que he encontrado que en algunas pruebas, mi sitio y el software debe ser pronto. Utiliza Roslyn de Microsoft, que va a poner un 'd' después de cada número, si todo va bien. Roslyn es alfa también, pero va a 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();
    }

Answer 3

simple, si no me equivoco:

double x = 3D / 2D;

Answer 4

Una solución sería escribir un método que hace esto para ellos y les enseñan a usarlo. Su método siempre tomaría en dobles y la respuesta siempre tendrá el número correcto de decimales.

Answer 5

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 demasiado: -)

Answer 6

Tal vez se puede tratar RPN analizador de expresiones Clase por ahora o bcParser ? Estos son muy pequeñas bibliotecas de expresión de análisis.

Me gusta fuertes idiomas, tipos estáticos para mi propio trabajo, pero no creo que están adaptados para los principiantes que no tienen ningún interés en convertirse en profesionales.

Así que tendría que decir que lamentablemente su elección de C # no podría de sido la mejor para ese público.

Boo parece ser de tipo estático a. ¿Ha pensado en la incorporación de un motor de Javascript, Python, o algún otro motor de tipos dinámicos? Estos por lo general no son tan difíciles de conectar a una aplicación existente y tiene el beneficio de una gran cantidad de documentación existente.

Answer 7

Tal vez un método de extensión en int32?

Answer 8

fórmulas preproceso antes de pasarlos al compilador de C #. Hacer algo como:

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

Para convertir literales enteros a los literales dobles.

Como alternativa, se puede utilizar una máquina de estados sencilla de realizar un seguimiento de si está o no está en una cadena literal o comentario en lugar de reemplazar a ciegas, sino por simples fórmulas Creo que será suficiente una expresión regular.

Answer 9

Trate de hacer lo siguiente:

double result = (double) 3 / 2;

resultado = 1,5