Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T15:11:35Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the <ref name = Currency />[http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values <ref name = jsql/>.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

One of the special cases of Java Money class implementation is found in Java Object-Relational Database Systems [http://www.firstsql.com/javaobjects.shtml]. Objects that are defined in Java are stored in FirstSQL/J as values in database columns. These are normal columns whose type is a Java class that is mapped to the appropriate database type internally.

<pre>
Money Class

Constructors:
Money(BigDecimal amt, String currency);
Money(double amt, String currency); Note: currency is a string name of a currency – ‘USD’, ‘Euro’, …
Methods: String getCurrency(); // get currency type string
String toString(); // get amount with standard formatting
BigDecimal decValue(); // get numeric amount
double doubleValue(); // get numeric amount
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.
* The FirstSQL/J inbuilt querying capabilities provide significant elegant methods to get information about Money classes.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===
Representations similar to the ones in Java are also seen in C++. While the fundamentals are the same, there are a few subtle differences as well. There are certain functions like "floor" that can be used in C++ for aiding in the right precision with decimal values for money quantities. The underlying data type for such cases is double.
Eg. floor(double*21.32).
With this neat trick, decimals are not lost because the double type, with its precision being greater than or equal to 15 digits, is used as a compiler supported long long. The only thing to be careful of is multiplying and dividing such values.

The one cool feature is that the Zortech distribution has an in-built C++ Money Class in it.

<pre>
class money {
long dollars;
int cents;
// ...
};
</pre>

=== Advantages ===
* The Zortech C++ money class is an efficient implementation. This is due to the fact that the operators use integer arithmetic.
* Not much overhead with maintaining the money class objects.
* Some nice routines such as "flatten" are made available using the money class. An example of this implementation from [http://www.di-mare.com/adolfo/p/money.htm] is shown here.

<pre>
// Returns a money data item where the cents are
// rounded modulo "cents". In this way cents can
// be stripped of money items when the currency
// does not have all the coins required to pay
// every posible quantity.
money flatten(const money& m, double cents, int rounding) {
money temp;
double c = floor(fabs(cents*money::SCALE())); // cents
double r = fmod(m.m_money, c); // remainder
temp.m_money =
(!rounding || (2.0* r <= c)
? m.m_money - r
: m.m_money - r + c
);
return temp;
}

</pre>

=== Disadvantages ===
* The long datatype in the Zortech implementation cannot hold more than 10 decimal digits.
* This money class implements most arithmethic operators, but it does not implement the multiply and divide operations. The user is left to implement these.

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
<ref name = Currency> http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html </ref>
<ref name = jsql> http://www.firstsql.com/javaobjects.shtml </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T15:00:43Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the <ref name = Currency />[http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values <ref name = jsql/>.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

One of the special cases of Java Money class implementation is found in Java Object-Relational Database Systems [http://www.firstsql.com/javaobjects.shtml]. Objects that are defined in Java are stored in FirstSQL/J as values in database columns. These are normal columns whose type is a Java class that is mapped to the appropriate database type internally.

<pre>
Money Class

Constructors:
Money(BigDecimal amt, String currency);
Money(double amt, String currency); Note: currency is a string name of a currency – ‘USD’, ‘Euro’, …
Methods: String getCurrency(); // get currency type string
String toString(); // get amount with standard formatting
BigDecimal decValue(); // get numeric amount
double doubleValue(); // get numeric amount
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.
* The FirstSQL/J inbuilt querying capabilities provide significant elegant methods to get information about Money classes.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===
Representations similar to the ones in Java are also seen in C++. While the fundamentals are the same, there are a few subtle differences as well. There are certain functions like "floor" that can be used in C++ for aiding in the right precision with decimal values for money quantities. The underlying data type for such cases is double.
Eg. floor(double*21.32).
With this neat trick, decimals are not lost because the double type, with its precision being greater than or equal to 15 digits, is used as a compiler supported long long. The only thing to be careful of is multiplying and dividing such values.

The one cool feature is that the Zortech distribution has an in-built C++ Money Class in it.

<pre>
class money {
long dollars;
int cents;
// ...
};
</pre>

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
<ref name = Currency> http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html </ref>
<ref name = jsql> http://www.firstsql.com/javaobjects.shtml </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T14:59:46Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the <ref name = Currency />[http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values <ref name = jsql/>.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

One of the special cases of Java Money class implementation is found in Java Object-Relational Database Systems [http://www.firstsql.com/javaobjects.shtml]. Objects that are defined in Java are stored in FirstSQL/J as values in database columns. These are normal columns whose type is a Java class that is mapped to the appropriate database type internally.

<pre>
Money Class

Constructors:
Money(BigDecimal amt, String currency);
Money(double amt, String currency); Note: currency is a string name of a currency – ‘USD’, ‘Euro’, …
Methods: String getCurrency(); // get currency type string
String toString(); // get amount with standard formatting
BigDecimal decValue(); // get numeric amount
double doubleValue(); // get numeric amount
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.
* The FirstSQL/J inbuilt querying capabilities provide significant elegant methods to get information about Money classes.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===
Representations similar to the ones in Java are also seen in C++. While the fundamentals are the same, there are a few subtle differences as well. There are certain functions like "floor" that can be used in C++ for aiding in the right precision with decimal values for money quantities. The underlying data type for such cases is double.
Eg. floor(double*21.32).
With this neat trick, decimals are not lost because the double type, with its precision being greater than or equal to 15 digits, is used as a compiler supported long long. The only thing to be careful of is multiplying and dividing such values.

The one cool feature is that the Zortech distribution has an in-built C++ Money Class in it.

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
<ref name = Currency> http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html </ref>
<ref name = jsql> http://www.firstsql.com/javaobjects.shtml </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T14:59:02Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the <ref name = Currency />[http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values <ref name = jsql>.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

One of the special cases of Java Money class implementation is found in Java Object-Relational Database Systems [http://www.firstsql.com/javaobjects.shtml]. Objects that are defined in Java are stored in FirstSQL/J as values in database columns. These are normal columns whose type is a Java class that is mapped to the appropriate database type internally.

<pre>
Money Class

Constructors:
Money(BigDecimal amt, String currency);
Money(double amt, String currency); Note: currency is a string name of a currency – ‘USD’, ‘Euro’, …
Methods: String getCurrency(); // get currency type string
String toString(); // get amount with standard formatting
BigDecimal decValue(); // get numeric amount
double doubleValue(); // get numeric amount
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.
* The FirstSQL/J inbuilt querying capabilities provide significant elegant methods to get information about Money classes.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===
Representations similar to the ones in Java are also seen in C++. While the fundamentals are the same, there are a few subtle differences as well. There are certain functions like "floor" that can be used in C++ for aiding in the right precision with decimal values for money quantities. The underlying data type for such cases is double.
Eg. floor(double*21.32).
With this neat trick, decimals are not lost because the double type, with its precision being greater than or equal to 15 digits, is used as a compiler supported long long. The only thing to be careful of is multiplying and dividing such values.

The one cool feature is that the Zortech distribution has an in-built C++ Money Class in it.

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
<ref name = Currency> http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html </ref>
<ref name = jsql> http://www.firstsql.com/javaobjects.shtml </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T14:58:42Z

Rpgodbol: /* References */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the <ref name = Currency />[http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values <ref name = jsql/>.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

One of the special cases of Java Money class implementation is found in Java Object-Relational Database Systems [http://www.firstsql.com/javaobjects.shtml]. Objects that are defined in Java are stored in FirstSQL/J as values in database columns. These are normal columns whose type is a Java class that is mapped to the appropriate database type internally.

<pre>
Money Class

Constructors:
Money(BigDecimal amt, String currency);
Money(double amt, String currency); Note: currency is a string name of a currency – ‘USD’, ‘Euro’, …
Methods: String getCurrency(); // get currency type string
String toString(); // get amount with standard formatting
BigDecimal decValue(); // get numeric amount
double doubleValue(); // get numeric amount
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.
* The FirstSQL/J inbuilt querying capabilities provide significant elegant methods to get information about Money classes.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===
Representations similar to the ones in Java are also seen in C++. While the fundamentals are the same, there are a few subtle differences as well. There are certain functions like "floor" that can be used in C++ for aiding in the right precision with decimal values for money quantities. The underlying data type for such cases is double.
Eg. floor(double*21.32).
With this neat trick, decimals are not lost because the double type, with its precision being greater than or equal to 15 digits, is used as a compiler supported long long. The only thing to be careful of is multiplying and dividing such values.

The one cool feature is that the Zortech distribution has an in-built C++ Money Class in it.

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
<ref name = Currency> http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html </ref>
<ref name = jsql> http://www.firstsql.com/javaobjects.shtml </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T14:58:06Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the <ref name = Currency />[http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values <ref name = jsql/>.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

One of the special cases of Java Money class implementation is found in Java Object-Relational Database Systems [http://www.firstsql.com/javaobjects.shtml]. Objects that are defined in Java are stored in FirstSQL/J as values in database columns. These are normal columns whose type is a Java class that is mapped to the appropriate database type internally.

<pre>
Money Class

Constructors:
Money(BigDecimal amt, String currency);
Money(double amt, String currency); Note: currency is a string name of a currency – ‘USD’, ‘Euro’, …
Methods: String getCurrency(); // get currency type string
String toString(); // get amount with standard formatting
BigDecimal decValue(); // get numeric amount
double doubleValue(); // get numeric amount
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.
* The FirstSQL/J inbuilt querying capabilities provide significant elegant methods to get information about Money classes.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===
Representations similar to the ones in Java are also seen in C++. While the fundamentals are the same, there are a few subtle differences as well. There are certain functions like "floor" that can be used in C++ for aiding in the right precision with decimal values for money quantities. The underlying data type for such cases is double.
Eg. floor(double*21.32).
With this neat trick, decimals are not lost because the double type, with its precision being greater than or equal to 15 digits, is used as a compiler supported long long. The only thing to be careful of is multiplying and dividing such values.

The one cool feature is that the Zortech distribution has an in-built C++ Money Class in it.

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
<ref name = Currency> http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T14:56:33Z

Rpgodbol: /* Advantages */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the <ref name = Currency />[http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

One of the special cases of Java Money class implementation is found in Java Object-Relational Database Systems [http://www.firstsql.com/javaobjects.shtml]. Objects that are defined in Java are stored in FirstSQL/J as values in database columns. These are normal columns whose type is a Java class that is mapped to the appropriate database type internally.

<pre>
Money Class

Constructors:
Money(BigDecimal amt, String currency);
Money(double amt, String currency); Note: currency is a string name of a currency – ‘USD’, ‘Euro’, …
Methods: String getCurrency(); // get currency type string
String toString(); // get amount with standard formatting
BigDecimal decValue(); // get numeric amount
double doubleValue(); // get numeric amount
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.
* The FirstSQL/J inbuilt querying capabilities provide significant elegant methods to get information about Money classes.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===
Representations similar to the ones in Java are also seen in C++. While the fundamentals are the same, there are a few subtle differences as well. There are certain functions like "floor" that can be used in C++ for aiding in the right precision with decimal values for money quantities. The underlying data type for such cases is double.
Eg. floor(double*21.32).
With this neat trick, decimals are not lost because the double type, with its precision being greater than or equal to 15 digits, is used as a compiler supported long long. The only thing to be careful of is multiplying and dividing such values.

The one cool feature is that the Zortech distribution has an in-built C++ Money Class in it.

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
<ref name = Currency> http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T14:54:57Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the <ref name = Currency />[http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

One of the special cases of Java Money class implementation is found in Java Object-Relational Database Systems [http://www.firstsql.com/javaobjects.shtml]. Objects that are defined in Java are stored in FirstSQL/J as values in database columns. These are normal columns whose type is a Java class that is mapped to the appropriate database type internally.

<pre>
Money Class

Constructors:
Money(BigDecimal amt, String currency);
Money(double amt, String currency); Note: currency is a string name of a currency – ‘USD’, ‘Euro’, …
Methods: String getCurrency(); // get currency type string
String toString(); // get amount with standard formatting
BigDecimal decValue(); // get numeric amount
double doubleValue(); // get numeric amount
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===
Representations similar to the ones in Java are also seen in C++. While the fundamentals are the same, there are a few subtle differences as well. There are certain functions like "floor" that can be used in C++ for aiding in the right precision with decimal values for money quantities. The underlying data type for such cases is double.
Eg. floor(double*21.32).
With this neat trick, decimals are not lost because the double type, with its precision being greater than or equal to 15 digits, is used as a compiler supported long long. The only thing to be careful of is multiplying and dividing such values.

The one cool feature is that the Zortech distribution has an in-built C++ Money Class in it.

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
<ref name = Currency> http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T08:38:08Z

Rpgodbol: /* C++ */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the <ref name = Currency />[http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===
Representations similar to the ones in Java are also seen in C++. While the fundamentals are the same, there are a few subtle differences as well. There are certain functions like "floor" that can be used in C++ for aiding in the right precision with decimal values for money quantities. The underlying data type for such cases is double.
Eg. floor(double*21.32).
With this neat trick, decimals are not lost because the double type, with its precision being greater than or equal to 15 digits, is used as a compiler supported long long. The only thing to be careful of is multiplying and dividing such values.

The one cool feature is that the Zortech distribution has an in-built C++ Money Class in it.

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
<ref name = Currency> http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T07:44:09Z

Rpgodbol: /* References */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the <ref name = Currency />[http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
<ref name = Currency> http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T07:43:32Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the <ref name = Currency />[http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T07:42:13Z

Rpgodbol: /* References */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the [http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T07:41:50Z

Rpgodbol: /* References */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the [http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
<ref name = Currency> http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T07:39:54Z

Rpgodbol: /* Disadvantages */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the [http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
* Significant amount of logic is required for custom implementation of Mixed Money - different currencies being available. Certain inefficiencies of code can creep in if the user is not careful with some of the implementation details.

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T07:37:51Z

Rpgodbol: /* Advantages */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the [http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.
* The use of Currency class in custom Money implementations allows users to represent money in any currency. Conversions from one currency to another can be easily done with the use of a Currency object.
* An object oriented approach to Money allows encapsulation of methods such as adding, subtracting, negating money in one common implementation.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T06:43:53Z

Rpgodbol: /* Disadvantages */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the [http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T06:41:26Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the [http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* float
* double
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
*

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T06:40:37Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the [http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types:
* int
* long
* BigDecimal
* Money Class (custom wrapper around BigDecimal)
Out of these, BigDecimal is the fundamental building block and custom Money Class implementations simply provide a higher level of abstraction around the BigDecimal type. This makes it a more practical form of use.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
*

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T06:26:44Z

Rpgodbol: /* Advantages */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the [http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types: int, long or BigDecimal. Out of these, BigDecimal is the recommended method.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

=== Advantages ===
* The int and long primitive types are very simple to use while representing cents/pennies.
* The BigDecimal representation has built-in rounding modes.
* BigDecimal objects are immutable i.e. operations always return new objects, and do not modify the state of existing objects.

=== Disadvantages ===
* Depending on the number of digits (<=9, <=18, >18), the corresponding types int, long, BigDecimal respectively are recommended for representation. This requires the user to be aware of what values the representation needs to take up.
* Primitive types double and float carry small rounding differences.
*

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T06:02:05Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the [http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types: int, long or BigDecimal. Out of these, BigDecimal is the recommended method.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

=== Advantages ===

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T05:59:34Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the [http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types: int, long or BigDecimal.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

=== Advantages ===

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T05:51:20Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the [http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types: int, long or BigDecimal.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

<pre>
import java.math.BigDecimal;
import java.util.Currency;

public class MoneyCalculation {

private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}
</pre>

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T05:49:34Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the [http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types: int, long or BigDecimal.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

import java.math.BigDecimal;
import java.util.Currency;
public class MoneyCalculation {
private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;
private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}
private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}
}

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T05:49:13Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

7a. Representing money. Skrien Chapter 6 gives an example of a class that can be used to represent money. But how is it done in real programs? Investigate, and report on the advantages and disadvantages of other approaches vs. Skrien's.

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

== Money Gem<ref name = moneygemwebsite /> (Ruby) ==
=== Overview ===
The Ruby Money gem borrows quite a bit from the Skrien<ref name = skrien /> text methodologies while using the dynamic properties of Ruby to allow for more flexibility. However, it should be noted that this implementation does not support an object containing mixed currencies as mentioned in the Skrien text and some behavior implemented goes against it's principles.

The Money gem consists of a main '''Money''' class which houses several sub-classes and modules which allow for everything to be done from the main Money class directly without the users knowledge. This implementation also mostly sticks to the idea that a Money object is immutable and thus any conversions and operations result in a new Money object. The only exception to this is that the currency identifier for a Money object can be changed once it has been created.

Internally, a Money object stores money as an integer in the form of '''cents'''. It should be noted that while the variable is called cents, it can apply to all currencies which have a subunit of denomination. Similar to the way the Skrien text uses the Currency and CurrencyConverter classes, the Money class uses internal classes for currency information and currency conversion as well, called '''Currency''' and '''Bank''' respectively. The '''Money''' object stores a '''bank''' and '''currency''' as well as default bank and currency types at the class level.

The '''Currency''' class contains information such as the ISO4217<ref name = iso4217 /> three letter and number codes for common currencies as well as number of subunits in a denomination (ie, cents in a dollar) and delimiters for units. Through the use of the currency class, Money objects can be initialized with a Currency value and have specific output formats based on currency. The currency class also internally extends the '''CurrencyLoader''' class which allows for specifying different locations for loading currency information to allow for flexible currency management. Below is an example of the USD currency information loaded by a default JSON configuration file:
<pre>
"usd": {
"priority": 1,
"iso_code": "USD",
"name": "United States Dollar",
"symbol": "$",
"subunit": "Cent",
"subunit_to_unit": 100,
"symbol_first": true,
"html_entity": "$",
"decimal_mark": ".",
"thousands_separator": ",",
"iso_numeric": "840"
},
</pre>

The Bank class is also an internal class to the Money class but it resides at the class level. This means that the Bank object follows the Singleton pattern in that only one Bank object exists across all of the currency. The purpose of the Bank is to maintain information related to currency values such that currency conversion can take place. Since the Bank class inherits from an interface, this allows for extensible money conversion schemes such as being able to 'scrape' data from the internet and use it to populate conversion ratios.

The Money class also has multiple modules internally that expand the operations that can be performed on Money objects, including converting to and from numbers, strings and symbols. Through the use of Ruby's dynamic nature, '''to_money()''' methods are added to the Numeric, String and Symbol types.

Below is an example from the official website <ref name = moneygemwebsite />:
<pre>
require 'money'

# 10.00 USD
money = Money.new(1000, "USD")
money.cents #=> 1000
money.currency #=> Currency.new("USD")

# Comparisons
Money.new(1000, "USD") == Money.new(1000, "USD") #=> true
Money.new(1000, "USD") == Money.new(100, "USD") #=> false
Money.new(1000, "USD") == Money.new(1000, "EUR") #=> false
Money.new(1000, "USD") != Money.new(1000, "EUR") #=> true

# Arithmetic
Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
Money.new(1000, "USD") / 5 == Money.new(200, "USD")
Money.new(1000, "USD") * 5 == Money.new(5000, "USD")

# Currency conversions
some_code_to_setup_exchange_rates
Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
</pre>

=== Advantages ===
* The internal '''CurrencyLoader''' class allows for easily extensible currency information sources, even allowing currency information to be dynamically loaded
* Due to the '''Bank''' implementation, additional class implementations can be loaded and changed out at runtime to allow for more complex, an potentially real-time, currency conversion information
* The fact that the '''Currency''' and '''Bank''' classes are internal to the '''Money''' class, the user doesn't have to know about their implementation
* Ruby's dynamic nature allows for classes to be internal to '''Money''', yet defined in separate files from the '''Money''' class, helping to keep the code modular from a developers point of view
* The addition of '''to_money()''' methods to basic Ruby primitives makes it easier to create money from just about any type
* Since Ruby supports arbitrarily large integer values, there is theoretically no upper bound to the amount of money that can be stored in a '''Money''' object

=== Disadvantages ===
* Doesn't support multiple currency types in a single object
* A '''Money''' object is immutable except in one way, ability to change currency type, which is an inconsistency that could easily have been avoided
* While the addition of '''to_money()''' methods to primitive types makes some things easier, it adds the additional ability to incorrectly combine an object of type Money with one that is not
* Since the '''Bank''' object is a singleton contained within the '''Money''' class, any modifications to currency exchange rates require locking of the '''Bank''' object which could result in performance degradation if exchange rates are modified often

== python-money<ref name = pymoneywebsite /> (Python) ==
=== Overview ===
The python-money implementation of storing money in an object is a relatively simple library written in Python. As such, it does not have as much functionality nor the complexities that many other implementations have.

The python-money module consists of two classes, '''Money''' and '''Currency'''. Much like other implementations, the '''Money''' object contains an amount and currency internally. The amount is specified as type Decimal<ref name = pydecimal />, which allows storing the amount in a format similar to a float but without all of the precision issues that arise with using floats. When a '''Money''' object is created, either an identifier or '''Currency''' object is passed. Below is an example of the '''Currency''' data used for USD:
<pre>
CURRENCY['USD'] = Currency(code='USD', numeric='840', name='US Dollar',
countries=['AMERICAN SAMOA', 'BRITISH INDIAN OCEAN TERRITORY', 'ECUADOR', 'GUAM',
'MARSHALL ISLANDS', 'MICRONESIA', 'NORTHERN MARIANA ISLANDS', 'PALAU',
'PUERTO RICO', 'TIMOR-LESTE', 'TURKS AND CAICOS ISLANDS',
'UNITED STATES MINOR OUTLYING ISLANDS', 'VIRGIN ISLANDS (BRITISH)',
'VIRGIN ISLANDS (U.S.)'])
</pre>

Within the namespace containing these classes, a default list of currency objects are created, indexed by their ISO4217<ref name = iso4217 /> standard three character and number identifiers. This is what allows specifying currency by identifier rather than currency object. Unfortunately this limits the currency types to those statically defined in the source code. Additionally, since there is not a separate class to handle conversions, the exchange rate information is contained within the '''Currency''' object. This limits the way that '''Money''' objects can be converted.

=== Advantages ===
* Much like an integer value in Ruby, a Decimal<ref name = pydecimal /> has a theoretically infinite precision and maximum value.
* As long as the user does not access the internal structure of the '''Money''' object directly, it behaves as an immutable object

=== Disadvantages ===
* This implementation does not support an arbitrary number of decimal points
* Since the currency conversion data is set within the '''Currency''' object itself
** There is no locking present for the '''Currency''' object and there could be race conditions when users are simultaneously setting and getting exchange rates
** The current implementation can only convert to and from the default currency type
* Since this implementation can take multiple types of arguments as the monetary value but does not add methods to primitives for converting them to '''Money''' objects, type checking has to be done on arguments to determine how to handle them. This is something that we want to avoid as part of object oriented design<ref name = skrien />.

== Java ==

=== Overview ===
While Skrien introduces the Java Money class and then refines it through various stages to break it up into SimpleMoney and MixedMoney derived classes, there are various other implementations possible in Java itself. Some of the most common operations for money types are implemented in the [http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Currency.html Currency] class, which encapsulates, among other things, standard identifiers for currencies around the world. However, the lack of a standard Money Class in the Java library has resulted in users employing different schemes to conduct operations on money.
One of the simplest ways to represent Money in Java programs is to use one of the following primitive types: int, long or BigDecimal.

Here is an example snippet from [http://www.javapractices.com/topic/TopicAction.do?Id=13] that shows the use of BigDecimal to perform some basic calculations on Money values.

import java.math.BigDecimal;
import java.util.Currency;
public class MoneyCalculation {
private BigDecimal fAmountOne, fAmountTwo;
private static int DECIMALS = 2;
private static final BigDecimal TWO = new BigDecimal("2");
private static int ROUNDING_MODE = BigDecimal.ROUND_HALF_EVEN;

private BigDecimal getSum(){
return fAmountOne.add(fAmountTwo);
}

private BigDecimal getAverage(){
return getSum().divide(TWO, ROUNDING_MODE);
}

}

== C++ ==

=== Overview ===

== References ==
<references>
<ref name = skrien> Object Oriented Design Using Java / Dale Skrien -- 1st Ed. </ref>
<ref name = moneygemwebsite> http://money.rubyforge.org/ </ref>
<ref name = pymoneywebsite> http://code.google.com/p/python-money/ </ref>
<ref name = pydecimal> http://docs.python.org/library/decimal.html </ref>
<ref name = iso4217> http://www.abstracttechnology.com/standard/iso4217.html </ref>
</references>

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T05:44:41Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T05:43:49Z

Rpgodbol: /* Overview */

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T05:32:46Z

Rpgodbol: /* Java */

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T05:30:05Z

Rpgodbol: /* Java */

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T04:37:17Z

Rpgodbol: /* Java */

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-02T04:36:27Z

Rpgodbol: /* python-money (Python) */

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-01T20:44:22Z

Rpgodbol: /* Introduction */

CSC/ECE 517 Fall 2011/ch7 7a kr

2011-12-01T20:43:05Z

Rpgodbol:

CSC/ECE 517 Fall 2011/ch7 7a kr

== Introduction ==
A common task in real world application programs is conducting operations on and manipulating money values. The base data type used to represent money can be one of several possible implementations. Object oriented languages have the ability to represent this information using classes. Primitive data types such as integers, floating point numbers can also be used to represent money. There are certain inherent advantages and disadvantages with each of these methods of representation. This wiki article explores these different implementations and analyzes their relative merits and demerits. We also focus on the various operations that can be performed with money values and analyze how different languages and schemes help while working with money values.

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-08T03:36:51Z

Rpgodbol: /* Advantages */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:

{|
! align="left"| Name
! Description
! Range
|-
| TrueClass
| Singleton instance "true" allowed
| true
|-
| FalseClass
| Singleton instance "false" allowed
| false
|-
| Integer [http://www.ruby-doc.org/core/Integer.html]
| Abstract class that forms the basis for Fixnum and Bignum
| See Fixnum and Bignum
|-
| Fixnum [http://www.ruby-doc.org/core-1.8.7/Fixnum.html]
| Integer representations that fit in native machine word
| Machine architecture dependent. 2^30-1 to -2^30 on 32-bit machines.
|-
| Bignum [http://www.ruby-doc.org/core/Bignum.html]
| Integer representations that do not fit in Fixnum width
| Machine architecture dependent. Values above Fixnum range.
|-
| Float [http://www.ruby-doc.org/core/Float.html]
| Real numbers using double precision representation
| Value after decimal point can be formatted
|-
| String [http://corelib.rubyonrails.org/classes/String.html]
| Contains sequence of characters
| No physical limit, but can be decided by machine architecture
|}

One interesting observation from the above table is that Ruby does not have a Boolean class; instead it has a separate TrueClass and FalseClass [http://www.skorks.com/2009/09/true-false-and-nil-objects-in-ruby].

puts true.class
=> TrueClass
puts false.class
=> FalseClass

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a brief analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these.
So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.
* Ease of testing for comparison: With primitive types, the equality testing operators such as == can be used. These essentially compare the values stored in the primitive types. Regular objects also offer the eql? method for testing equality. However, the following are not equivalent:
a=10
=> 10
a==10
=> true
a==10.0
=> true
a.eql?(10.0)
=> false
The reason the .eql? fails is that this operator tests for value and type being the same. 10 is type Fixnum and 10.0 is type Float.
The eql? can be overridden by == for primitive objects if you wish to compare only the values, but that can have a negative impact on performance [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html].

=== Disadvantages ===
* Lack of inheritance capability: The primitive data types in languages such as Java cannot be inherited to create further subtypes.
* Unexpected results due to method overriding: There are certain examples such as [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html], which show that overriding inbuilt methods such as == and eql? can lead to unexpected results.

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm
# http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-08T01:51:34Z

Rpgodbol: /* Merit Analysis of Primitive Types */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:

{|
! align="left"| Name
! Description
! Range
|-
| TrueClass
| Singleton instance "true" allowed
| true
|-
| FalseClass
| Singleton instance "false" allowed
| false
|-
| Integer [http://www.ruby-doc.org/core/Integer.html]
| Abstract class that forms the basis for Fixnum and Bignum
| See Fixnum and Bignum
|-
| Fixnum [http://www.ruby-doc.org/core-1.8.7/Fixnum.html]
| Integer representations that fit in native machine word
| Machine architecture dependent. 2^30-1 to -2^30 on 32-bit machines.
|-
| Bignum [http://www.ruby-doc.org/core/Bignum.html]
| Integer representations that do not fit in Fixnum width
| Machine architecture dependent. Values above Fixnum range.
|-
| Float [http://www.ruby-doc.org/core/Float.html]
| Real numbers using double precision representation
| Value after decimal point can be formatted
|-
| String [http://corelib.rubyonrails.org/classes/String.html]
| Contains sequence of characters
| No physical limit, but can be decided by machine architecture
|}

One interesting observation from the above table is that Ruby does not have a Boolean class; instead it has a separate TrueClass and FalseClass [http://www.skorks.com/2009/09/true-false-and-nil-objects-in-ruby].

puts true.class
=> TrueClass
puts false.class
=> FalseClass

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a brief analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these.
So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.
* Simplicity in testing types for comparison: With primitive types, the equality testing operators such as == can be used. These essentially compare the values stored in the primitive types. Regular objects also offer the eql? method for testing equality. However, the following are not equivalent:
a=10
=> 10
a==10
=> true
a==10.0
=> true
a.eql?(10.0)
=> false
The reason the .eql? fails is that this operator tests for value and type being the same. 10 is type Fixnum and 10.0 is type Float.
The eql? can be overridden by == for primitive objects if you wish to compare only the values, but that can have a negative impact on performance [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html].

=== Disadvantages ===
* Lack of inheritance capability: The primitive data types in languages such as Java cannot be inherited to create further subtypes.
* Unexpected results due to method overriding: There are certain examples such as [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html], which show that overriding inbuilt methods such as == and eql? can lead to unexpected results.

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm
# http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-08T01:50:44Z

Rpgodbol: /* Advantages */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:

{|
! align="left"| Name
! Description
! Range
|-
| TrueClass
| Singleton instance "true" allowed
| true
|-
| FalseClass
| Singleton instance "false" allowed
| false
|-
| Integer [http://www.ruby-doc.org/core/Integer.html]
| Abstract class that forms the basis for Fixnum and Bignum
| See Fixnum and Bignum
|-
| Fixnum [http://www.ruby-doc.org/core-1.8.7/Fixnum.html]
| Integer representations that fit in native machine word
| Machine architecture dependent. 2^30-1 to -2^30 on 32-bit machines.
|-
| Bignum [http://www.ruby-doc.org/core/Bignum.html]
| Integer representations that do not fit in Fixnum width
| Machine architecture dependent. Values above Fixnum range.
|-
| Float [http://www.ruby-doc.org/core/Float.html]
| Real numbers using double precision representation
| Value after decimal point can be formatted
|-
| String [http://corelib.rubyonrails.org/classes/String.html]
| Contains sequence of characters
| No physical limit, but can be decided by machine architecture
|}

One interesting observation from the above table is that Ruby does not have a Boolean class; instead it has a separate TrueClass and FalseClass [http://www.skorks.com/2009/09/true-false-and-nil-objects-in-ruby].

puts true.class
=> TrueClass
puts false.class
=> FalseClass

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these.
So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.
* Simplicity in testing types for comparison: With primitive types, the equality testing operators such as == can be used. These essentially compare the values stored in the primitive types. Regular objects also offer the eql? method for testing equality. However, the following are not equivalent:
a=10
=> 10
a==10
=> true
a==10.0
=> true
a.eql?(10.0)
=> false
The reason the .eql? fails is that this operator tests for value and type being the same. 10 is type Fixnum and 10.0 is type Float.
The eql? can be overridden by == for primitive objects if you wish to compare only the values, but that can have a negative impact on performance [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html].

=== Disadvantages ===
* Lack of inheritance capability: The primitive data types in languages such as Java cannot be inherited to create further subtypes.
* Unexpected results due to method overriding: There are certain examples such as [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html], which show that overriding inbuilt methods such as == and eql? can lead to unexpected results.

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm
# http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T06:19:07Z

Rpgodbol: /* Disadvantages */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:

{|
! align="left"| Name
! Description
! Range
|-
| TrueClass
| Singleton instance "true" allowed
| true
|-
| FalseClass
| Singleton instance "false" allowed
| false
|-
| Integer [http://www.ruby-doc.org/core/Integer.html]
| Abstract class that forms the basis for Fixnum and Bignum
| See Fixnum and Bignum
|-
| Fixnum [http://www.ruby-doc.org/core-1.8.7/Fixnum.html]
| Integer representations that fit in native machine word
| Machine architecture dependent. 2^30-1 to -2^30 on 32-bit machines.
|-
| Bignum [http://www.ruby-doc.org/core/Bignum.html]
| Integer representations that do not fit in Fixnum width
| Machine architecture dependent. Values above Fixnum range.
|-
| Float [http://www.ruby-doc.org/core/Float.html]
| Real numbers using double precision representation
| Value after decimal point can be formatted
|-
| String [http://corelib.rubyonrails.org/classes/String.html]
| Contains sequence of characters
| No physical limit, but can be decided by machine architecture
|}

One interesting observation from the above table is that Ruby does not have a Boolean class; instead it has a separate TrueClass and FalseClass [http://www.skorks.com/2009/09/true-false-and-nil-objects-in-ruby].

puts true.class
=> TrueClass
puts false.class
=> FalseClass

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these.
So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.
* Comparison operation

=== Disadvantages ===
* Lack of inheritance capability: The primitive data types in languages such as Java cannot be inherited to create further subtypes.
* Unexpected results due to method overriding: There are certain examples such as [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html], which show that overriding inbuilt methods such as == and eql? can lead to unexpected results.

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm
# http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T06:17:12Z

Rpgodbol: /* Disadvantages */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:

{|
! align="left"| Name
! Description
! Range
|-
| TrueClass
| Singleton instance "true" allowed
| true
|-
| FalseClass
| Singleton instance "false" allowed
| false
|-
| Integer [http://www.ruby-doc.org/core/Integer.html]
| Abstract class that forms the basis for Fixnum and Bignum
| See Fixnum and Bignum
|-
| Fixnum [http://www.ruby-doc.org/core-1.8.7/Fixnum.html]
| Integer representations that fit in native machine word
| Machine architecture dependent. 2^30-1 to -2^30 on 32-bit machines.
|-
| Bignum [http://www.ruby-doc.org/core/Bignum.html]
| Integer representations that do not fit in Fixnum width
| Machine architecture dependent. Values above Fixnum range.
|-
| Float [http://www.ruby-doc.org/core/Float.html]
| Real numbers using double precision representation
| Value after decimal point can be formatted
|-
| String [http://corelib.rubyonrails.org/classes/String.html]
| Contains sequence of characters
| No physical limit, but can be decided by machine architecture
|}

One interesting observation from the above table is that Ruby does not have a Boolean class; instead it has a separate TrueClass and FalseClass [http://www.skorks.com/2009/09/true-false-and-nil-objects-in-ruby].

puts true.class
=> TrueClass
puts false.class
=> FalseClass

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these.
So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.
* Comparison operation

=== Disadvantages ===
* Lack of inheritance capability
* Unexpected results due to method overriding

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm
# http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T06:13:24Z

Rpgodbol: /* Advantages */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:

{|
! align="left"| Name
! Description
! Range
|-
| TrueClass
| Singleton instance "true" allowed
| true
|-
| FalseClass
| Singleton instance "false" allowed
| false
|-
| Integer [http://www.ruby-doc.org/core/Integer.html]
| Abstract class that forms the basis for Fixnum and Bignum
| See Fixnum and Bignum
|-
| Fixnum [http://www.ruby-doc.org/core-1.8.7/Fixnum.html]
| Integer representations that fit in native machine word
| Machine architecture dependent. 2^30-1 to -2^30 on 32-bit machines.
|-
| Bignum [http://www.ruby-doc.org/core/Bignum.html]
| Integer representations that do not fit in Fixnum width
| Machine architecture dependent. Values above Fixnum range.
|-
| Float [http://www.ruby-doc.org/core/Float.html]
| Real numbers using double precision representation
| Value after decimal point can be formatted
|-
| String [http://corelib.rubyonrails.org/classes/String.html]
| Contains sequence of characters
| No physical limit, but can be decided by machine architecture
|}

One interesting observation from the above table is that Ruby does not have a Boolean class; instead it has a separate TrueClass and FalseClass [http://www.skorks.com/2009/09/true-false-and-nil-objects-in-ruby].

puts true.class
=> TrueClass
puts false.class
=> FalseClass

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these.
So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.
* Comparison operation

=== Disadvantages ===
* Lack of inheritance capability
*

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm
# http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T06:11:42Z

Rpgodbol: /* Primitive Objects in Ruby */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:

{|
! align="left"| Name
! Description
! Range
|-
| TrueClass
| Singleton instance "true" allowed
| true
|-
| FalseClass
| Singleton instance "false" allowed
| false
|-
| Integer [http://www.ruby-doc.org/core/Integer.html]
| Abstract class that forms the basis for Fixnum and Bignum
| See Fixnum and Bignum
|-
| Fixnum [http://www.ruby-doc.org/core-1.8.7/Fixnum.html]
| Integer representations that fit in native machine word
| Machine architecture dependent. 2^30-1 to -2^30 on 32-bit machines.
|-
| Bignum [http://www.ruby-doc.org/core/Bignum.html]
| Integer representations that do not fit in Fixnum width
| Machine architecture dependent. Values above Fixnum range.
|-
| Float [http://www.ruby-doc.org/core/Float.html]
| Real numbers using double precision representation
| Value after decimal point can be formatted
|-
| String [http://corelib.rubyonrails.org/classes/String.html]
| Contains sequence of characters
| No physical limit, but can be decided by machine architecture
|}

One interesting observation from the above table is that Ruby does not have a Boolean class; instead it has a separate TrueClass and FalseClass [http://www.skorks.com/2009/09/true-false-and-nil-objects-in-ruby].

puts true.class
=> TrueClass
puts false.class
=> FalseClass

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these. So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.
* Comparison operation

=== Disadvantages ===
* Lack of inheritance capability
*

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm
# http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T06:10:54Z

Rpgodbol: /* Primitive Objects in Ruby */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:

{|
! align="left"| Name
! Description
! Range
|-
| TrueClass
| Singleton instance "true" allowed
| true
|-
| FalseClass
| Singleton instance "false" allowed
| false
|-
| Integer [http://www.ruby-doc.org/core/Integer.html]
| Abstract class that forms the basis for Fixnum and Bignum
| See Fixnum and Bignum
|-
| Fixnum [http://www.ruby-doc.org/core-1.8.7/Fixnum.html]
| Integer representations that fit in native machine word
| Machine architecture dependent. 2^30-1 to -2^30 on 32-bit machines.
|-
| Bignum [http://www.ruby-doc.org/core/Bignum.html]
| Integer representations that do not fit in Fixnum width
| Machine architecture dependent. Values above Fixnum range.
|-
| Float [http://www.ruby-doc.org/core/Float.html]
| Real numbers using double precision representation
| Value after decimal point can be formatted
|-
| String [http://corelib.rubyonrails.org/classes/String.html]
| Contains sequence of characters
| Limit imposed by machine architecture
|}

One interesting observation from the above table is that Ruby does not have a Boolean class; instead it has a separate TrueClass and FalseClass [http://www.skorks.com/2009/09/true-false-and-nil-objects-in-ruby].

puts true.class
=> TrueClass
puts false.class
=> FalseClass

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these. So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.
* Comparison operation

=== Disadvantages ===
* Lack of inheritance capability
*

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm
# http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T05:51:56Z

Rpgodbol: /* Primitive Objects in Ruby */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:

{|
! align="left"| Name
| Description
| Range
|-
| TrueClass
| Singleton instance "true" allowed
|-
| FalseClass
| Singleton instance "false" allowed
|-
| Integer [http://www.ruby-doc.org/core/Integer.html]
| Abstract class that forms the basis for Fixnum and Bignum
|-
| Fixnum [http://www.ruby-doc.org/core-1.8.7/Fixnum.html]
| Integer representations that fit in native machine word
|-
| Bignum [http://www.ruby-doc.org/core/Bignum.html]
| Integer representations that do not fit in Fixnum width
|-
| Float [http://www.ruby-doc.org/core/Float.html]
| Real numbers using double precision representation
|-
| String [http://corelib.rubyonrails.org/classes/String.html]
| Contains sequence of characters
|}

One interesting observation from the above table is that Ruby does not have a Boolean class; instead it has a separate TrueClass and FalseClass [http://www.skorks.com/2009/09/true-false-and-nil-objects-in-ruby].

puts true.class
=> TrueClass
puts false.class
=> FalseClass

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these. So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.
* Comparison operation

=== Disadvantages ===
* Lack of inheritance capability
*

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm
# http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T05:30:14Z

Rpgodbol: /* References */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:

{|
! align="left"| Name
|-
| Boolean
|-
| Bignum
|-
| Fixnum
|-
| Float
|-
| Integer
|-
| String
|}

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these. So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.
* Comparison operation

=== Disadvantages ===
* Lack of inheritance capability
*

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm
# http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T05:30:03Z

Rpgodbol: /* Advantages */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:

{|
! align="left"| Name
|-
| Boolean
|-
| Bignum
|-
| Fixnum
|-
| Float
|-
| Integer
|-
| String
|}

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these. So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.
* Comparison operation

=== Disadvantages ===
* Lack of inheritance capability
*

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T03:36:46Z

Rpgodbol: /* Primitive Objects in Ruby */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:

{|
! align="left"| Name
|-
| Boolean
|-
| Bignum
|-
| Fixnum
|-
| Float
|-
| Integer
|-
| String
|}

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these. So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.

=== Disadvantages ===
* Lack of inheritance capability
*

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T03:33:11Z

Rpgodbol: /* Advantages */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:
* Boolean
* Bignum
* Fixnum
* Float
* Integer
* String

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these. So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.

=== Disadvantages ===
* Lack of inheritance capability
*

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T03:32:24Z

Rpgodbol: /* Primitive Objects in Ruby */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:
* Boolean
* Bignum
* Fixnum
* Float
* Integer
* String

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types or objects in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these. So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.

=== Disadvantages ===
* Lack of inheritance capability
*

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T03:31:23Z

Rpgodbol: /* Disadvantages */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:
* Boolean
* Bignum
* Fixnum
* Float
* Integer
* String

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

* Example [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html]

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types or objects in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these. So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.

=== Disadvantages ===
* Lack of inheritance capability
*

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T03:25:00Z

Rpgodbol: /* Advantages */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:
* Boolean
* Bignum
* Fixnum
* Float
* Integer
* String

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

* Example [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html]

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types or objects in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these. So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.

=== Disadvantages ===

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T03:24:04Z

Rpgodbol: /* Advantages */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:
* Boolean
* Bignum
* Fixnum
* Float
* Integer
* String

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

* Example [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html]

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types or objects in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these. So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.

=== Disadvantages ===

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm

CSC/ECE 517 Fall 2011/ch3 3h rr

2011-10-07T03:13:21Z

Rpgodbol:

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{|
! align="left"|Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{|
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{|
! align="left"| Name
! .NET Class
! Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:
* Boolean
* Bignum
* Fixnum
* Float
* Integer
* String

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

* Example [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html]

== Merit Analysis of Primitive Types ==
This section deals with a holistic analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types or objects in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these. So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg.

=== Disadvantages ===

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm