C# Version HisotryC# Language FeaturesInstalling Visual StudioC# Basic Project StructureHello Wolrd, first C# program
Variables in C# Explicitly typed variables in C#Implicitly typed variables in C#Constants in C#Data types in C#Integral data types in C#Floating-point data types in C#Comparison between Float, Double and DecimalChar data type in C#String data type in C#Boolean data type in C#DateTime data type in C#Enumeration data type in C#Array data type in C#Object data type in C#Dynamic data type in C#Anonymous data type in C#Nullable data type in C#Type casting in C#Type safety in C#Literals in C#Operators in C#Ternary Operator in C#Null coalescing Operator in C#Tilde(~) Operator in C#Keywords in C#Namespace in C#Nullable Types in C#Nullable Helper Class in C#Characteristics of Nullable typesC# Difference between "int" and "int?"
Block statement in C#Empty statement in C#Jump statements in C#Break statement in C#Continue statement in C#Difference between continue and breakGoto statement in C#Return statement in C#Throw statement in C#Yield keyword in C#Checked statement in C#Unchecked statement in C#Lock statement in C#Using statement in C#Enum/Enumeration in C#If-Else statement in C#Switch statement in C#What is a loop in C#?For loop in C#While loop in C#Do while loop in C#Foreach loop in C#Nested loop in C#Infinite loop in C#
C# Method or FunctionC# Method Parameters and ArgumentsC# Method OverloadingC# Return StatementsC# Static vs. Instance MethodsC# Method ModifiersC# Method Signatures and Naming ConventionsC# Function Documentation and CommentsC# Value Type ParametersC# Ref Type ParametersDifference between Value and Ref TypeC# Out ParametersDifference between Ref and out parametersC# Optional parametersAre Nullable types reference types in C#"
Exception Handling in C#Types of exception in C#Try catch finally in C#finally block in C#try block without catch blockMultiple catch blocks in exceptionCatch multiple exceptions in C#Base class of exception in C#finally block execution in C#finally block execution in case of errorFinally and return statementWays to use try-catch-finallyException throw from finally block"throw" and "throw ex" in C#Differene between finalize() and finallyInner exception in C#Error types in C#Catch multi exception by single catch blockUser defined/custom excetion in C#Compile and run time exception in C#Difference between "error" and "exception"System and application exception in C#Exception handling abuse in c#?
C# String BasicsC# String ManipulationC# String FormattingC# String Comparison and SearchingC# StringBuilder ClassC# Regular ExpressionsC# Unicode and EncodingC# String Parsing and ConversionDifference between "string" and "String"C# String Escape SequenceC# Mutable and Immutable ConceptProve that string is immutableString value stored in memoryDifference between string and stringbuilderOverride the tostring() method
Enum/enumeration in C#Can you inherit enum in C#?Convert enum to stringConvert enum to list in C#Cast int value to enum in C#Get int value from enum in C#Convert string to enum in C#Usage of enum in switch case statementLoop through all enum valuesUse tilde(~) with Enum
Main() method basics in C#More than one "Main()" method in C#Static Main() method in C#Overload Main() method in C#Override Main() method in C#Access modifiers of Main() method in C#Non-static method in C#Main() method arguments and return typeasync Main() method in C#Class without Main() method in C#Main() method rules in C#
Recursion in C#Base condition in recursion in C#Recursive Algorithms in C#Tree traversal using recursion in C#Stack overflow error in recursionBack tracking using recursionIndirect recursion in C#Recursive data structures in C#Tail Recursion in C#Recursive problem solvingRecursion vs Iteration
C# File and File InfoC# StreamReader and StreamWriterC# FileStream and BinaryReader/BinaryWriterC# Directory and DirectoryInfo ClassesC# File PathsC# File and Directory OperationsC# File Exceptions and Error HandlingC# File Serialization and DeserializationC# File System Watcher
What is array?Single dimension arrayMulti dimension arrayJagged arrayParam arrayArray with multi data typesDifferent data types from object arrayArray with non-default valuesArray methods and propertiesArray manipulation techniquesArray sorting algorithmsArray Searching algorithms(linear, binary search)Array finding maximum and minimumArray of Reference Types
C# GenericsC# Generic Constraints
C# ArrayListC# Array vs ArrayListC# ListC# SortedListC# DictionaryC# HashtableC# Dictionary vs HashtableC# HashSetC# Hashtable vs HashSetC# StackC# Queue
C# IEnumerableC# IEnumeratorC# ICollectionC# IListC# IDictionaryC# IDisposableC# IComparableC# IEquatableC# ICloneableC# IQueryableC# INotifyPropertyChangedC# INotifyCollectionChangedC# IFormattableC# IAsyncResultC# IComparerC# IEqualityComparerC# IHttpHandlerC# IHttpModule
C# DelegatesC# Single-Cast DelegateC# Multi-Cast DelegateC# Generic DelegatesC# Func DelegateC# Action DelegateC# Predicate DelegateC# Anonymous MethodsC# EventsDifference Between Event & DelegateDifference Between Interface & DelegateC# Covariance and Contravariance
Previous
Next

