Comment forcer c division int # binaire pour retourner un double?

Question

Comment forcer double x = 3/2; pour revenir à 1,5 x sans le suffixe D ou coulée? Y at-il sorte de surcharge de l'opérateur qui peut être fait? Ou une option du compilateur?

Etonnamment, ce n'est pas si simple d'ajouter la coulée ou un suffixe pour la raison suivante:

Les utilisateurs professionnels ont besoin d'écrire et déboguer leurs propres formules. Actuellement, C # est utilisé comme un se DSL (Domain Specific Language) en ce que ces utilisateurs ne sont pas des ingénieurs en informatique. Donc, tout ce qu'ils savent comment modifier et créer quelques types de classes pour tenir leurs « règles métier » qui sont généralement seulement des formules mathématiques.

Mais ils supposent toujours que le double x = 3/2; sera de retour x = 1,5 mais en C # qui retourne 1.

A. ils oublient toujours cela, le débogage de perte de temps, appelez-moi pour le soutien et nous le réparer. B. ils pensent qu'il est très laid et nuit à la lisibilité de leurs règles métier.

Comme vous le savez, le besoin de DSL pour être plus comme langage naturel.

Oui. Nous prévoyons de passer à Boo et construire un DSL basé sur elle, mais qui est sur la route.

Y at-il une solution simple à faire double x = 3/2; retour 1,5 par quelque chose d'extérieur à la classe de sorte qu'il est invisible pour les utilisateurs?

Merci! Wayne

Answer 1

Non, il n'y a pas de solution qui peut faire retour 3 / 2 1.5.

La seule solution prenant en compte vos contraintes est de décourager les utilisateurs d'utiliser littéraux dans la formule. Encouragez-les à utiliser des constantes. Ou, si elles ont vraiment besoin d'utiliser littéraux, Encouragez-les à utiliser littéraux avec un point décimal.

Answer 2

ne jamais dire jamais ... La solution (double) a l'air bien ... 3/2

mais il a échoué pour 4 + 5/6

essayez ceci: donné au domaine public à utiliser librement SymbolicComputation.com.
Il est l'alpha, mais vous pouvez l'essayer, je n'ai plus que sur quelques tests, mon site et le logiciel devrait être bientôt. Il utilise Roslyn de Microsoft, il va mettre un « d » après chaque numéro, si tout va bien. Roslyn est l'alpha aussi, mais il va analyser un peu juste 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 je ne me trompe pas:

double x = 3D / 2D;

Answer 4

Une solution serait d'écrire une méthode qui fait cela pour eux et leur apprendre à l'utiliser. Votre méthode serait toujours prendre en double et la réponse sera toujours le bon nombre de décimales.

Answer 5

Je ne suis pas assez sûr, mais je crois que vous pouvez obtenir un double en utilisant 3.0 / 2.0 Mais si vous pensez .0 comme une autre façon de suffixation alors il est pas la réponse aussi: -)

Answer 6

Peut-être que vous pouvez essayer RPN Expression Parser classe pour l'instant ou bcParser ? Ceux-ci sont très petites bibliothèques analyse syntaxique d'expression.

J'aime fort, langues tapées pour statiquement mon propre travail, mais je ne pense pas qu'ils sont adaptés pour les débutants qui ont aucun intérêt pour les professionnels devenir.

Je dois dire que, malheureusement, votre choix de C # peut-être pas de été le meilleur pour ce public.

Boo semble être statiquement typé à. Avez-vous pensé à intégrer un moteur Javascript, Python, ou un autre moteur typé dynamiquement? Ceux-ci ne sont généralement pas si difficile à brancher sur une application existante et vous avez l'avantage des lots de la documentation existante.

Answer 7

Peut-être une méthode d'extension sur int32?

Answer 8

formules Prétraitez avant de les transmettre au compilateur C #. Faites quelque chose comme:

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

Pour convertir littéraux entiers à doubles littéraux.

Alternativement, vous pouvez utiliser une simple machine d'état afin de déterminer si oui ou non vous êtes dans une chaîne de caractères ou un commentaire plutôt que aveuglément remplacer, mais pour des formules simples, je pense qu'un regex suffit.

Answer 9

Essayez de le faire comme ceci:

double result = (double) 3 / 2;

result = 1,5