############################################################################
#                                                                          #
# Μία πρώτη επαφή με μεταβλητές, διανύσματα, λίστες και συναρτήσεις στην R #
#                                                                          #
############################################################################




# Χρήση μεταβλητών για την αποθήκευση τιμών. 
# ΚΑΛΗ ΠΡΑΚΤΙΚΗ: Επιλέγεται όνομα μεταβλητής που υποδηλώνει τη σημασία της.


# Μεταβλητή με όνομα studentAge που της δίνεται τιμή ένας ακέραιος. 
# Τελεστής <- : τελεστής ανάθεσης τιμής
studentAge <- 15

# Ανάθεση τιμής τύπου συμβολοσειράς (character/string) σε μεταβλητή. Τιμές συμβολοσειρών μπαίνουν πάντα 
# σε double quotes " "
directorName <- "Michael Mann"

# Εμφάνιση τιμής μεταβλητής στην οθόνη
directorName

print( studentAge )



######################################################################################
#                                                                                    #
# Διανύσματα (vectors) στην R                                                        #
#                                                                                    # 
######################################################################################




#
# Μεταβλητή aVector που είναι διάνυσμα και περιέχει αριθμητικές τιμές. 
# Χρήση του τελεστή c() της R για 
# τη δημιουργία διανύσματος και αποθήκευσή του στη μεταβλητή aVector
#

aVector <- c(9, -21, 33, -4, 0.4)

# CAVEAT LECTOR! Διανύσματα δέχονται τιμές ΜΟΝΟ του ίδιου τύπου. Στο παρακάτω διάνυσμα anotherVector
# έχουμε τιμές ακέραιες π.χ. 1 και -2 αλλά και συμβολοσειρές "hello". Επειδή όμως τα διανύσματα
# δέχονται ΜΟΝΟ τιμές του ίδιου τύπου, οι τιμές 1 και -2 θα ερμηνευτούν από την R  όχι ως αριθμοί 
# αλλά ως συμβολοσειρές!

anotherVector <- c(1, "hello", -2)

# Στην παρακάτω εκτύπωση προσέξτε τα doublequotes γύρω από τις τιμές -1 κα 2
print(anotherVector)

# Αναφορά στα στοιχεία του διανύσματος με τον τελεστή []. Αναφορά/προσπέλαση
# 2ου στοιχείου του διανύσματος aVector.
# NOTE: Η πρώτη τιμή του διανύσματος είναι στη θέση 1 δλδ aVector[1]

second_number_in_vector <- aVector[2]

# Εμφάνιση τιμής μεταβλητής με τη συνάρτηση print
print(second_number_in_vector)


# Μπορούμε να δούμε τον τύπο των δεδομένων που διατηρεί ένα διάνυσμα (και οποιαδήποτε μεταβλητή)
# με χρήση της class

# Βγάζει numeric δλδ τα στοιχεία του διανύσματος aVector είναι αριθμοί.
class(aVector)

# Εμφανίζει character δλδ τα στοιχεία του διανύσματος anotherVector είναι συμβολοσειρές
class(anotherVector)


# Συνάρτηση length() της R: επιστρέφει το πλήθος των στοιχείων ενός διανύσματος.
numValues<-length(aVector)

# Θα εμφανιστεί 5
numValues



######################################################################################
#                                                                                    #
# Λίστες (Lists) στην R                                                              #
#                                                                                    # 
######################################################################################


# Μεταβλητή aList που είναι τύπου λίστα (list). Οι λίστες μπορούν να έχουν στοιχεία οποιουδήποτε 
# τύπου. Π.χ. η λίστα aList περιέχει αριθμούς (3,4 και 9.3) συμβολοσειρές (hello, Yoshi),
# διάνυσμα ( c (1,2,-29.87) ) και λογικές τιμές (TRUE)

aList = list(3, 4, "hello", c(1,2,-29,87), "Yoshi", TRUE, 9.3)

#
# Υπάρχουν δύο τελεστές που επιτρέπουν αναφορά στα στοιχεία μιας λίστας: ο τελεστής [] και 
# ο τελεστής [[]]] . Δέχονται ως όρισμα ακέραιο που δηλώνει τη θέση του στοιχείου που θέλουμε.
# lst[i] -> επιστρέφει το στοιχείο i της λίστας lst και αυτό που επιστρέφει είναι τύπου λίστα
# lst[[i]] -> επιστρέφει το στοιχείο i της λίστας lst και αυτό που επιστρέφει είναι του ίδιου τύπου
# με το στοιχείο της λίστας
#

# Έκτο στοιχείο της λίστας. Ο τύπος της επιστρεφόμενης τιμής είναι λίστα
aList[6]

# Εμφανίζει list
class(aList[6])


# Έκτο στοιχείο της λίστας. Ο τύπος της επιστρεφόμενης τιμής είναι logical
aList[[6]]

# Εμφανίζει logical, τον τύπο της 6ης μεταβλητής
class(aList[[6]])


# Μπορούν να δοθούν και ονόματα στα στοιχεία μιας λίστας. 
anotherList = list(name="Michael Bay", age=51, nationality="American", AvgMovieRating=4.2)