C# - Floating-point data types

In C#, floating-point data types are used to represent real numbers with decimal points. These data types are essential for handling numbers that can have fractional parts or a very large or small magnitude.

In C#, float, double and decimal are the three commonly used floating-point data types. Floating-point types are utilized to show numbers that have decimal parts.

1. float

In C#, the float data type is used to store numbers with decimal points. It's like a container that can hold values like 3.14 or 0.5. Think of it as a way to work with numbers that aren't whole, such as measurements, percentages, or any number with a fraction part. The "float" type is good for saving memory, but it may not be as precise as "double" for very accurate calculations.

It is used to store numbers with a fractional part and offers approximately 7 decimal digits of precision. The float data type is denoted by the keyword float in C#.

Here's an example that demonstrates the usage of the float data type: 


using System;

class Program
{
    static void Main()
    {
        float myFloat = 3.14f;
        float anotherFloat = 2.5f;

        float sum = myFloat + anotherFloat;
        float product = myFloat * anotherFloat;

        Console.WriteLine("Sum: " + sum);
        Console.WriteLine("Product: " + product);
    }
}

When you run this C# program, it will calculate the sum and product of the two single-precision floating-point numbers (floats) and display the results:


Sum: 5.64
Product: 7.85

In the above example, we declare two variables myFloat and anotherFloat of type float and assign them floating-point values. We then perform basic arithmetic operations on these variables, calculating the sum and product, and store the results in sum and product variables, respectively.

It is important to note that when using the float data type, you need to explicitly append the suffix f to a literal value to indicate that it is a float value. Without the f suffix, the literal value is considered a double by default, which is a higher precision floating-point type.

The float data type is suitable for situations where precision up to approximately 7 decimal digits is sufficient, such as scientific calculations, graphics rendering, or storage optimization when memory usage is a concern.

2. double

The double data type in C# represents a double-precision floating-point number. It is used to store numbers with a fractional part and offers approximately 15 decimal digits of precision. The double data type is denoted by the keyword double in C#.

Here's an example that demonstrates the usage of the double data type: 


using System;

class Program
{
    static void Main()
    {
        double myDouble = 3.14159;
        double anotherDouble = 2.5;

        double sum = myDouble + anotherDouble;
        double product = myDouble * anotherDouble;

        Console.WriteLine("Sum: " + sum);
        Console.WriteLine("Product: " + product);
    }
}

When you run this C# program, it will calculate the sum and product of the two double-precision floating-point numbers and display the results:


Sum: 5.64159
Product: 7.853975

In the above example, we declare two variables myDouble and anotherDouble of type double and assign them floating-point values. We then perform basic arithmetic operations on these variables, calculating the sum and product, and store the results in sum and product variables, respectively.

