Since it is common to have positive or non-negative integer attributes, it's preferable to use predefined datatypes, like PositiveInteger and NonNegativeInteger, as their range in an information design model, instead of defining them with the range Integer and adding a corresponding interval constraint.

In a (JavaScript or Java) model class definition, these attributes have to be implemented as integer-valued attributes with an interval constraint. It is, however, desirable to have built-in support for them, like in the data/document format definition language XML Schema.

Certain attributes, e.g., when representing probabilities, have the unit interval [0,1], or one of its open variants, as their range. They can be implemented as decimal-valued attributes with an interval constraint. But having a corresponding predefined datatype, like UnitInterval, is preferable.

The values of certain attributes represent percentages, which are decimal numbers that have to be divided by 100 for obtaining the numeric value represented by them. In a user interface, the value of a percentage attribute is shown with a % suffix, similar to quantity attributes shown with a unit suffix. For supporting percentage attributes, a special predefined datatype like Percent is needed.

In widely used programming languages, like JavaScript and Java, the built-in standard datatypes for dealing with decimal numbers (like number in JavaScript and double in Java) do not support precise calculations. For instance, in JavaScript, the result of computing the subtraction 0.3 - 0.1 is not 0.2, but rather 0.09999999999999998, which is close to, but not the same as the correct result. Even if such a precision error may be acceptable in a use case like in physics simulation for games, it is not acceptable in a use case like financial accounting.

The concept of arbitrary-precision numbers is to allow calculations where the precision is only limited by the available computer memory, unlike the fixed-precision arithmetic implemented in a computer's arithmetic logic unit, which is normally employed by the standard arithmetic implementation of a programming language. Arbitrary-precision numbers are used in applications where precise results of calculations (even with large numbers) are required and where the calculation speed is not a critical factor.

In JavaScript, we can use a library like big.js or mathjs for arbitrary-precision calculations. For instance, using the big.js library, the precise result of the subtraction 0.3 - 0.1 is obtained in the following way:

var x = new Big( 0.3);
var result = x.minus( 0.1);
console.log( result);  // 0.2

The maximum number of decimal places and the rounding mode used to round the results of the critical operations div, sqrt and pow (with negative exponent) is determined by the value of the static properties DP and RM of the Big class, as illustrated by the following example:

Big.DP = 10  // decimal places
Big.RM = 1   // default rounding mode 

x = new Big( 2);
y = new Big( 3);
z = x.div( y)     // "0.6666666667"
z.sqrt()          // "0.8164965809"
z.pow(-3)         // "3.3749999995"

The rounding mode property values 0..3 have the following meaning:

In Java, we can use the built-in datatype class BigDecimal for arbitrary-precision calculations. For instance, the precise result of the subtraction 0.3 - 0.1 is obtained in the following way:

import java.math.BigDecimal;
BigDecimal x = new BigDecimal("0.3");
BigDecimal y = new BigDecimal("0.2");
BigDecimal result = x.subtract( y);

The maximum number of decimal places, called scale in Java, is either set implicitly by the constructor argument or explicitly with

x.setScale( 2);

A scale and rounding mode can be set for each operation by providing either a scale value and a RoundingMode enumeration literal or a MathContext object. They should be set at least for the critical operations divide and pow (with negative exponent), as illustrated by the following example:

BigDecimal x = new BigDecimal("2");
BigDecimal y = new BigDecimal("3");
BigDecimal result = x.divide( y, 10, RoundingMode.ROUND_HALF_UP);

In this example, the value of the result variable is 0.6666666667.