Table of Contents

Solidity, the language that powers smart contracts on the Ethereum blockchain, is a powerful tool for building decentralized applications. But unlike many traditional programming languages, floating point numbers in Solidity are not supported. This might seem strange at first, considering how common decimals are in the real world. So, what’s the deal?

## The Floating-Point Fumble: Why Solidity Doesn’t Like Decimals

Imagine a number line. Integers, like 1, 2, or 3, are whole numbers with neat little marks on that line. Floating-point numbers, like 3.14 (pi) or 1.23, can fall anywhere in between those marks. They use a combination of a base number (like 10) and an exponent (like the power of 10) to represent decimals efficiently.

Computers, however, understand things in terms of 0s and 1s. Representing all the possible in-between values of a floating-point number with perfect accuracy can be tricky. This is where the “fumble” comes in. There’s a trade-off between precision (how many decimal places you can store) and efficiency (how much space it takes up in memory).

Solidity, designed for secure and predictable execution on the blockchain, prioritizes determinism and avoids the potential for errors that floating-point calculations can introduce. The blockchain is a public ledger, and every transaction needs to be verifiable by everyone on the network. Inconsistent results due to floating-point approximations could wreak havoc in this environment.

**๐ฅ Check this course out: Build a One Piece Personality dApp With Solidity**

## Working with Numbers in Solidity: The Art of the Integer

So, how do Solidity developers handle situations that seem to require decimals? Here are a couple of approaches:

**Fixed-Point Math:** Imagine zooming in on that number line. Instead of representing decimals directly, Solidity uses integers and keeps track of the decimal places “behind the scenes.” For example, to represent 1.23, you could store the integer 123 and consider it as 123/100 (1.23). This approach ensures predictable calculations but requires careful scaling and tracking of decimal positions. This example calculates a simple interest payment on a loan amount. We’ll define a fixed-point variable with 18 decimal places (represented by a factor of 10^18).

```
pragma solidity ^0.8.0;
contract FixedPointExample {
// Define a fixed-point variable with 18 decimals
uint256 public constant DECIMALS = 1e18;
function calculateInterest(uint256 principal, uint256 interestRate, uint256 timeInYears) public pure returns (uint256) {
// Interest rate is assumed to be a percentage (e.g., for 5% interest, rate = 5)
uint256 interest = principal * interestRate * timeInYears / DECIMALS / 100; // Adjust for decimals and percentage
return interest;
}
}
```

**Explanation:**

- We define a constant
`DECIMALS`

to represent the number of decimal places (1e18 = 1 with 18 zeros).

- The
`calculateInterest`

function takes the principal amount, interest rate (as a percentage), and time in years.

- To handle decimals, we multiply the principal by the interest rate and time, but we also divide by
`DECIMALS`

and 100 to adjust for the fixed-point representation and percentage basis.

**Libraries for Floating-Point-like Behavior:** While Solidity itself doesn’t have built-in floating-point functionality, there are external libraries that developers can integrate. These libraries offer functions that mimic floating-point behavior using clever integer manipulations. However, it’s important to remember that these are still workarounds with their own limitations and potential for errors.

**๐ฅ Check this course out: Build Hogwarts Sorting Hat dApp on Polygon**

### Choosing the Right Tool for the Job: When Integers Rule and When Workarounds Work

Here’s a good rule of thumb: if your smart contract deals with whole numbers like token quantities or voting tallies, integers are perfectly suitable. However, if you need calculations involving precise decimals, like financial transactions or scientific computations, things get trickier.

In such cases, carefully consider the trade-offs:

**Fixed-point math:**Offers good control and predictability, but requires extra coding effort and potential for overflow errors if not handled properly.**External libraries:**Can provide a more familiar floating-point-like experience, but introduce additional complexity and potential security vulnerabilities if not chosen and implemented carefully.

## The Future of Floating-Point in Solidity: A Work in Progress

The world of blockchain technology is constantly evolving. There’s an ongoing discussion about introducing fixed-point numbers as a first-class citizen in future versions of Solidity. This would streamline the process of working with decimals while maintaining the core principles of security and determinism.

## In Conclusion: Embrace the Power of Integers, But Be Aware of the Workarounds

The lack of support for floating point numbers in Solidity might seem like a hurdle at first. However, it’s a deliberate design choice that prioritizes security and predictability for decentralized applications. With a solid understanding of integer arithmetic and the available workarounds, you can write robust smart contracts that handle even complex calculations involving decimals. As the blockchain ecosystem matures, we might see more native support for fixed-point numbers in the future, but for now, integers reign supreme in the world of Solidity.

**Try it out, ask us questions, and tell us how it went by tagging Metaschool on Social Media.**

**Follow us on** โ

๐ฎTwitter โ https://twitter.com/0xmetaschool

๐LinkedIn โ https://www.linkedin.com/company/0xmetaschool/