Add tests for Money, ExchangeRate and ExchangeRatManager

Author: Eucalyptus2013

src/currencies/exchangerate.jl

@@ -6,6 +6,7 @@ immutable ExchangeRate
 	rateChain::(ExchangeRate, ExchangeRate)
 
 	ExchangeRate(source::Currency, target::Currency, rate::Float64)=new(source, target, rate, :Direct)
+	ExchangeRate(source::Currency, target::Currency, rate::Float64, type_::Symbol, rateChain::(ExchangeRate, ExchangeRate))=new(source, target, rate, type_, rateChain)
 end
 
 # Apply the exchange rate to a cash amount
@@ -22,7 +23,6 @@ function exchange(ER::ExchangeRate, m::Money)
 		end
 
 	elseif ER.type_==:Derived #Derived from exchange rates between other currencies
-	
 		if m.currency==ER.rateChain[1].source || m.currency==ER.rateChain[1].target
 			return exchange(ER.rateChain[2], exchange(ER.rateChain[1], m))
 		elseif m.currency==ER.rateChain[2].source || m.currency==ER.rateChain[2].target
@@ -37,39 +37,35 @@ end
 
 # Chain two exchange rates
 function chain(ER1::ExchangeRate, ER2::ExchangeRate)
-	
-	result::ExchangeRate
-	result.type_=:Derived
-	result.rateChain=(ER1, ER2)
-	
+
 	if ER1.source==ER2.source
 
-		result.source=ER1.target
-		result.target=ER2.target
-		result.rate=ER2.rate/ER1.rate
+		source=ER1.target
+		target=ER2.target
+		rate=ER2.rate/ER1.rate
 
 	elseif ER1.source==ER2.target
 
-		result.source=ER1.target
-		result.target=ER2.source
-		result.rate=1.0/(ER1.rate*ER2.rate)
+		source=ER1.target
+		target=ER2.source
+		rate=1.0/(ER1.rate*ER2.rate)
 
 	elseif ER1.target==ER2.source
 
-		result.source=ER1.source
-		result.target=ER2.target
-		result.rate=ER1.rate*ER2.rate
+		source=ER1.source
+		target=ER2.target
+		rate=ER1.rate*ER2.rate
 
 	elseif ER1.target==ER2.target
 
-		result.source=ER1.source
-		result.target=ER2.source
-		result.rate=ER1.rate/ER2.rate
+		source=ER1.source
+		target=ER2.source
+		rate=ER1.rate/ER2.rate
 
 	else
 		error("Exchange rates not chainable")
 	end
 
-	return result
-
-end
+	return ExchangeRate(source, target, rate, :Derived, (ER1, ER2))
+end
+	

src/currencies/exchangeratemanager.jl

