www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Specializing on Compile Time Constants

reply dsimcha <dsimcha yahoo.com> writes:
I'm working on a mathematical expression interpreter for D, which would allow
for closed form mathematical expressions to be specified as string literals at
runtime and be evaluated.  For example:

MathExp myExpression = mathExp("x^2 + e^cos(-x) - 2 * sqrt(pi)", "x");
writeln(myExpression(2));  // Does exactly what you think it does.

I've found the syntax so convenient that I'd like to transparently specialize
it on strings known at compile time.  The idea is that, when the expression is
hard-coded, you will still be able to use the MathExp interface, but your
expression will evaluate at the full speed of a statically compiled function.
 Is there any way to test whether the value of an argument to a template
function is known at compile time and specialize on this?
Oct 12 2009
next sibling parent reply Jacob Carlborg <doob me.com> writes:
On 10/12/09 23:49, dsimcha wrote:

 I'm working on a mathematical expression interpreter for D, which would allow
 for closed form mathematical expressions to be specified as string literals at
 runtime and be evaluated.  For example:

 MathExp myExpression = mathExp("x^2 + e^cos(-x) - 2 * sqrt(pi)", "x");
 writeln(myExpression(2));  // Does exactly what you think it does.

 I've found the syntax so convenient that I'd like to transparently specialize
 it on strings known at compile time.  The idea is that, when the expression is
 hard-coded, you will still be able to use the MathExp interface, but your
 expression will evaluate at the full speed of a statically compiled function.
   Is there any way to test whether the value of an argument to a template
 function is known at compile time and specialize on this?


Doesn't all values to a template have to be known at compile time
Oct 12 2009
parent reply dsimcha <dsimcha yahoo.com> writes:
== Quote from Jacob Carlborg (doob me.com)'s article

 On 10/12/09 23:49, dsimcha wrote:

 I'm working on a mathematical expression interpreter for D, which would allow
 for closed form mathematical expressions to be specified as string literals at
 runtime and be evaluated.  For example:

 MathExp myExpression = mathExp("x^2 + e^cos(-x) - 2 * sqrt(pi)", "x");
 writeln(myExpression(2));  // Does exactly what you think it does.

 I've found the syntax so convenient that I'd like to transparently specialize
 it on strings known at compile time.  The idea is that, when the expression is
 hard-coded, you will still be able to use the MathExp interface, but your
 expression will evaluate at the full speed of a statically compiled function.
   Is there any way to test whether the value of an argument to a template
 function is known at compile time and specialize on this?


 Doesn't all values to a template have to be known at compile time


No, I mean the *function* parameters of a template function.
Oct 12 2009
next sibling parent reply Jacob Carlborg <doob me.com> writes:
On 10/12/09 23:55, dsimcha wrote:

 == Quote from Jacob Carlborg (doob me.com)'s article

 On 10/12/09 23:49, dsimcha wrote:

 I'm working on a mathematical expression interpreter for D, which would allow
 for closed form mathematical expressions to be specified as string literals at
 runtime and be evaluated.  For example:

 MathExp myExpression = mathExp("x^2 + e^cos(-x) - 2 * sqrt(pi)", "x");
 writeln(myExpression(2));  // Does exactly what you think it does.

 I've found the syntax so convenient that I'd like to transparently specialize
 it on strings known at compile time.  The idea is that, when the expression is
 hard-coded, you will still be able to use the MathExp interface, but your
 expression will evaluate at the full speed of a statically compiled function.
    Is there any way to test whether the value of an argument to a template
 function is known at compile time and specialize on this?


 Doesn't all values to a template have to be known at compile time


 No, I mean the *function* parameters of a template function.


Can't you pass the values as template arguments? Seems you working with 
strings (and numbers?). mathExp!("x^2 + e^cos(-x) - 2 * sqrt(pi)", "x"); 
Note the ! after the function name.
Oct 12 2009
parent dsimcha <dsimcha yahoo.com> writes:
== Quote from Jacob Carlborg (doob me.com)'s article

 On 10/12/09 23:55, dsimcha wrote:

 == Quote from Jacob Carlborg (doob me.com)'s article

 On 10/12/09 23:49, dsimcha wrote:

 I'm working on a mathematical expression interpreter for D, which would allow
 for closed form mathematical expressions to be specified as string literals at
 runtime and be evaluated.  For example:

 MathExp myExpression = mathExp("x^2 + e^cos(-x) - 2 * sqrt(pi)", "x");
 writeln(myExpression(2));  // Does exactly what you think it does.

 I've found the syntax so convenient that I'd like to transparently specialize
 it on strings known at compile time.  The idea is that, when the expression is
 hard-coded, you will still be able to use the MathExp interface, but your
 expression will evaluate at the full speed of a statically compiled function.
    Is there any way to test whether the value of an argument to a template
 function is known at compile time and specialize on this?


 Doesn't all values to a template have to be known at compile time


 No, I mean the *function* parameters of a template function.


 Can't you pass the values as template arguments? Seems you working with
 strings (and numbers?). mathExp!("x^2 + e^cos(-x) - 2 * sqrt(pi)", "x");
 Note the ! after the function name.


