## 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?

Asked by Charlie

## 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);
```

Answered by dtb

## 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.

Answered by General Grey

## Solution #3

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

You asked:

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

Answered by Brian R. Bondy

## 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 ----------------
private readonly double _value;
#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 --------------
}
}
```

Answered by Petter

## Solution #5

I’m surprised no one has addressed this, since you simply multiply by itself in the simple (and arguably most common) instance of squaring.

```
float someNumber;
float result = someNumber * someNumber;
```

Answered by RubberDuck

**Post is based on https://stackoverflow.com/questions/3034604/is-there-an-exponent-operator-in-c**