# Multiplying fixed-point types in Solidity

I would like to define a function like this:

``````function convert(ufixed x) external pure returns (uint256 result) {
result = x * 1e18;
}
``````

Unfortunately, the code above does not compile:

TypeError: type ufixed128x18 is not implicitly convertible to expected type uint256.

I went ahead and casted `x` to `uint256`:

``````result = uint256(x) * 1e18;
``````

But this didn't work either:

UnimplementedFeatureError: Fixed point types not implemented.

I have read the docs, and I understand that fixed-point types cannot be assigned to or from. However, all I want is to multiply them by a pre-factor.

Is this still not possible to do in Solidity just yet?

At the moment we cannot do practically anything with the `ufixed` type.

You could implement your own `UFixed` type or use a library that handles "fix point" number arithmetics.

Take a look at the following `UFixed` custom type and `FixedMath` library to abstract the details of the arithmetics operations for this type:

``````// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;

type UserId is uint256;
type UFixed is uint256;

/// A minimal library to do fixed point operations on UFixed.
library FixedMath {
uint constant multiplier = 10**18;

/// Adds two UFixed numbers. Reverts on overflow,
/// relying on checked arithmetic on uint256.
function add(UFixed a, UFixed b) internal pure returns (UFixed) {
return UFixed.wrap(UFixed.unwrap(a) + UFixed.unwrap(b));
}
/// Multiplies UFixed and uint256. Reverts on overflow,
/// relying on checked arithmetic on uint256.
function mul(UFixed a, uint256 b) internal pure returns (UFixed) {
return UFixed.wrap(UFixed.unwrap(a) * b);
}
/// Take the floor of a UFixed number.
/// @return the largest integer that does not exceed `a`.
function floor(UFixed a) internal pure returns (uint256) {
return UFixed.unwrap(a) / multiplier;
}
/// Turns a uint256 into a UFixed of the same value.
/// Reverts if the integer is too large.
function toUFixed(uint256 a) internal pure returns (UFixed) {
return UFixed.wrap(a * multiplier);
}
}

contract Contract {
using FixedMath for UFixed;

mapping(UserId => User) public users;

struct User {
UserId id;
string name;
}

function getUser(UserId userId) public view returns(User memory) {
return users[userId];
}

function add(UFixed a, UFixed b) public pure returns(UFixed) {