# Αναφορά στις τιμές μιας λίστας μπορεί να γίνει και μέσω των ονομάτων με διάφορους τρόπους

# Τελεστής $
print( anotherList$name )
print( anotherList$AvgMovieRating )

# Τελεστμής [] και χρήση ονόματος
anotherList["name"]

# Τελεστής [[]] και χρήση ονόματος
anotherList[["name"]]


# Πρόσθεση στοιχείων σε υπάρχουσα λίστα. 

# Πρόσθεση νέου στοιχείου Address="San Fransisco" στην υπάρχουσα λίστα anotherList με συνένωση
# λιστών.
anotherList<-c( anotherList, c(Address="San Fransisco") )

# Θα εμφανιστεί στο τέλος η τιμή "San Fransisco"
anotherList

# Ενναλλακτικός τρόπος πρόσθεσης νέας τιμής στη λίστα anotherList
anotherList<-c( anotherList, 100000000 )
anotherList



######################################################################################
#                                                                                    #
# Συναρτήσεις στην R (functions)                                                     #
#                                                                                    # 
######################################################################################




#
# Συναρτήσεις στην R: συναρτήσεις που δίνονται από την  R
#
# Η R διαθέτει πληθώρα συναρτήσεων που υπολογίζουν (σχεδόν) ο,τιδήποτε.
#

# Παράδειγμα, υπολογισμός αριθμητικού μέσου όρου τιμών διανύσματος 

# δημιουργία διανύσματος
someData <- c(1,2,3,4,5,6,7,8,9,10)

# χρήση της συνάρτησης mean που μας δίνεται από την  R
mean(someData)

# το αποτέλεσμα της συνάρτησης mean μπορεί να ανατεθεί σε άλλη μεταβλητή. Π.χ.
vectorMean <- mean(someData)
print(vectorMean)

# Υπολογισμός διακύμανσης, χρήση έτοιμης συνάρτησης var()
vectorVar <- var(someData)
print(vectorVar)


# Υπολογισμός τυπικής απόκλισης, χρήση έτοιμης συνάρτησης sd()

vectorStdev <- sd(someData)
print(vectorStdev)




#
# Συναρτήσεις στην R
#
# Μπορείτε να φτιάξετε δικές σας συναρτήσεις που υπολογίζουν ο,τιδήποτε εσείς θελήσετε και να 
# τις χρησιμοποιήσετε όπως τις συναρτήσεις που παρέχει η R. 
#
#


# Παράδειγμα ορισμού συνάρτησης με όνομα mySum, η οποία υπολογίζει το άθροισμα των ορισμάτων της και επιστρέφει 
# το αποτέλεσμα
#

mySum <- function(a, b) {
  # Έναρξη σώματος της συνάρτησης. 
  c <- a + b
  
  #Εμφανίζει στην οθόνη το αποτέλεσμα
  print( c )
} # Εδώ τερματίζει ο ορισμός της συνάρτησης mySum

# Κλήση συνάρτησης mySum που έχει οριστεί παραπάνω
mySum(1,33)



# Ορισμός συνάρτησης quadRoot η οποία υπολογίζει τις πραγματικές ρίζες της δευτεροβάθμιας εξίσωσης:
#      ax^2+bx+c = 0
# Η συνάρτηση quadRoot δέχεται ως όρισμα 3 τιμές -τους συντελεστές a,b,c- και θα 
# επιστρέφει μία λίστα που περιέχει τα εξής:
# 1) Ένα μήνυμα
# 2) Τίς ρίζες της εξίσωσης, αν αυτές υπάρχουν
#
# Καλείται με τον εξής τρόπο: quadRoot(a, b, c)



