# In C#, is there an exponent operator?

## Problem

Is there, for example, an operator that can deal with this?

``````float Result, Number1, Number2;

Number1 = 2;
Number2 = 2;

Result = Number1 (operator) Number2;
``````

In other languages, the operator has previously acted as an exponential operator, but in C#, it is a bit-wise operator.

To handle exponential operations, do I need to construct a loop or include another namespace? If that’s the case, how do I handle non-integer exponential operations?

## Solution #1

The power operator isn’t available in C#. However, the .NET Framework offers the Math.Pow method:

As an example, consider the following:

``````float Result, Number1, Number2;

Number1 = 2;
Number2 = 2;

Result = Math.Pow(Number1, Number2);
``````

## Solution #2

I came across this post when looking for a way to use scientific notation in my code, so I used it.

``````4.95*Math.Pow(10,-10);
``````

However, I discovered afterwards that you can do it.

``````4.95E-10;
``````

Just thought I would add this for anyone in a similar situation that I was in.

## Solution #3

The C# team has written a blog post on MSDN detailing why an exponent operator does not exist.

Math. Because Pow supports double parameters, you won’t have to write your own.

## Solution #4

When we were looking for a new language to convert our math software from VB6, the lack of an exponential operator in C# was a major nuisance.

I’m delighted we chose C#, but it still irritates me when I have to write a difficult equation with exponents. The Math.Pow() function, in my opinion, makes equations difficult to read.

We came up with a solution by creating a custom DoubleX class that overrides the -operator (see below)

As long as at least one of the variables is declared as DoubleX, this works very well:

``````DoubleX a = 2;
DoubleX b = 3;

Console.WriteLine(\$"a = {a}, b = {b}, a^b = {a ^ b}");
``````

Alternatively, on standard doubles, use an explicit converter:

``````double c = 2;
double d = 3;

Console.WriteLine(\$"c = {c}, d = {d}, c^d = {c ^ (DoubleX)d}");     // Need explicit converter
``````

However, as compared to other operators, this technique has one flaw: the exponent is calculated in the wrong order. This can be prevented by adding an extra () around the operation, which makes the equations a little more difficult to read:

``````DoubleX a = 2;
DoubleX b = 3;

Console.WriteLine(\$"a = {a}, b = {b}, 3+a^b = {3 + a ^ b}");        // Wrong result
Console.WriteLine(\$"a = {a}, b = {b}, 3+a^b = {3 + (a ^ b)}");      // Correct result
``````

I hope this is useful to people who write code with a lot of difficult equations, and perhaps someone has a suggestion for how to enhance this method?!

DoubleX class:

``````using System;

namespace ExponentialOperator
{
/// <summary>
/// Double class that uses ^ as exponential operator
/// </summary>
public class DoubleX
{
#region ---------------- Fields ----------------

#endregion ------------- Fields ----------------

#region -------------- Properties --------------

public double Value
{
get { return _value; }
}

#endregion ----------- Properties --------------

#region ------------- Constructors -------------

public DoubleX(double value)
{
_value = value;
}

public DoubleX(int value)
{
_value = Convert.ToDouble(value);
}

#endregion ---------- Constructors -------------

#region --------------- Methods ----------------

public override string ToString()
{
return _value.ToString();
}

#endregion ------------ Methods ----------------

#region -------------- Operators ---------------

// Change the ^ operator to be used for exponents.

public static DoubleX operator ^(DoubleX value, DoubleX exponent)
{
return Math.Pow(value, exponent);
}

public static DoubleX operator ^(DoubleX value, double exponent)
{
return Math.Pow(value, exponent);
}

public static DoubleX operator ^(double value, DoubleX exponent)
{
return Math.Pow(value, exponent);
}

public static DoubleX operator ^(DoubleX value, int exponent)
{
return Math.Pow(value, exponent);
}

#endregion ----------- Operators ---------------

#region -------------- Converters --------------

// Allow implicit convertion

public static implicit operator DoubleX(double value)
{
return new DoubleX(value);
}

public static implicit operator DoubleX(int value)
{
return new DoubleX(value);
}

public static implicit operator Double(DoubleX value)
{
return value._value;
}

#endregion ----------- Converters --------------
}
}
``````

``````float someNumber;