The double data type provides higher precision compared to the float data type, making it suitable for applications where increased accuracy is required. It is the default floating-point data type in C#, and it is commonly used in various scenarios such as scientific calculations, financial calculations, and general-purpose arithmetic.

It's worth noting that if you need even higher precision and exact decimal representation, you can use the decimal data type instead, which is suitable for financial and monetary calculations.

3. decimal

The decimal data type in C# represents a decimal floating-point number. It is used to store numbers with a fractional part and provides high precision with approximately 28-29 significant digits. The decimal data type is denoted by the keyword decimal in C#.

Here's an example that demonstrates the usage of the decimal data type: 


using System;

class Program
{
    static void Main()
    {
        decimal myDecimal = 3.1415926535897932384626433833m;
        decimal anotherDecimal = 2.5m;

        decimal sum = myDecimal + anotherDecimal;
        decimal product = myDecimal * anotherDecimal;

        Console.WriteLine("Sum: " + sum);
        Console.WriteLine("Product: " + product);
    }
}

Output of the above program would be:


Sum: 5.6415926535897932384626433833
Product: 7.8539816339744830966063297083

In the above example, we declare two variables myDecimal and anotherDecimal of type decimal and assign them decimal values. We then perform basic arithmetic operations on these variables, calculating the sum and product, and store the results in sum and product variables, respectively.

The decimal data type is suitable for applications that require precise decimal representation, such as financial calculations, monetary values, or any scenario where exact decimal values are essential. It is designed to minimize rounding errors that can occur with floating-point types (float and double).

When using the decimal data type, it's important to note that you need to explicitly append the suffix m to a literal value to indicate that it is a decimal value. This ensures that the value is treated as a decimal and not as a double or another type. 


decimal price = 9.99m;
decimal quantity = 5;
decimal total = price * quantity;

In the example above, price is explicitly assigned a decimal value with the m suffix, and total is calculated using the decimal arithmetic operations.

Points to Remember:
  • Precision vs. Range: Floating-point data types like float and double offer a trade-off between precision and range. double provides higher precision but occupies more memory, while float offers less precision but consumes less memory.
  • Suffix 'f' or 'F': When initializing a float literal, always use the 'f' or 'F' suffix (e.g., 3.14f) to explicitly indicate that it's a float value. Otherwise, it will be treated as a double by default.
  • Rounding Errors: Due to limited precision, floating-point calculations may result in rounding errors, especially in operations involving very large or very small numbers or when performing many successive calculations.
  • Comparing Floating-Point Numbers: Avoid using the equality operator (==) to compare floating-point numbers directly because of potential precision issues. Instead, use tolerance or epsilon comparisons to check if two numbers are approximately equal.
  • Format Specifiers: When formatting floating-point numbers for output, consider using format specifiers (e.g., "F2") to control the number of decimal places displayed and ensure consistent formatting.
  • Overflow and Underflow: Floating-point types have limits, and calculations can lead to overflow (values exceeding the maximum representable value) or underflow (values below the minimum representable value). Be aware of these limitations in your calculations.
  • Avoid Currency Calculations: Do not use floating-point types for financial calculations, as they can introduce rounding errors. Instead, use the decimal data type, which provides exact decimal arithmetic.
  • NaN and Infinity: Floating-point types can represent special values like NaN (Not-a-Number) and positive/negative infinity. Be aware of these values and handle them appropriately in your code.
  • Type Conversion: When working with floating-point values and other numeric types, be mindful of type conversions, as implicit or explicit conversions can lead to data loss or unexpected results.
  • Choose the Right Type: Select the appropriate floating-point data type (float or double) based on your application's requirements for precision and range. In most cases, double is a good default choice.
  • Testing and Debugging: When dealing with floating-point calculations, thoroughly test your code with a variety of input values to ensure it behaves as expected and watch out for edge cases.
  • Documentation: Document your code, especially when using floating-point values in critical calculations. Explain the assumptions and potential precision issues to make it easier for others to understand and maintain the code.
Previous
Next