quadRoot <- function( a, b, c ) {
  
  # Έναρξη σώματος της συνάρτησης. 
  # Δλδ τα βήματα που εκτελεί η συνάρτηση για να παράξει το αποτέλεσμα που
  # ζητάμε.
  
  # Έλεγχος αν a είναι 0. Αν είναι τότε δεν πρόκειται για δευτεροβάθμια εξίσωση.
  # Χρήση if (<συνθήκη>){ ... } . 
  # Σημ: ο τελεστής == είναι ο τελεστής ελέγχου ισότητας
  if (a == 0) {
    return( list(status="No quadratic polynomial") )
  }
  
  # Υπολογισμός διακρίνουσας. Απ'αυτήν εξαρτώνται όλα!
  d = b^2 - 4*a*c
  
  # Εντολή φορμαρισμένης εξόδου. Όταν θέλουμε να εμφανίσουμε μηνύματα και τιμές μεταβλητών 
  # μορφοποιημένες με συγκεκριμένο τρόπο.
  # Εδώ για παράδειγμα θέλουμε απλά να δείξουμε την τιμή της διακρίνουσας ώστε να δούμε αν όλα
  # πάνε καλά.
  cat( sprintf("Variable d is %f", d) )
  
  # Διακρίνουσα αρνητική?
  if ( d < 0 ) {
    # Ναι, αρνητική. Δεν υπάρχουν πραγματικές λύσεις.
    # Σημείωση: Μετά την εκτέλεση της return, η συνάρτηση τερματίζει την εκτέλεσή της.
    # Δλδ δεν συνεχίζει την εκτέλεση εντολών από εκεί και κάτω.
    return( list(status="No real roots for this polynomial") )
  }
  
  # Διακρίνουσα δεν είναι αρνητική. Είναι μηδέν?
  if ( d == 0 ) {
    # Ναι είναι μηδέν. Έχουμε μία διπλή ρίζα.
    
    # Φτιάξε μία λίστα όπου θα μπουν τα αποτελέσματα. Πρώτα, βάλε στη λίστα ένα μήνυμα
    sol<-list(status="One double solution")
    
    # Υπολόγισε τη διπλή ρίζα
    roots12 = -b/(2*a)
    
    # Βάλε τη ρίζα στην υπάρχουσα λίστα sol
    sol<-c(sol, c(roots=roots12) )
    
    # Επέστρεψε τη λίστα που περιέχει το μήνυμα και τις ρίζες στο σημείο που κλήθηκε η συνάρτηση
    return(sol)
  }
  
  # Διακρίνουσα ούτε αρνητική, ούτε μηδέν. Αυτό μόνο ένα πράγμα μπορεί να σημαίνει: 
  # είναι > 0 και συνεπώς υπάρχουν δύο πραγματικές ρίζες. Αυτές θα υπολογιστούν παρακάτω.
  
  # Φτιάξε τη λίστα sol όπου θα αποθηκευτούν το μήνυμα και οι ρίζες
  sol <- list(status="2 roots")
  
  # Υπολόγισε τις 2 ρίζες
  r1 <- (-b+sqrt(d))/ (2*a)
  r2 <- (-b-sqrt(d))/ (2*a)
  
  # Πρόσθεσε τις ρίζες στη λίστα sol
  sol<-c(sol, c(root1=r1, root2=r2))
  
  #...και επέστρεψε τη λίστα sol
  return(sol)
  
} # Εδώ τερματίζει ο ορισμός της συνάρτησης quadRoot


# Κλήση της συνάρτησης quadRoot που ορσίστηκε παραπάνω. Η συνάρτηση quadRoot θα εκτελεστεί με 
# ορίσματα: a=-1, b=2 και c=1 . βρίσκει δλδ τις ρίζες της εξίσωσης
# -x^2 + 2x + 1 = 0
# Η τιμή που επιστρέφεται είναι λίστα και αποθηκεύεται στη μεταβλητή solution
solution <- quadRoot(-1,2,1)

# Εμφανίζει μόνο το μήνυμα
solution$status

# Εμφανίζει ολόκληρη τη λίστα
solution


# Συνάρτηση vecDuplicate: δέχεται ως όρισμα ένα διάνυσμα origVec και επιστρέφει νέο διάνυσμα
# με ακριβώς τα ίδια στοιχεία με αυτό που δίνεται ως όρισμα. Δλδ κάνει  αντίγραφο 
# ενός διανύσματος.


# origVec: διάνυσμα που θέλουμε να αντιγράψουμε.
vecDuplicate <- function(origVec) {
  
  # Δημιουργία κενού/άδειου διανύσματος. Στο duplicate θα αντιγραφούν οι τιμές του διανύσματος
  # origVec.
  duplicate <- c()  
  
  # Χρήση επανάληψης for: σαρώνουμε όλες τις τιμές του διανύσματος origVec και 
  # αντιγράφουμε/προσθέτουμε κάθα μία τιμή του διανύσματος origVec που συναντάμε στο διάνυσμα duplicate.
  # ΣΗΜ: η συνάρτηση length μας δίνει το μήκος του διανύσματος που δίνεται ως όρισμα. Δλδ το πλήθος
  # των στοιχείων που περιέχει.
  for (i in 1:length(origVec) ) {
    
    # Ένας τρόπος για να κάνεις την αναφορά και αντιγραφή από το origVec στο duplicate.
    duplicate[i] <- origVec[i]
    
    #υπάρχουν και άλλοι τρόποι όπως π.χ. ο παρακάτω που συνενώνει διανύσματα:
    #duplicate <- c( duplicate, origVec[i])
    
  }
  
  # Επέστρεψε το διάνυσμα duplicate που τώρα έχει τα ίδια στοιχεία με το διάνυσμα origVec.
  return(duplicate)
  
} # Τέλος ορισμού συνάρτησης vecDuplicate



#κλήση συνάρτησης vecDuplicate. Πρώτα φτιάξε ένα νέο διάνυσμα με κάποια στοιχεία:
vec1 <- c(-1,9,0,-23,-8,6,98,-124, 9, 31, -7)

# Κάλεσε τη συνάρτηση vecDuplicate και δώσε ως όρισμα το διάνυσμα που θέλουμε να αντιγράψουμε.
dupVec1 <- vecDuplicate(vec1)

#Τώρα, vec1 Και dupVec1 έχουν τα ίδια ακριβώς στοιχεία.
# Υπάρχουν διάφοροι τρόποι να το εξετάσουμε αυτό (αν δλδ έχουν τα ίδια στοιχεία).
# Ένας τρόπος είναι ο εξής:
vec1 == dupVec1