how to generate/compute x^1+...x^n type equation in c#?

Question

Question pertains to series type math problems:

x^1+x^2+x^3+...+x^n

please note, this is just a simple example. each iteration of n could be more complex. i am not actually looking to calculate this equation.. just curious about what constructs are available..

i know i could write a simple loop or use recursion to accomplish this. But i remember reading about some construct in c# that will pre-compile such a statement for later execution. This was years ago, and it might have been using reflection.. can't recall.

are there any other interesting ways to accomplish this?

Answer 1

To calculate x^n use Math.Pow:

Math.Pow(x, n)

If you want to calculate the sum you could use a loop or LINQ. I don't think there's anything wrong with a simple loop here:

double total = 0;
for (int i = 1; i <= n; ++i)
{
    total += Math.Pow(x, i);
}
Console.WriteLine(total);

You can write this in LINQ but I don't see any particularly strong reason to do so. Perhaps you could expand on what features you are looking for? Are you looking for better performance?

Since your question is tagged 'mathematical-optimization' you might also want to optimize it by finding a shortcut. In this specific case it is a geometric series so you can use the formula:

Or in C#:

static double geometricSeries(double a, double r, int n)
{
    return a * (1 - Math.Pow(r, n + 1)) / (1 - r);
}

In other more complex cases finding the formula might be more difficult.

Answer 2

int total = 0;
for(int i = 1; i <= n; i++)
    total += Math.Pow(x, i);

Answer 3

Well you might be talking about using a delegate for deferred execution. But in many cases it's the same as writing a method. For example, let's start with the "simple" way of doing it:

public static double SumExponents(double x, int n)
{
    double total = 0;
    for (int i = 1; i <= n; i++)
    {
         total += Math.Pow(x, i);
    }
    return total;
}

This can be written using LINQ as:

public static double SumExponents(double x, int n)
{
    return Enumerable.Range(1, n)
                     .Select(i => Math.Pow(x, i))
                     .Sum();
}

You could then write this as a single lambda expression:

Func<double, int, double> func = (x, n) => Enumerable.Range(1, n)
                                              .Select(i => Math.Pow(x, i))
                                              .Sum();

Is that the sort of thing you were thinking of? If not, please clarify your question. It's not really obvious what you're looking for.

Answer 4

There's nothing specific to C# about geometric progression. You can compute this sum in O(1) time. (Assuming power operation takes constant time.)

In your case, the formula would be

x*(x^n - 1)/(x - 1)

Answer 5

As well as select\sum, you can also use Aggregate for folding sequences.

int n;
double x;
double result = Enumerable.Range(1, n)
    .Aggregate(0.0, (acc, i) => acc + Math.Pow(x, i));

Answer 6

I understand that your example is intentionally trivial. However, if what you're really trying to calculate is still a polynomial, then you should definitely use Horner scheme. Here's a C# implementation.