@@ -21,7 +21,7 @@ function add(ERM::ExchangeRateManager, ER::ExchangeRate, startdate::CalendarTime
 	if !haskey(ERM.data, key)
 		ERM.data[key]=Array(Entry, 0)
 	end
-	push!(ERM.data[key], Entry(ER, startdate, enddate))
+	push!(ERM.data[key], Entry(ER, startdate, enddate))	
 end
 
 function addKnownRates(ERM::ExchangeRateManager)
@@ -53,14 +53,17 @@ function addKnownRates(ERM::ExchangeRateManager)
 end
 
 function clear(ERM::ExchangeRateManager)
-	ERM.data=Dict{BigInt, Array{Entry}}() # Delete the dictionary
-	addKnownRates(ERM)
+	ERM=ExchangeRateManager()
 end
 
 hash(c1::Currency, c2::Currency)=BigInt(min(c1.numeric, c2.numeric))*1000+BigInt(max(c1.numeric, c2.numeric))
-hashes(key::BigInt, c::Currency)=c.numeric==key%1000 || c.numeric==key/1000
+hashes(key::BigInt, c::Currency)=c.numeric==key%1000 || c.numeric==trunc(key/1000)
 
 function fetch(ERM::ExchangeRateManager, source::Currency, target::Currency, date::CalendarTime)
+	if !haskey(ERM.data, hash(source, target))
+		return nothing
+	end
+	
 	entries=ERM.data[hash(source, target)]
 	for entry in entries
 		if date>=entry.start && date<=entry.end_
@@ -80,7 +83,7 @@ function directLookup(ERM::ExchangeRateManager, source::Currency, target::Curren
 	end
 end
 
-function smartLookup(ERM::ExchangeRateManager, source::Currency, target::Currency, date::CalendarTime, forbidden::Array{Integer, 1})
+function smartLookup(ERM::ExchangeRateManager, source::Currency, target::Currency, date::CalendarTime, forbidden::Array{Int, 1})
 	fetchedRate=fetch(ERM, source, target, date)
 
 	# direct exchange rates are preferred.
@@ -94,20 +97,20 @@ function smartLookup(ERM::ExchangeRateManager, source::Currency, target::Currenc
 
 	for key in keys(ERM.data)
 		# we look for exchange-rate data which involve our source currency
-		if hashes(key, source) && length(ERM.data[key])!=0
+		if hashes(key, source) && length(ERM.data[key])!=0				
 			# ...whose other currency is not forbidden...
-			e=ERM.data[key][1]
+			e=ERM.data[BigInt(key)][1]
 			other= source==e.rate.source ? e.rate.target : e.rate.source
-			
 			if !in(other.numeric, forbidden)
 				# ...and which carries information for the requested date.
-				head=fetch(ERM, source, other, date)
-				
+				head=fetch(ERM, source, other, date)	
+
 				if head!=nothing
 					# if we can get to the target from here...
-					try
-						tail=smartLookup(ERM, other, target, date, forbidden)
+					try						
+						tail=smartLookup(ERM, other, target, date, forbidden)						
 						# ..we're done.
+						return chain(head, tail)
 					catch
 						# otherwise, we just discard this rate.
 					end
@@ -121,6 +124,7 @@ function smartLookup(ERM::ExchangeRateManager, source::Currency, target::Currenc
 end
 
 function lookup(ERM::ExchangeRateManager, source::Currency, target::Currency, date::CalendarTime, ERType::Symbol=:Derived)
+	
 	if source==target
 		return ExchangeRate(source, target, 1.0)
 	end
@@ -150,14 +154,16 @@ function lookup(ERM::ExchangeRateManager, source::Currency, target::Currency, da
 		end
 
 	else
-		return smartLookup(EMR, source, target, date, Array(Int,0))
+		return smartLookup(ERM, source, target, date, Array(Int,0))
 	end
 
 end
 
+# Singleton design pattern
 function getInstance()
-	if !isdefined(:ERM_Instance)
-		global ERM_Instance=ExchangeRateManager()
+	global ERM_Instance
+	if !isdefined(Currencies, :ERM_Instance)
+		ERM_Instance=ExchangeRateManager()
 	end
 	return ERM_Instance
 end

src/currencies/money.jl

@@ -3,15 +3,21 @@ type Money
 	currency::Currency
 end
 
-const ConversionType=:NoConversion # or :BaseCurrencyConversion, :AutomatedConversion
+ConversionType=:NoConversion # or :BaseCurrencyConversion, :AutomatedConversion
+setConversionType(s::Symbol)=(global ConversionType; ConversionType=s)
+
+staticBaseCurrency=nothing
+setStaticBaseCurrency(c::Currency)=(global staticBaseCurrency; staticBaseCurrency=c)
+resetStaticBaseCurrency()=(global staticBaseCurrency; staticBaseCurrency=nothing)
 
 # Constructors
 Money()=Money(0.0, none)
 Money(curr::Currency, val::Float64)=Money(val, curr)
 
 # Transformations
-rounded(m::Money)=Money(m.rounding(m.value), m.currency)
-baseCurrency(m::Money)=m.currency
+rounded(m::Money)=Money(m.currency.rounding(m.value), m.currency)
+
+baseCurrency(m::Money)= staticBaseCurrency==nothing ? m.currency : staticBaseCurrency
 +(m::Money)=m
 -(m::Money)=Money(-m.value, m.currency)	
 
@@ -25,6 +31,9 @@ baseCurrency(m::Money)=m.currency
 /(m::Money, x::Float64)=Money(m.currency, m.value/x)
 /(x::Float64, m::Money)=m/x
 
+# Copy function
+import Base.copy
+copy(m::Money)=Money(m.currency, m.value)
 
 # Print function
 import Base.show

src/currencies/moneyop.jl

@@ -2,8 +2,9 @@
 function convertTo(m::Money, target::Currency)
 	if m.currency!=target
 		rate=lookup(m.currency, target)
-		m=rounded(exchange(rate, m))
+		return rounded(exchange(rate, m))
 	end
+	return m
 end
 
 convertToBase(m::Money)=convertTo(m, baseCurrency(m))
@@ -12,24 +13,38 @@ function functionOperator(m1::Money, m2::Money, op::Function)
 	if m1.currency==m2.currency
 		return op(m1.value, m2.value)
 	elseif ConversionType==:BaseCurrencyConversion
-		tmp1=copy(m1)
-		convertToBase(tmp1)
-		tmp2=copy(m2)
-		convertToBase(tmp2)
-		return functionOperator(tpm1, tpm2, op)
+		tmp1=convertToBase(m1)
+		tmp2=convertToBase(m2)
+		return functionOperator(tmp1, tmp2, op)
 	elseif ConversionType==:AutomatedConversion
-		tmp=copy(m2)
-		convertTo(tmp, m1.currency)
+		tmp=convertTo(m2, m1.currency)
 		return functionOperator(m1, tmp, op)
 	else
 		error("currency mismatch and no conversion specified")
 	end
 end
 
-# Operator functions
-+(m1::Money, m2::Money)=functionOperator(m1, m2, +)
--(m1::Money, m2::Money)=functionOperator(m1, m2, -)
+# Operator functions that return a value
 /(m1::Money, m2::Money)=functionOperator(m1, m2, /)
 ==(m1::Money, m2::Money)=functionOperator(m1, m2, ==)
 <(m1::Money, m2::Money)=functionOperator(m1, m2, <)
-close(m1::Money, m2::Money)=functionOperator(m1, m2, (x,y)=>abs(x-y)<10.0^(-10))
+close(m1::Money, m2::Money)=functionOperator(m1, m2, (x,y)=>abs(x-y)<10.0^(-10))
+
+function functionOperatorMoney(m1::Money, m2::Money, op::Function)
+	if m1.currency==m2.currency
+		return Money(m1.currency, op(m1.value, m2.value))
+	elseif ConversionType==:BaseCurrencyConversion
+		tmp1=convertToBase(m1)		
+		tmp2=convertToBase(m2)
+		return functionOperatorMoney(tmp1, tmp2, op)
+	elseif ConversionType==:AutomatedConversion
+		tmp=convertTo(m2, m1.currency)
+		return functionOperatorMoney(m1, tmp, op)
+	else
+		error("currency mismatch and no conversion specified")
+	end
+end
+
+# Operator functions that return a Money
++(m1::Money, m2::Money)=functionOperatorMoney(m1, m2, +)
+-(m1::Money, m2::Money)=functionOperatorMoney(m1, m2, -)

test/Ito.jl

@@ -3,4 +3,5 @@
 require("Ito/test/calendars.jl")
 require("Ito/test/statistics.jl")
 require("Ito/test/integration.jl")
-require("Ito/test/term_structure.jl")
+require("Ito/test/term_structure.jl")
+require("Ito/test/currencies.jl")

test/currencies.jl

@@ -0,0 +1,78 @@
+require("Ito")
+using Base.Test
+using Ito.Currencies
+
+# Testing money arithmetic without conversions...
+
+EUR=Currencies.EURCurrency()
+
+m1 = 50000.0 * EUR;
+m2 = 100000.0 * EUR;
+m3 = 500000.0 * EUR;
+
+Currencies.setConversionType(:NoConversion)
+
+calculated = m1*3.0 + 2.5*m2 - m3/5.0
+x = m1.value*3.0 + 2.5*m2.value - m3.value/5.0
+expected=Currencies.Money(x, EUR)
+
+@test calculated==expected
+
+# Testing money arithmetic with conversion to base currency...
+
+EUR=Currencies.EURCurrency()
+GBP=Currencies.GBPCurrency()
+USD=Currencies.USDCurrency()
+
+m1 = 50000.0 * GBP
+m2 = 100000.0 * EUR
+m3 = 500000.0 * USD
+
+Currencies.clear()
+
+eur_usd=Currencies.ExchangeRate(EUR, USD, 1.2042)
+eur_gbp=Currencies.ExchangeRate(EUR, GBP, 0.6612)
+Currencies.add(eur_usd)
+Currencies.add(eur_gbp)
+
+
+Currencies.setConversionType(:BaseCurrencyConversion)
+Currencies.setStaticBaseCurrency(EUR)
+
+
+calculated=m1*3.0+2.5*m2-m3/5.0
+_round=Currencies.baseCurrency(m1).rounding
+x=_round(m1.value*3.0/eur_gbp.rate)+2.5*m2.value-_round(m3.value/(5.0*eur_usd.rate))
+expected=Currencies.Money(x, EUR)
+
+Currencies.setConversionType(:NoConversion)
+
+@test calculated==expected
+
+# Testing money arithmetic with automated conversion...
+
+EUR=Currencies.EURCurrency()
+GBP=Currencies.GBPCurrency()
+USD=Currencies.USDCurrency()
+
+m1 = 50000.0 * GBP
+m2 = 100000.0 * EUR
+m3 = 500000.0 * USD
+
+Currencies.clear()
+
+eur_usd=Currencies.ExchangeRate(EUR, USD, 1.2042)
+eur_gbp=Currencies.ExchangeRate(EUR, GBP, 0.6612)
+Currencies.add(eur_usd)
+Currencies.add(eur_gbp)
+
+Currencies.setConversionType(:AutomatedConversion)
+
+calculated=(m1*3.0+2.5*m2)-m3/5.0
+_round=m1.currency.rounding
+x=m1.value*3.0+_round(2.5*m2.value*eur_gbp.rate)-_round((m3.value/5.0)*eur_gbp.rate/eur_usd.rate)
+expected=Currencies.Money(x, GBP)
+
+Currencies.setConversionType(:NoConversion)
+
+@test calculated==expected