Dans le domaine de la programmation C#, la méthode Math.Round joue un rôle clé dans l'arrondi des valeurs numériques, en particulier lorsqu'il s'agit de types de données à double valeur et à valeur décimale. Cette méthode permet aux développeurs d'arrondir une valeur numérique donnée à la valeur entière la plus proche ou à un nombre spécifié de chiffres fractionnaires moins élevés, offrant flexibilité et précision dans les opérations mathématiques. Plusieurs types d'arrondi sont disponibles, comme l'arrondi à mi-chemin. Dans cet article, nous allons explorer les subtilités de Math.Round en C#, en examinant ses divers aspects et scénarios d'utilisation. Dans les sections suivantes de cet article, nous explorerons l'utilisation de la bibliothèque IronPDF par Iron Software pour gérer les PDF.
La méthode Math.Round en C# est un outil puissant pour arrondir les chiffres fractionnaires en utilisant une convention d'arrondi spécifiée. Elle fait partie du namespace System et propose plusieurs surcharges pour s'adapter à différentes opérations d'arrondi.
// Methods overloaded by Math.Round
Math.Round(Double)
Math.Round(Double, Int32) // Int32 specifies number of fractional digits
Math.Round(Double, Int32, MidpointRounding) // Int32 specifies number of fractional digits, MidpointRounding is the type of rounding method
Math.Round(Double, MidpointRounding) // MidpointRounding is the type of rounding method
Math.Round(Decimal)
Math.Round(Decimal, Int32) // Int32 specifies number of fractional digits
Math.Round(Decimal, Int32, MidpointRounding)
Math.Round(Decimal, MidpointRounding)' Methods overloaded by Math.Round
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Math.Round(Double) Math.Round(Double, Int32) Math.Round(Double, Int32, MidpointRounding) Math.Round(Double, MidpointRounding) Math.Round(Decimal) Math.Round(Decimal, Int32) Math.Round(Decimal, Int32, MidpointRounding) Math.Round(Decimal, MidpointRounding)Lorsqu'il s'agit de valeurs doubles, Math.Round est couramment utilisé pour arrondir un nombre à l'entier le plus proche. Par exemple:
double originalValue = 3.75;
double roundedValue = Math.Round(originalValue);
// Output: 4Dim originalValue As Double = 3.75
Dim roundedValue As Double = Math.Round(originalValue)
' Output: 4Dans cet exemple, la méthode Math.Round arrondit la valeur double originale 3,75 à la valeur entière la plus proche, qui est 4.
De même, la méthode Math.Round s'applique aux valeurs décimales. Considérez l'exemple suivant :
decimal originalValue = 8.625m;
decimal roundedValue = Math.Round(originalValue, 2);
// Output: 8.63Dim originalValue As Decimal = 8.625D
Dim roundedValue As Decimal = Math.Round(originalValue, 2)
' Output: 8.63Ici, la méthode Math.Round est utilisée pour arrondir le nombre décimal 8,625 à deux décimales, ce qui donne la valeur arrondie 8,63.
Le principal objectif de Math.Round est d'arrondir une valeur numérique donnée à l'entier le plus proche. Lorsque la partie fractionnaire est exactement à mi-chemin entre deux entiers, la méthode suit une convention d'arrondi spécifiée. L'énumération MidpointRounding peut être utilisée comme argument dans la méthode Math.Round et détermine s'il faut arrondir vers le nombre pair le plus proche ou s'éloigner de zéro.
Explorons comment le mode MidpointRounding peut être employé:
double originalValue = 5.5;
double roundedValueEven = Math.Round(originalValue, MidpointRounding.ToEven);
double roundedValueOdd = Math.Round(originalValue, MidpointRounding.AwayFromZero);
// Output: roundedValueEven = 6, roundedValueOdd = 6Dim originalValue As Double = 5.5
Dim roundedValueEven As Double = Math.Round(originalValue, MidpointRounding.ToEven)
Dim roundedValueOdd As Double = Math.Round(originalValue, MidpointRounding.AwayFromZero)
' Output: roundedValueEven = 6, roundedValueOdd = 6Dans cet exemple, lors de l'arrondi de la valeur 5,5, MidpointRounding.ToEven arrondit vers le nombre pair le plus proche (résultant en 6), et MidpointRounding.AwayFromZero s'éloigne de zéro, donnant 6.
Pour arrondir un nombre à un nombre spécifié de décimales, la méthode Math.Round permet l'inclusion d'un paramètre supplémentaire représentant le nombre de chiffres fractionnaires:
decimal originalValue = 9.123456m;
decimal roundedValue = Math.Round(originalValue, 3);
// Output: 9.123Dim originalValue As Decimal = 9.123456D
Dim roundedValue As Decimal = Math.Round(originalValue, 3)
' Output: 9.123Ici, le nombre décimal 9,123456 est arrondi à trois décimales, ce qui donne la valeur arrondie 9,123.
Une valeur à mi-parcours apparaît lorsque la valeur après le chiffre significatif le moins important dans le résultat est exactement à mi-chemin entre deux nombres. Par exemple, 2,56500 est une valeur à mi-parcours lorsqu'elle est arrondie à deux décimales à 2,57, et 3,500 est une valeur à mi-parcours lorsqu'elle est arrondie à un entier 4. Le défi réside dans l'identification de la valeur la plus proche dans la stratégie d'arrondi à la valeur la plus proche pour les valeurs à mi-parcours sans convention d'arrondi définie.
La méthode Round en C# prend en charge deux conventions d'arrondi pour gérer les valeurs à mi-parcours :
Arrondi en s'éloignant de zéro : les valeurs à mi-parcours subissent un arrondi vers le nombre suivant en s'éloignant de zéro. Cette méthode est représentée par le membre d'énumération MidpointRounding.AwayFromZero.
Arrondi vers le nombre pair le plus proche (Arrondi bancaire) : les valeurs à mi-parcours sont arrondies vers le nombre pair le plus proche. Cette approche d'arrondi est indiquée par le membre d'énumération MidpointRounding.ToEven.
decimal[] decimalSampleValues = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
decimal sum = 0;
// Calculate true mean values.
foreach (var value in decimalSampleValues)
{
sum += value;
}
Console.WriteLine("True mean values: {0:N2}", sum / decimalSampleValues.Length);
// Calculate mean values with rounding away from zero.
sum = 0;
foreach (var value in decimalSampleValues)
{
sum += Math.Round(value, 1, MidpointRounding.AwayFromZero);
}
Console.WriteLine("AwayFromZero mean: {0:N2}", sum / decimalSampleValues.Length);
// Calculate mean values with rounding to the nearest even.
sum = 0;
foreach (var value in decimalSampleValues)
{
sum += Math.Round(value, 1, MidpointRounding.ToEven);
}
Console.WriteLine("ToEven mean: {0:N2}", sum / decimalSampleValues.Length);Dim decimalSampleValues() As Decimal = { 1.15D, 1.25D, 1.35D, 1.45D, 1.55D, 1.65D }
Dim sum As Decimal = 0
' Calculate true mean values.
For Each value In decimalSampleValues
sum += value
Next value
Console.WriteLine("True mean values: {0:N2}", sum / decimalSampleValues.Length)
' Calculate mean values with rounding away from zero.
sum = 0
For Each value In decimalSampleValues
sum += Math.Round(value, 1, MidpointRounding.AwayFromZero)
Next value
Console.WriteLine("AwayFromZero mean: {0:N2}", sum / decimalSampleValues.Length)
' Calculate mean values with rounding to the nearest even.
sum = 0
For Each value In decimalSampleValues
sum += Math.Round(value, 1, MidpointRounding.ToEven)
Next value
Console.WriteLine("ToEven mean: {0:N2}", sum / decimalSampleValues.Length)
La stratégie d'arrondi S'éloigner de zéro arrondit vers le nombre le plus proche, arrondissant un nombre à mi-chemin entre deux autres en s'éloignant de zéro.
Cette stratégie est caractérisée par un arrondi dirigé vers zéro. Le résultat est le plus proche et n'est pas plus grand en magnitude que le résultat infiniment précis.
Cette stratégie implique un arrondi vers le nombre le plus proche, et lorsqu'un nombre est à mi-chemin entre deux autres, il est arrondi vers le nombre pair le plus proche.
Cette stratégie implique un arrondi vers le bas, le résultat étant le plus proche et pas plus grand que le résultat infiniment précis.
Cette stratégie implique un arrondi vers le haut, le résultat étant le plus proche et pas moins que le résultat infiniment précis.
Lorsqu'on travaille avec des nombres en virgule flottante à double précision, il est essentiel de comprendre l'imprécision potentielle en raison de la nature de la représentation en virgule flottante. La méthode Math.Round aide à atténuer les problèmes de précision en arrondissant les valeurs à l'entier le plus proche ou à un nombre spécifié de décimales.
Les développeurs peuvent tirer parti de la méthode Math.Round pour atteindre la précision souhaitée dans leurs calculs :
double originalValue = 123.456789;
double result = Math.Round(originalValue, 4);
// Output: 123.4568, rounded valueDim originalValue As Double = 123.456789
Dim result As Double = Math.Round(originalValue, 4)
' Output: 123.4568, rounded valueDans cet exemple, la valeur double 123,456789 est arrondie à quatre décimales, ce qui donne la valeur plus précise 123,4568.
La stratégie d'arrondi à mi-parcours devient cruciale lorsqu'une valeur fractionnaire est exactement à mi-chemin entre deux entiers. La méthode Math.Round utilise la stratégie MidpointRounding spécifiée pour résoudre de tels cas.
Considérons l'exemple suivant où l'arrondi à mi-parcours est utilisé :
double originalValue = 7.5;
double roundedValue = Math.Round(originalValue, MidpointRounding.AwayFromZero);
// Output: 8Dim originalValue As Double = 7.5
Dim roundedValue As Double = Math.Round(originalValue, MidpointRounding.AwayFromZero)
' Output: 8Ici, la valeur 7,5 est arrondie en s'éloignant de zéro, ce qui donne la valeur arrondie 8.
Voici quelques exemples de son application dans divers contextes :
Dans les applications financières, un arrondi précis est crucial. Par exemple, lors du calcul des taux d'intérêt, de la conversion des devises ou du traitement des calculs d'impôts, la méthode Math.Round peut être utilisée pour s'assurer que les résultats sont arrondis au nombre approprié de décimales, en respectant les normes financières.
double interestRate = 0.04567;
double roundedInterest = Math.Round(interestRate, 4); // Round to 4 decimal placesDim interestRate As Double = 0.04567
Dim roundedInterest As Double = Math.Round(interestRate, 4) ' Round to 4 decimal placesLors de la présentation de valeurs numériques dans une interface utilisateur, il est courant d'arrondir les nombres pour une meilleure lisibilité. L'arrondi en utilisant Math.Round peut améliorer la clarté des informations présentées.
double temperature = 23.678;
double roundedTemperature = Math.Round(temperature, 1); // Round to 1 decimal placeDim temperature As Double = 23.678
Dim roundedTemperature As Double = Math.Round(temperature, 1) ' Round to 1 decimal placeDans l'analyse statistique, un arrondi précis est essentiel pour éviter d'introduire des biais ou des imprécisions. La méthode Math.Round peut aider à présenter des résultats avec le niveau de précision désiré.
double meanValue = CalculateMean(data);
double roundedMean = Math.Round(meanValue, 2); // Round mean value to 2 decimal placesDim meanValue As Double = CalculateMean(data)
Dim roundedMean As Double = Math.Round(meanValue, 2) ' Round mean value to 2 decimal placesDans les applications scientifiques, la précision est cruciale. Lorsqu'il s'agit de données expérimentales ou de calculs scientifiques, l'arrondi en utilisant Math.Round garantit que les résultats sont présentés de manière significative et précise.
double experimentalResult = 9.87654321;
double roundedResult = Math.Round(experimentalResult, 5); // Round to 5 decimal placesDim experimentalResult As Double = 9.87654321
Dim roundedResult As Double = Math.Round(experimentalResult, 5) ' Round to 5 decimal placesLors de l'implémentation de modèles mathématiques ou de simulations, l'arrondi peut simplifier les calculs complexes. La méthode Math.Round peut être appliquée pour contrôler la précision des résultats intermédiaires dans le processus de modélisation.
double modelResult = SimulatePhysicalSystem(parameters);
double roundedModelResult = Math.Round(modelResult, 3); // Round to 3 decimal placesDim modelResult As Double = SimulatePhysicalSystem(parameters)
Dim roundedModelResult As Double = Math.Round(modelResult, 3) ' Round to 3 decimal placesDans le développement de jeux, la précision numérique est cruciale pour les calculs de physique, le positionnement, et d'autres opérations mathématiques. La méthode Math.Round garantit que les valeurs liées aux jeux sont arrondies à un niveau de précision approprié.
double playerPosition = CalculatePlayerPosition();
double roundedPosition = Math.Round(playerPosition, 2); // Round to 2 decimal placesDim playerPosition As Double = CalculatePlayerPosition()
Dim roundedPosition As Double = Math.Round(playerPosition, 2) ' Round to 2 decimal placesDans chacun de ces scénarios, la méthode Math.Round permet aux développeurs de contrôler la précision des valeurs numériques, favorisant l'exactitude et la lisibilité dans leurs applications.
La fonctionnalité principale de IronPDF est sa fonction HTML en PDF, qui maintient les mises en page et les styles. Il convertit le contenu Web en PDF, ce qui est excellent pour les rapports, les factures et la documentation. Vous pouvez facilement convertir des fichiers HTML, des URLs et des chaînes HTML en PDFs.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim renderer = New ChromePdfRenderer()
' Convert HTML String to PDF
Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
' Convert HTML File to PDF
Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
' Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End ClassVoyons maintenant comment nous pouvons générer des documents PDF en utilisant IronPDF bibliothèque PDF C# de Iron Software.
Vous avez la possibilité d'installer IronPDF soit via la console du gestionnaire de packages NuGet, soit via le gestionnaire de packages Visual Studio.
Installez IronPDF en utilisant le gestionnaire de packages NuGet en recherchant "IronPDF" dans la barre de recherche.
using IronPdf;
List<string> cart = new List<string>();
void AddItems(params string[] items)
{
for (int i = 0; i < items.Length; i++)
{
cart.Add(items[i]);
}
}
Console.WriteLine("Enter the cart items as comma-separated values:");
var itemsString = Console.ReadLine();
if (itemsString != null)
{
var items = itemsString.Split(",").ToArray();
AddItems(items);
}
AddItems("Sample1", "Sample2");
Console.WriteLine("-------------------------------------------------------");
Console.WriteLine("Display Cart");
string name = "Sam";
var count = cart.Count;
string content = $@"
<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" + string.Join("\n", cart.Select(x => $"<p>{x}</p>"))
+ @"
</body>
</html>";
var pdfRenderer = new ChromePdfRenderer();
pdfRenderer.RenderHtmlAsPdf(content).SaveAs("cart.pdf");Imports Microsoft.VisualBasic
Imports IronPdf
Private cart As New List(Of String)()
Private Sub AddItems(ParamArray ByVal items() As String)
For i As Integer = 0 To items.Length - 1
cart.Add(items(i))
Next i
End Sub
Console.WriteLine("Enter the cart items as comma-separated values:")
Dim itemsString = Console.ReadLine()
If itemsString IsNot Nothing Then
Dim items = itemsString.Split(",").ToArray()
AddItems(items)
End If
AddItems("Sample1", "Sample2")
Console.WriteLine("-------------------------------------------------------")
Console.WriteLine("Display Cart")
Dim name As String = "Sam"
Dim count = cart.Count
Dim content As String = $"
<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" & String.Join(vbLf, cart.Select(Function(x) $"<p>{x}</p>")) & "
</body>
</html>"
Dim pdfRenderer = New ChromePdfRenderer()
pdfRenderer.RenderHtmlAsPdf(content).SaveAs("cart.pdf")Dans le code ci-dessus, nous générons un document HTML pour les articles du panier et nous l'enregistrons ensuite comme document PDF à l'aide de IronPDF.
Pour activer la fonctionnalité du code fourni, il est nécessaire d'obtenir une clé de licence. Vous pouvez obtenir une clé d'essai à partir de cet emplacement ici, et elle doit être insérée dans le fichier appsettings.json.
"IronPdf.LicenseKey": "your license key"Fournissez votre adresse e-mail pour obtenir une licence d'essai livrée.
En conclusion, la méthode Math.Round en C# est un outil polyvalent pour arrondir les valeurs double et décimales, offrant aux développeurs la flexibilité d'arrondir à l'entier le plus proche ou à un nombre spécifié de décimales. Comprendre les subtilités de Math.Round, y compris son traitement des valeurs à mi-parcours et l'utilisation des stratégies MidpointRounding, est essentiel pour des opérations mathématiques précises et fiables dans la programmation C#. Que ce soit pour effectuer des calculs financiers, afficher des interfaces utilisateur ou d'autres scénarios nécessitant une représentation numérique précise, la méthode Math.Round s'avère être un atout indispensable dans la boîte à outils du programmeur. De plus, nous avons vu comment IronPDF est une bibliothèque polyvalente pour générer des documents PDF.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
