# Import / Load the necessary librarys
library(openxlsx)
library(readxl)
# Reading the Data from the Sheet (Excel)
fx_data <- read.xlsx("Foreign_Exchange_Rates.xlsx", sheet = "Rates")
# Replacement of all "ND" values
# Using the values from the previous rows to do so
for (col_index in 1:ncol(fx_data)) {
for (row_index in 1:nrow(fx_data)) {
if (fx_data[row_index, col_index] == "ND") {
fx_data[row_index, col_index] <- fx_data[row_index - 1, col_index]
}
}
}
# Saving the cleaned data under another Excel file
write.xlsx(fx_data, "Cleaned_Foreign_Exchange_Rates.xlsx", sheetName = "Rates")
# Convert the 'Time.Serie' column to a Date format
fx_data$Time.Serie <- as.Date(fx_data$Time.Serie)
# Assigning each currency's rates to individual variables (Named after their currency codes (EUR,GBP,AUD,CAD,JPY))
EUR <- c(fx_data$`EURO.AREA.-.EURO/US$`)
GBP <- c(fx_data$`UNITED.KINGDOM.-.UNITED.KINGDOM.POUND/US$`)
AUD <- c(fx_data$`AUSTRALIA.-.AUSTRALIAN.DOLLAR/US$`)
SGD <- c(fx_data$`SINGAPORE.-.SINGAPORE.DOLLAR/US$`)
JPY <- c(fx_data$`JAPAN.-.YEN/US$`)
#All exchange rates: Each plotted in a separate table
par(mfrow = c(2, 3))
plot(EUR , type = "l",col = "gold", xlab = "time", ylab = "Exchange Rate to USD", main = "Euro")
plot(GBP , type = "l",col = "green", xlab = "time", ylab = "Exchange to USD", main = "Great British Pound")
plot(AUD , type = "l", col = "darkblue", xlab = "time", ylab = "Exchange Rate to USD", main = "Australian Dollar")
plot(SGD , type = "l", col = "red", xlab = "time", ylab = "Exchange Rate to USD", main = "Singapore Dollar")
plot(JPY , type = "l", col = "purple", xlab = "time", ylab = "Exchange Rate to USD", main = "Japanese Yen")
par(mfrow = c(1, 1))
# All exchange rates in a single table: Leaving out JPY (Due to Visibility)
plot(EUR , type = "l",col = "gold", xlab = "Time", xlim = c(2000, 2024), ylab = "Exchange Rates to USD", ylim = c(0.4, 1.6), main = "Exchange Rates over time")
lines(GBP , type = "l",col = "green")
lines(AUD , type = "l",col = "darkblue")
lines(SGD , type = "l",col = "red")
# Load required packages or install (if necessary)
if (!require("corrplot")) {install.packages("corrplot"); library("corrplot")}
## Lade nötiges Paket: corrplot
## corrplot 0.92 loaded
#Converting exchange rate data to numeric format(Enabling mathematical operations and analysis)
EUR <- as.numeric(EUR)
GBP <- as.numeric(GBP)
AUD <- as.numeric(AUD)
SGD <- as.numeric(SGD)
JPY <- as.numeric(JPY)
#Calculating the discrete returns for each currency: Taking the difference between consecutive exchange rate values and dividing by the previous value
#Effectively computing the percentage change from one period to the next.
# R[t]=P[t]/P[t-1]-1
Return_EUR <- diff(EUR) / EUR[-length(EUR)]
Return_GBP <- diff(GBP) / GBP[-length(GBP)]
Return_AUD <- diff(AUD) / AUD[-length(AUD)]
Return_SGD <- diff(SGD) / SGD[-length(SGD)]
Return_JPY <- diff(JPY) / JPY[-length(JPY)]
# Assuming all return vectors have the same length
returns <- cbind(Return_EUR, Return_GBP, Return_AUD, Return_SGD, Return_JPY)
colnames(returns) <- c("EUR", "GBP", "AUD", "SGD", "JPY")
# Calculate correlation matrix
cor_matrix <- cor(returns, use = "complete.obs")
# Plot correlation matrix
corrplot(cor_matrix, method = "color")
# Creating the Return Histograms
par(mfrow = c(2, 2))
hist(Return_EUR, breaks = 30, col = "gold", xlab = "Return", ylab = "Frequency", main = "Histogram: EUR Returns")
hist(Return_GBP, breaks = 30, col = "green", xlab = "Return", ylab = "Frequency", main = "Histogram: GBP Returns")
hist(Return_AUD, breaks = 30, col = "darkblue", xlab = "Return", ylab = "Frequency", main = "Histogram: AUD Returns")
hist(Return_SGD, breaks = 30, col = "red", xlab = "Return", ylab = "Frequency", main = "Histogram: SGD Returns")
hist(Return_JPY, breaks = 30, col = "purple", xlab = "Return", ylab = "Frequency", main = "Histogram: JPY Returns")
# Plotting all Return Rates in single tables
par(mfrow = c(2, 2))
plot(Return_EUR,type = "l",col = "gold", xlab = "time", xlim = c(2000, 2024), ylab = "Exchange Rates to USD", ylim = c(-0.05, 0.05), main = "Euro Return")
plot(Return_GBP , type = "l",col = "green", xlab = "time", xlim = c(2000, 2024), ylab = "Exchange Rates to USD", ylim = c(-0.05, 0.05), main = "Great Britain Pound Return")
plot(Return_AUD , type = "l", col = "darkblue", xlab = "time", xlim = c(2000, 2024), ylab = "Exchange Rates to USD", ylim = c(-0.05, 0.05), main = "Australian Dollar Return")
plot(Return_SGD , type = "l", col = "red", xlab = "time", xlim = c(2000, 2024), ylab = "Exchange Rates to USD", ylim = c(-0.05, 0.05), main = "Singapore Dollar Return")
plot(Return_JPY , type = "l", col = "purple", xlab = "time", xlim = c(2000, 2024), ylab = "Exchange Rates to USD", ylim = c(-0.05, 0.05), main = "Japanese Yen Return")
par(mfrow = c(1, 1))
# Loading the required "moments" package (if necessary)
if (!require("moments")) {install.packages("moments"); library("moments")}
## Lade nötiges Paket: moments
# List of all the currencies
currencies <- c("EUR", "GBP", "AUD", "SGD", "JPY")
# Function: Calculating the measures for each currency
calculate_measures <- function(currency) {
returns <- get(paste0("Return_", currency))
# Calculation: Return p.a. (250 trading days per year)
mean_return_pa <- mean(returns) * 250
# Calculation: Historical volatility
sd_pa <- sd(returns) * sqrt(250)
# Calculation: Skewness
skew <- skewness(returns)
# Kurtosis
kurt <- kurtosis(returns)
# Sharpe ratio with 4.25% risk-free rate
sharpe_ratio <- (mean_return_pa - 0.03) / sd_pa
# Calculation: Value-at-Risk (1 year, 3 Months, 10 Days // 95% Confidence)
var_1year <- mean_return_pa + qnorm(0.05) * sd_pa
var_3months <- mean_return_pa + qnorm(0.05) * sd_pa * sqrt(60)
var_10days <- mean_return_pa + qnorm(0.05) * sd_pa * sqrt(10)
return(c(mean_return_pa, sd_pa, skew, kurt, sharpe_ratio, var_1year, var_3months, var_10days))
}
# Calculating the relevant measures for every currency
results <- t(sapply(currencies, calculate_measures))
# Reviewing the dimensions of the results matrix to ensure there were no calculation mistakes
print(dim(results))
## [1] 5 8
#Generating a data frame for the results
results_df <- data.frame(
Mean_Return_pa = results[,1],
Volatility_pa = results[,2],
Skewness = results[,3],
Kurtosis = results[,4],
Sharpe_Ratio = results[,5],
VaR_1year = results[,6],
VaR_3months = results[,7],
VaR_10days = results[,8]
)
# Display the results
print(results_df)
## Mean_Return_pa Volatility_pa Skewness Kurtosis Sharpe_Ratio VaR_1year
## EUR -0.0003710667 0.09420434 -0.04721343 5.562962 -0.3223956 -0.15532342
## GBP 0.0140379613 0.09251702 0.85736170 16.114097 -0.1725308 -0.13813900
## AUD 0.0045870609 0.12414954 0.80673282 16.560690 -0.2046962 -0.19962077
## SGD -0.0087018845 0.05081241 0.03338141 8.431664 -0.7616620 -0.09228086
## JPY 0.0078775149 0.09690920 -0.26413005 7.353733 -0.2282805 -0.15152394
## VaR_3months VaR_10days
## EUR -1.2006268 -0.4903734
## GBP -1.1647197 -0.4671878
## AUD -1.5772000 -0.6411748
## SGD -0.6561019 -0.2730018
## JPY -1.2268408 -0.4961941
# Load required packages or install (if necessery)
if(!require(TTR)) {install.packages("TTR");library(TTR)}
## Lade nötiges Paket: TTR
if(!require(MASS)) {install.packages(MASS);library(MASS)}
## Lade nötiges Paket: MASS
if(!require(quantmod)) {install.packages("quantmod");library(quantmod)}
## Lade nötiges Paket: quantmod
## Lade nötiges Paket: xts
## Lade nötiges Paket: zoo
##
## Attache Paket: 'zoo'
## Die folgenden Objekte sind maskiert von 'package:base':
##
## as.Date, as.Date.numeric
## Registered S3 method overwritten by 'quantmod':
## method from
## as.zoo.data.frame zoo
if(!require(dplyr)) {install.packages("dplyr");library(dplyr)}
## Lade nötiges Paket: dplyr
##
## ######################### Warning from 'xts' package ##########################
## # #
## # The dplyr lag() function breaks how base R's lag() function is supposed to #
## # work, which breaks lag(my_xts). Calls to lag(my_xts) that you type or #
## # source() into this session won't work correctly. #
## # #
## # Use stats::lag() to make sure you're not using dplyr::lag(), or you can add #
## # conflictRules('dplyr', exclude = 'lag') to your .Rprofile to stop #
## # dplyr from breaking base R's lag() function. #
## # #
## # Code in packages is not affected. It's protected by R's namespace mechanism #
## # Set `options(xts.warn_dplyr_breaks_lag = FALSE)` to suppress this warning. #
## # #
## ###############################################################################
##
## Attache Paket: 'dplyr'
## Die folgenden Objekte sind maskiert von 'package:xts':
##
## first, last
## Das folgende Objekt ist maskiert 'package:MASS':
##
## select
## Die folgenden Objekte sind maskiert von 'package:stats':
##
## filter, lag
## Die folgenden Objekte sind maskiert von 'package:base':
##
## intersect, setdiff, setequal, union
if(!require(moments)) {install.packages("moments");library(moments)}
# Convert columns to numeric format
fx_data$`AUSTRALIA.-.AUSTRALIAN.DOLLAR/US$` <- as.numeric(as.character(fx_data$`AUSTRALIA.-.AUSTRALIAN.DOLLAR/US$`))
fx_data$`EURO.AREA.-.EURO/US$` <- as.numeric(as.character(fx_data$`EURO.AREA.-.EURO/US$`))
fx_data$`UNITED.KINGDOM.-.UNITED.KINGDOM.POUND/US$` <- as.numeric(as.character(fx_data$`UNITED.KINGDOM.-.UNITED.KINGDOM.POUND/US$`))
fx_data$`CANADA.-.CANADIAN.DOLLAR/US$` <- as.numeric(as.character(fx_data$`CANADA.-.CANADIAN.DOLLAR/US$`))
fx_data$`JAPAN.-.YEN/US$` <- as.numeric(as.character(fx_data$`JAPAN.-.YEN/US$`))
# Calculate the Simple Moving Average (SMA) for each currency pair
SMA_AustralianDollar_US<-SMA(fx_data$`AUSTRALIA.-.AUSTRALIAN.DOLLAR/US$`, n=200)
SMA_EURO_US<-SMA(fx_data$`EURO.AREA.-.EURO/US$`, n=200)
SMA_POUND_US<-SMA(fx_data$`UNITED.KINGDOM.-.UNITED.KINGDOM.POUND/US$`, n=200)
SMA_CanadianDollar_US<-SMA(fx_data$`CANADA.-.CANADIAN.DOLLAR/US$`, n=200)
SMA_YEN_US<-SMA(fx_data$`JAPAN.-.YEN/US$`, n=200)
# Implement the Long-Position based on the SMA
Long_Position_AustralianDollar_US<-ifelse(fx_data$`AUSTRALIA.-.AUSTRALIAN.DOLLAR/US$`>SMA_AustralianDollar_US,1,0)
Long_Position_EURO_US<-ifelse(fx_data$`EURO.AREA.-.EURO/US$`>SMA_EURO_US,1,0)
Long_Position_POUND_US<-ifelse(fx_data$`UNITED.KINGDOM.-.UNITED.KINGDOM.POUND/US$`>SMA_POUND_US,1,0)
Long_Position_CanadianDollar_US<-ifelse(fx_data$`CANADA.-.CANADIAN.DOLLAR/US$`>SMA_CanadianDollar_US,1,0)
Long_Position_YEN_US<-ifelse(fx_data$`JAPAN.-.YEN/US$`>SMA_YEN_US,1,0)
# Implement the Short-Position based on the SMA
Short_Position_AustralianDollar_US<-ifelse(fx_data$`AUSTRALIA.-.AUSTRALIAN.DOLLAR/US$`<= SMA_AustralianDollar_US,1,0)
Short_Position_EURO_US<-ifelse(fx_data$`EURO.AREA.-.EURO/US$`<=SMA_EURO_US,1,0)
Short_Position_POUND_US<-ifelse(fx_data$`UNITED.KINGDOM.-.UNITED.KINGDOM.POUND/US$`<=SMA_POUND_US,1,0)
Short_Position_CanadianDollar_US<-ifelse(fx_data$`CANADA.-.CANADIAN.DOLLAR/US$`<=SMA_CanadianDollar_US,1,0)
Short_Position_YEN_US<-ifelse(fx_data$`JAPAN.-.YEN/US$`<=SMA_YEN_US,1,0)
# Calculate MACD for the currency rates
macd_signal_AustralienDollar_US<-MACD(x=fx_data$`AUSTRALIA.-.AUSTRALIAN.DOLLAR/US$`, nFast = 12, nSlow = 26, nSig = 9)
macd_signal_EURO_US<-MACD(x=fx_data$`EURO.AREA.-.EURO/US$`, nFast = 12, nSlow = 26, nSig = 9)
macd_signal_POUND_US<-MACD(x=fx_data$`UNITED.KINGDOM.-.UNITED.KINGDOM.POUND/US$`, nFast = 12, nSlow = 26, nSig = 9)
macd_signal_CanadianDollar_US<-MACD(x=fx_data$`CANADA.-.CANADIAN.DOLLAR/US$`, nFast = 12, nSlow = 26, nSig = 9)
macd_signal_YEN_US<-MACD(x=fx_data$`JAPAN.-.YEN/US$`, nFast = 12, nSlow = 26, nSig = 9)
# Set NA values to mean values
mean_value<-mean(na.omit(macd_signal_AustralienDollar_US))
macd_signal_AustralienDollar_US[is.na(macd_signal_AustralienDollar_US)]<- mean_value
mean_value<-mean(na.omit(macd_signal_EURO_US))
macd_signal_EURO_US[is.na(macd_signal_EURO_US)]<- mean_value
mean_value<-mean(na.omit(macd_signal_POUND_US))
macd_signal_POUND_US[is.na(macd_signal_POUND_US)]<- mean_value
mean_value<-mean(na.omit(macd_signal_CanadianDollar_US))
macd_signal_CanadianDollar_US[is.na(macd_signal_CanadianDollar_US)]<- mean_value
mean_value<-mean(na.omit(macd_signal_YEN_US))
macd_signal_YEN_US[is.na(macd_signal_YEN_US)]<- mean_value
# Implement investment strategy based on MACD signal
MACD_Line_AustralianDollar_US<-macd_signal_AustralienDollar_US[, "macd"]
Signal_Line_AustralianDollar_US<-macd_signal_AustralienDollar_US[, "signal"]
MACD_Line_EURO_US<-macd_signal_EURO_US[, "macd"]
Signal_Line_EURO_US<-macd_signal_EURO_US[, "signal"]
MACD_Line_POUND_US<-macd_signal_POUND_US[, "macd"]
Signal_Line_POUND_US<-macd_signal_POUND_US[, "signal"]
MACD_Line_CanadianDollar_US<-macd_signal_CanadianDollar_US[, "macd"]
Signal_Line_CanadianDollar_US<-macd_signal_CanadianDollar_US[, "signal"]
MACD_Line_YEN_US<-macd_signal_YEN_US[, "macd"]
Signal_Line_YEN_US<-macd_signal_YEN_US[, "signal"]
# Generate Buy/Sell signals based on MACD crossovers
Buy_Signal_AustralianDollar_US<-ifelse(MACD_Line_AustralianDollar_US>Signal_Line_AustralianDollar_US,1,0)
Sell_Signal_Australian_US<-ifelse(MACD_Line_AustralianDollar_US < Signal_Line_AustralianDollar_US,1,0)
Buy_Signal_EURO_US<-ifelse(MACD_Line_EURO_US>Signal_Line_EURO_US,1,0)
Sell_Signal_EURO_US<-ifelse(MACD_Line_EURO_US<Signal_Line_EURO_US,1,0)
Buy_Signal_POUND_US<-ifelse(MACD_Line_POUND_US>Signal_Line_POUND_US,1,0)
Sell_Signal_POUND_US<-ifelse(MACD_Line_POUND_US<Signal_Line_POUND_US,1,0)
Buy_Signal_CanadianDollar_US<-ifelse(MACD_Line_CanadianDollar_US>Signal_Line_CanadianDollar_US,1,0)
Sell_Signal_CanadianDollar_US<-ifelse(MACD_Line_CanadianDollar_US<Signal_Line_CanadianDollar_US,1,0)
Buy_Signal_YEN_US<-ifelse(MACD_Line_YEN_US>Signal_Line_YEN_US,1,0)
Sell_Signal_YEN_US<-ifelse(MACD_Line_YEN_US<Signal_Line_YEN_US,1,0)
# Calculate the measures for SMA strategy
# Eliminate NA´s in SMA (first 200 rows)
SMA_AustralianDollar_US<-SMA_AustralianDollar_US[-c(1:200)]
SMA_EURO_US<-SMA_EURO_US[-c(1:200)]
SMA_POUND_US<-SMA_POUND_US[-c(1:200)]
SMA_CanadianDollar_US<-SMA_CanadianDollar_US[-c(1:200)]
SMA_YEN_US<-SMA_YEN_US[-c(1:200)]
# For same length eliminate first 200 rows in fx_data
fx_data_shortened <- fx_data[201:nrow(fx_data), ]
# Calculate daily returns of each currency
Daily_Return_AustralianDollar_4 <- c(NA, diff(log(fx_data_shortened$`AUSTRALIA.-.AUSTRALIAN.DOLLAR/US$`)))
Daily_Return_EURO_4 <- c(NA, diff(log(fx_data_shortened$`EURO.AREA.-.EURO/US$`)))
Daily_Return_POUND_4 <- c(NA, diff(log(fx_data_shortened$`UNITED.KINGDOM.-.UNITED.KINGDOM.POUND/US$`)))
Daily_Return_CanadianDollar_4 <- c(NA, diff(log(fx_data_shortened$`CANADA.-.CANADIAN.DOLLAR/US$`)))
Daily_Return_YEN_4 <- c(NA, diff(log(fx_data_shortened$`JAPAN.-.YEN/US$`)))
# Calculate daily exchange rate returns based on Long and Short positions SMA
Return_AustralianDollar_SMA <- ifelse(Long_Position_AustralianDollar_US == 1, Daily_Return_AustralianDollar_4, ifelse(Short_Position_AustralianDollar_US == 0, -Daily_Return_AustralianDollar_4, 0))
Return_EURO_SMA <- ifelse(Long_Position_EURO_US == 1, Daily_Return_EURO_4, ifelse(Short_Position_EURO_US == 0, -Daily_Return_EURO_4, 0))
Return_POUND_SMA <- ifelse(Long_Position_POUND_US == 1, Daily_Return_POUND_4, ifelse(Short_Position_POUND_US == 0, -Daily_Return_POUND_4, 0))
Return_CanadianDollar_SMA <- ifelse(Long_Position_CanadianDollar_US == 1, Daily_Return_CanadianDollar_4, ifelse(Short_Position_CanadianDollar_US == 0, -Daily_Return_CanadianDollar_4, 0))
Return_YEN_SMA <- ifelse(Long_Position_YEN_US == 1, Daily_Return_YEN_4, ifelse(Short_Position_YEN_US == 0, -Daily_Return_YEN_4, 0))
# Replacement for NA values
Return_AustralianDollar_SMA <- na.locf(Return_AustralianDollar_SMA)
Return_EURO_SMA <- na.locf(Return_EURO_SMA)
Return_POUND_SMA <- na.locf(Return_POUND_SMA)
Return_CanadianDollar_SMA<-na.locf(Return_CanadianDollar_SMA)
Return_YEN_SMA <- na.locf(Return_YEN_SMA)
# Combining the return vectors for different currencies into a single matrix "SMA_returns" using "cbind()", and then assigns column names to this matrix corresponding to each currency.
SMA_returns <- cbind(Return_AustralianDollar_SMA, Return_EURO_SMA,Return_POUND_SMA,Return_CanadianDollar_SMA,Return_YEN_SMA)
SMA_returns <- cbind(Return_AustralianDollar_SMA, Return_EURO_SMA,Return_POUND_SMA,Return_CanadianDollar_SMA,Return_YEN_SMA)
# List of all the currencies
currencies <- c("AustralianDollar_SMA", "EURO_SMA", "POUND_SMA", "CanadianDollar_SMA", "YEN_SMA")
# Function: Calculating the measures for each currencies SMA-Return
calculate_measures <- function(currency) {
SMA_returns <- get(paste0("Return_", currency))
# Calculation: Return p.a. (250 trading days per year)
SMA_mean_return_pa <- mean(SMA_returns) * 250
# Calculation: Historical volatility
SMA_sd_pa <- sd(SMA_returns) * sqrt(250)
# Calculation: Skewness
SMA_skew <- skewness(SMA_returns)
# Kurtosis
SMA_kurt <- kurtosis(SMA_returns)
# Sharpe ratio with 4.25% risk-free rate
SMA_sharpe_ratio <- (SMA_mean_return_pa - 0.03) / SMA_sd_pa
# Calculation: Value-at-Risk (1 year, 3 Months, 10 Days // 95% Confidence)
SMA_var_1year <- SMA_mean_return_pa + qnorm(0.05) * SMA_sd_pa
SMA_var_3months <- SMA_mean_return_pa + qnorm(0.05) * SMA_sd_pa * sqrt(60)
SMA_var_10days <- SMA_mean_return_pa + qnorm(0.05) * SMA_sd_pa * sqrt(10)
SMA_returns <- c(SMA_mean_return_pa, SMA_sd_pa, SMA_skew, SMA_kurt, SMA_sharpe_ratio,
SMA_var_1year, SMA_var_3months, SMA_var_10days)
}
# Calculating the relevant measures for every currency
SMA_results<-t(simplify2array(lapply(currencies,calculate_measures)))
# Reviewing the dimensions of the results matrix to ensure there were no calculation mistakes
print(dim(SMA_results))
## [1] 5 8
#Generating a data frame for the results
SMA_results_df<- tibble(
SMA_mean_return_pa=SMA_results[,1],
SMA_Volatility = SMA_results[,2],
SMA_skewness = SMA_results[,3],
SMA_kurtosis = SMA_results[,4],
SMA_sharpe_ratio= SMA_results[,5],
SMA_var_1year=SMA_results[,6],
SMA_var_3months= SMA_results[,7],
SMA_var_20days=SMA_results[,8]
)
# Display the Results
print(SMA_results_df)
## # A tibble: 5 × 8
## SMA_mean_return_pa SMA_Volatility SMA_skewness SMA_kurtosis SMA_sharpe_ratio
## <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 -0.00534 0.0683 0.165 8.99 -0.517
## 2 -0.0189 0.0590 -0.154 10.0 -0.829
## 3 -0.00464 0.0669 0.496 21.4 -0.518
## 4 0.00536 0.0574 -0.0863 11.6 -0.430
## 5 0.00310 0.0643 -0.310 12.9 -0.418
## # ℹ 3 more variables: SMA_var_1year <dbl>, SMA_var_3months <dbl>,
## # SMA_var_20days <dbl>
# Calculation of measures based on MACD-strategy
# Daily returns of each currency
Daily_Return_AustralianDollar <- c(NA, diff(log(fx_data$`AUSTRALIA.-.AUSTRALIAN.DOLLAR/US$`)))
Daily_Return_EURO <- c(NA, diff(log(fx_data$`EURO.AREA.-.EURO/US$`)))
Daily_Return_POUND <- c(NA, diff(log(fx_data$`UNITED.KINGDOM.-.UNITED.KINGDOM.POUND/US$`)))
Daily_Return_CanadianDollar <- c(NA, diff(log(fx_data$`CANADA.-.CANADIAN.DOLLAR/US$`)))
Daily_Return_YEN <- c(NA, diff(log(fx_data$`JAPAN.-.YEN/US$`)))
# Daily returns based on BUY- and SELL-Signals
Return_AustralianDollar_MACD <- ifelse(Buy_Signal_AustralianDollar_US == 1, Daily_Return_AustralianDollar, ifelse(Sell_Signal_Australian_US == 0, -Daily_Return_AustralianDollar, 0))
Return_EURO_MACD <- ifelse(Buy_Signal_EURO_US == 1, Daily_Return_EURO, ifelse(Sell_Signal_EURO_US == 0, -Daily_Return_EURO, 0))
Return_POUND_MACD <- ifelse(Buy_Signal_POUND_US == 1, Daily_Return_POUND, ifelse(Sell_Signal_POUND_US == 0, -Daily_Return_POUND, 0))
Return_CanadianDollar_MACD <- ifelse(Buy_Signal_CanadianDollar_US == 1, Daily_Return_CanadianDollar, ifelse(Sell_Signal_CanadianDollar_US == 0, -Daily_Return_CanadianDollar, 0))
Return_YEN_MACD <- ifelse(Buy_Signal_YEN_US == 1, Daily_Return_YEN, ifelse(Sell_Signal_YEN_US == 0, -Daily_Return_YEN, 0))
# Combining the return vectors for different currencies into a single matrix "MACD_returns" using "cbind()", and then assigns column names to this matrix corresponding to each currency.
MACD_returns<-cbind(Return_AustralianDollar_MACD,Return_EURO_MACD,Return_POUND_MACD,Return_CanadianDollar_MACD,Return_YEN_MACD)
# Eliminate NAs
MACD_returns <- na.locf(MACD_returns)
# List of all the currencies
currencies <- c("AustralianDollar_MACD", "EURO_MACD", "POUND_MACD", "CanadianDollar_MACD", "YEN_MACD")
# Function: Calculating the measures for each currency's MACD-Return
calculate_measures <- function(currency) {
MACD_returns <- get(paste0("Return_", currency))
# Calculation: Return p.a. (250 trading days per year)
MACD_mean_return_pa <- mean(MACD_returns, na.rm = TRUE) * 250
# Calculation: Historical volatility
MACD_sd_pa <- sd(MACD_returns, na.rm = TRUE) * sqrt(250)
# Calculation: Skewness
MACD_skew <- moments::skewness(MACD_returns, na.rm = TRUE)
# Kurtosis
MACD_kurt <- moments::kurtosis(MACD_returns, na.rm = TRUE)
# Sharpe ratio with 4.25% risk-free rate
MACD_sharpe_ratio <- (MACD_mean_return_pa - 0.03) / MACD_sd_pa
# Calculation: Value-at-Risk (1 year, 3 Months, 10 Days // 95% Confidence)
MACD_var_1year <- MACD_mean_return_pa + qnorm(0.05) * MACD_sd_pa
MACD_var_3months <- MACD_mean_return_pa + qnorm(0.05) * MACD_sd_pa * sqrt(60)
MACD_var_10days <- MACD_mean_return_pa + qnorm(0.05) * MACD_sd_pa * sqrt(10)
return(c(MACD_mean_return_pa, MACD_sd_pa, MACD_skew, MACD_kurt, MACD_sharpe_ratio,
MACD_var_1year, MACD_var_3months, MACD_var_10days))
}
# Calculating the relevant measures for every currency's MAC returns
MAC_results <- t(simplify2array(lapply(currencies, calculate_measures)))
# Reviewing the dimensions of the results matrix to ensure there were no calculation mistakes
print(dim(MAC_results))
## [1] 5 8
# Generating a data frame for the results
MAC_results_df<- tibble(MAC_mean_return_pa= MAC_results[,1], MAC_Volatility=MAC_results[, 2], MAC_skewness=MAC_results[,3], MAC_kurtosis=MAC_results[,4], MAC_sharpe_ratio=MAC_results[,5], MAC_var_1year=MAC_results[,6], MAC_var_3months=MAC_results[,7], MAC_var_10days=MAC_results[,8])
# Display the results
print(MAC_results_df)
## # A tibble: 5 × 8
## MAC_mean_return_pa MAC_Volatility MAC_skewness MAC_kurtosis MAC_sharpe_ratio
## <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 0.127 0.0938 1.63 39.5 1.04
## 2 0.105 0.0657 0.710 9.15 1.15
## 3 0.109 0.0680 2.19 40.6 1.16
## 4 0.0911 0.0641 0.0730 21.8 0.953
## 5 0.104 0.0643 0.574 10.2 1.16
## # ℹ 3 more variables: MAC_var_1year <dbl>, MAC_var_3months <dbl>,
## # MAC_var_10days <dbl>