This would work, but it's a bit kludgey because it requires the user to
explicitly
specify that the string is known at compile time.  I was wondering if this could
be done transparently.
Oct 12 2009
prev sibling parent reply "Lars T. Kyllingstad" <public kyllingen.NOSPAMnet> writes:
dsimcha wrote:

 == Quote from Jacob Carlborg (doob me.com)'s article

 On 10/12/09 23:49, dsimcha wrote:

 I'm working on a mathematical expression interpreter for D, which would allow
 for closed form mathematical expressions to be specified as string literals at
 runtime and be evaluated.  For example:

 MathExp myExpression = mathExp("x^2 + e^cos(-x) - 2 * sqrt(pi)", "x");
 writeln(myExpression(2));  // Does exactly what you think it does.

 I've found the syntax so convenient that I'd like to transparently specialize
 it on strings known at compile time.  The idea is that, when the expression is
 hard-coded, you will still be able to use the MathExp interface, but your
 expression will evaluate at the full speed of a statically compiled function.
   Is there any way to test whether the value of an argument to a template
 function is known at compile time and specialize on this?


 Doesn't all values to a template have to be known at compile time


 
 No, I mean the *function* parameters of a template function.



I may be wrong, but I seem to remember reading somewhere that DMD always 
tries to evaluate as much as possible at compile time. That is, if a 
function is CTFE-enabled, and its input is known at compile time, it is 
calculated at compile time.

     void main(string[] args) {
         auto x = foo(args[1]);  // foo() is evaluated at run time
         auto y = bar("baz");    // foo() is evaluated at compile time
     }

That said, I also seem to remember that the use of structs and classes 
is very limited (or nonexistent) in CTFE, and I guess your mathExp() is 
supposed to return a MathExp struct...

-Lars
Oct 13 2009
parent Fawzi Mohamed <fmohamed mac.com> writes:
On 2009-10-13 09:11:08 +0200, "Lars T. Kyllingstad" 
<public kyllingen.NOSPAMnet> said:


 I may be wrong, but I seem to remember reading somewhere that DMD 
 always tries to evaluate as much as possible at compile time. That is, 
 if a function is CTFE-enabled, and its input is known at compile time, 
 it is calculated at compile time.
 
      void main(string[] args) {
          auto x = foo(args[1]);  // foo() is evaluated at run time
          auto y = bar("baz");    // foo() is evaluated at compile time
      }


you are wrong, compile time evaluation is not performed if not 
requested (by making that constant for example).
The compiler cannot know the complexity of the calculation, and making 
it at compile time is much slower...
thus you have to explicitly instruct the computer to do it...
Oct 13 2009
prev sibling next sibling parent Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
dsimcha wrote:

 I'm working on a mathematical expression interpreter for D, which would allow
 for closed form mathematical expressions to be specified as string literals at
 runtime and be evaluated.  For example:
 
 MathExp myExpression = mathExp("x^2 + e^cos(-x) - 2 * sqrt(pi)", "x");
 writeln(myExpression(2));  // Does exactly what you think it does.
 
 I've found the syntax so convenient that I'd like to transparently specialize
 it on strings known at compile time.  The idea is that, when the expression is
 hard-coded, you will still be able to use the MathExp interface, but your
 expression will evaluate at the full speed of a statically compiled function.
  Is there any way to test whether the value of an argument to a template
 function is known at compile time and specialize on this?


As an aside, I'd so use that if you allowed LaTeX math expressions.

Andrei
Oct 12 2009
prev sibling next sibling parent bearophile <bearophileHUGS lycos.com> writes:
dsimcha:


  Is there any way to test whether the value of an argument to a template
 function is known at compile time and specialize on this?


Do you mean this?
http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=97424

Bye,
bearophile
Oct 12 2009
prev sibling parent "Lars T. Kyllingstad" <public kyllingen.NOSPAMnet> writes:
dsimcha wrote:

 I'm working on a mathematical expression interpreter for D, which would allow
 for closed form mathematical expressions to be specified as string literals at
 runtime and be evaluated.  For example:
 
 MathExp myExpression = mathExp("x^2 + e^cos(-x) - 2 * sqrt(pi)", "x");
 writeln(myExpression(2));  // Does exactly what you think it does.
 
 I've found the syntax so convenient that I'd like to transparently specialize
 it on strings known at compile time.  The idea is that, when the expression is
 hard-coded, you will still be able to use the MathExp interface, but your
 expression will evaluate at the full speed of a statically compiled function.



This is *so* cool. :)

-Lars
Oct 13 2009