Bestaat er bijvoorbeeld een operator om dit af te handelen?
float Result, Number1, Number2;
Number1 = 2;
Number2 = 2;
Result = Number1 (operator) Number2;
In het verleden heeft de operator ^gediend als exponentiële operator in andere talen, maar in C# is het een bitsgewijze operator.
Moet ik een lus schrijven of een andere naamruimte opnemen om exponentiële bewerkingen af te handelen? Zo ja, hoe ga ik om met exponentiële bewerkingen met niet-gehele getallen?
Antwoord 1, autoriteit 100%
De C#-taal heeft geen macht exploitant. Het .NET Framework biedt echter de Math.Powmethode:
Retourneert een opgegeven getal tot de opgegeven macht.
Uw voorbeeld ziet er dus als volgt uit:
float Result, Number1, Number2;
Number1 = 2;
Number2 = 2;
Result = Math.Pow(Number1, Number2);
Antwoord 2, autoriteit 22%
Ik stuitte op dit bericht op zoek naar wetenschappelijke notatie in mijn code, ik gebruikte
4.95*Math.Pow(10,-10);
Maar achteraf kwam ik erachter dat je dat wel kunt
4.95E-10;
Ik dacht dat ik dit zou toevoegen voor iedereen in een vergelijkbare situatie waarin ik me bevond.
Antwoord 3, autoriteit 13%
Er is een blogpost op MSDN over waarom een exponent-operator NIET bestaatvan het C#-team.
Het zou mogelijk zijn om een kracht toe te voegen
operator naar de taal, maar
het uitvoeren van deze operatie is een redelijk
zeldzaam om te doen in de meeste programma’s, en
het lijkt niet gerechtvaardigd om een toe te voegen
operator bij het aanroepen van Math.Pow() is
eenvoudig.
Je vroeg:
Moet ik een lus schrijven of opnemen
een andere naamruimte om te verwerken
exponentiële operaties? Zo ja, hoe?
Ik behandel exponentiële bewerkingen met behulp van
niet-gehele getallen?
Math.Powondersteunt dubbele parameters, dus u hoeft uw eigen parameters niet te schrijven.
Antwoord 4, autoriteit 5%
Het ontbreken van een exponentiële operator voor C# was een grote ergernis voor ons bij het zoeken naar een nieuwe taal om onze rekensoftware naar te converteren van de goede oude vb6.
Ik ben blij dat we voor C# zijn gegaan, maar het irriteert me nog steeds als ik een complexe vergelijking schrijf, inclusief exponenten. De methode Math.Pow()maakt vergelijkingen behoorlijk moeilijk leesbaar IMO.
Onze oplossing was om een speciale DoubleX-klasse te maken waarin we de ^-operator overschrijven (zie hieronder)
Dit werkt redelijk goed zolang u ten minste één van de variabelen declareert als DoubleX:
DoubleX a = 2;
DoubleX b = 3;
Console.WriteLine($"a = {a}, b = {b}, a^b = {a ^ b}");
of gebruik een expliciete converter op standaard doubles:
double c = 2;
double d = 3;
Console.WriteLine($"c = {c}, d = {d}, c^d = {c ^ (DoubleX)d}"); // Need explicit converter
Een probleem met deze methode is echter dat de exponent in de verkeerde volgorde wordt berekend in vergelijking met andere operators. Dit kan worden voorkomen door altijd een extra ()rond de bewerking te plaatsen, wat het weer wat moeilijker maakt om de vergelijkingen te lezen:
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
Ik hoop dat dit anderen kan helpen die veel complexe vergelijkingen in hun code gebruiken, en misschien heeft iemand zelfs een idee hoe deze methode te verbeteren?!
DoubleXklasse:
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 --------------
}
}
Antwoord 5
Het verbaast me dat niemand dit heeft genoemd, maar voor het eenvoudige (en waarschijnlijk meest voorkomende) geval van kwadrateren, vermenigvuldig je gewoon met zichzelf.
float someNumber;
float result = someNumber * someNumber;
Antwoord 6
Omdat nog niemand een functie heeft geschreven om dit met twee gehele getallen te doen, is dit een manier:
private static long CalculatePower(int number, int powerOf)
{
long result = number;
for (int i = 2; i <= powerOf; i++)
result *= number;
return result;
}
alternatief in vb.net:
Private Function CalculatePower(ByVal number As Integer, ByVal powerOf As Integer) As Long
Dim result As Long = number
For i As Integer = 2 To powerOf
result = result * number
Next
Return result
End Function
CalculatePower(5, 3) ' 125
CalculatePower(8, 4) ' 4096
CalculatePower(6, 2) ' 36
Antwoord 7
Voor wat het waard is, mis ik de operator ^ bij het verhogen van een kracht van 2 om een binaire constante te definiëren. Kan Math.Pow () daar niet gebruiken, maar het verschuiven van een niet-ondertekende int van 1 naar links door de waardewerken van de exponent. Wanneer ik een constante van (2 ^ 24) moet definiëren -1:
public static int Phase_count = 24;
public static uint PatternDecimal_Max = ((uint)1 << Phase_count) - 1;
Onthoud dat de typen moeten zijn (uint) & lt; & lt; (INT).
Antwoord 8
Een goede stroomfunctie zou
zijn
public long Power(int number, int power) {
if (number == 0) return 0;
long t = number;
int e = power;
int result = 1;
for(i=0; i<sizeof(int); i++) {
if (e & 1 == 1) result *= t;
e >>= 1;
if (e==0) break;
t = t * t;
}
}
De Math.PowFUNCTION gebruikt de PROCESSOR POWER-functie en is efficiënter.