Problem_03_Fixing_rank_tie_method.R

#Not as data table?

outcomes.df <- fread("C:/Users/corma/OneDrive/Documents/R/Assignment3/hospitaldata/outcomes.csv",
                     header = TRUE, sep = ",", stringsAsFactors = FALSE,
                     na.strings = "Not Available", select = c(2,7,11,17,23)) %>%
      naniar::replace_with_na_all(condition = ~.x %in% "Not Available") %>% # Doing it with :: removes the need to load another package we're only going to use for one function call one time.
      as_tibble %>%
      mutate(across(3:5, as.numeric)) %>%
      mutate(across(2, as.factor)) %>%
      setnames(c("Hospital","State","Heart Attack","Heart Failure","Pneumonia"))

outcomes.df.split <- split(outcomes.df, outcomes.df$State)


class(outcomes.df)

class(iris)

class(outcomes)

outcomes <- as.data.table(fread("C:/Users/corma/OneDrive/Documents/R/Assignment3/hospitaldata/outcomes.csv",
                                header = TRUE, sep = ",", stringsAsFactors = FALSE,
                                na.strings = "Not Available", select = c(2,7,11,17,23)) %>%
                                naniar::replace_with_na_all(condition = ~.x %in% "Not Available") %>% # Doing it with :: removes the need to load another package we're only going to use for one function call one time.
                                as_tibble %>%
                                mutate(across(3:5, as.numeric)) %>%
                                mutate(across(2, as.factor)) %>%
                                setnames(c("Hospital","State","Heart Attack","Heart Failure","Pneumonia")))


rankhospital <- function(x,y,z) {
      statesub <- outcomes[State == x]
      sorted <- statesub[order(statesub, get(y)), ]
      index <- as.numeric(which(names(outcomes) == y))
      head(dplyr::select(sorted, c(1,index)),1)
}

rank(outcomes$`Heart Failure`)


#Thoughts:

# I'll have to use split by state, create a new column called rank and populate it
# for each state AND each condition, so I'll actually need 3 columns called rank
# and then rbind all that stuff back together

# Lots of lapply I think.


#Let's create a practice dataset for creating the Rank row...####
rm(list=ls())
vector1 <- sample(letters, 15, replace = TRUE)
vector2 <- sample(letters, 15, replace = TRUE)
vector1
vector2

dfletters <- data.frame(vector1, vector2)

dim(dfletters)

dfletters

dfletters[, "vector2"]

rank(dfletters$vector2)

dfletters$Rank1 <- rank(dfletters$vector1,ties.method = "min" )

dfletters

dfletters$Rank2 <- rank(dfletters$vector2, ties.method = "min")


dfletters[c("vector1", "Rank1", "vector2", "Rank2")] -> dfletters2


dfletters2

?rank

# Split Practice - NY Only ####

nyoutcomes <- as.data.table(outcomes)[outcomes$State == "NY"]

# Let's get a rank for Heart Attack and Bind It:

nyoutcomes$AttackRank <- rank(nyoutcomes$`Heart Attack`, ties.method = "min")

nyoutcomes

# Now the other two:

nyoutcomes$FailureRank <- rank(nyoutcomes$`Heart Failure`, ties.method = "min")
nyoutcomes$PneumoniaRank <- rank(nyoutcomes$Pneumonia, ties.method = "min")

# Find the best for Pneumonia:

nyoutcomes[nyoutcomes$PneumoniaRank == 1]

# 3 Hospitals have the same rate (10.0), so it should be decided alphabetically, so Albany Medical Center Hospital.

# Now to rank and bind for all 54 states ####

# Iris dataset:

iris.split <- split(iris.df, iris.df$Species)
iris.split

str(iris.split)

get.mean.of.specified.column <- function(df, column.name) {

      mean.of.given.column <- mean(df[[column.name]])

      return(mean.of.given.column)
}


sapply(X = iris.split, FUN = get.mean.of.specified.column, column.name = "Sepal.Length")

get.AttackRank <- function(df, column.name) {
      AttackRank <- rank(df[[column.name]], ties.method = "min")
      return(AttackRank)
}

sapply(X = outcomes.split, FUN = get.AttackRank, column.name = "Heart Attack")

# Stupid, screw this...
get.PneumoniaRankTable <- function(df, column.name) {
      PneumoniaRank <- rank(df[ , .(column.name = column.name)], ties.method = "min")
      return(PneumoniaRank)
}

sapply(X = outcomes.split, FUN = get.AttackRank, column.name = "Heart Attack")



# Try it for the newly created outcomes.df.split...

sapply(X = outcomes.df.split, FUN = get.PneumoniaRank, column.name = "Pneumonia")

# Bro what, it worked on my tibble? Why did it being a data table break it?

lapply(X = outcomes.split, FUN = get.PneumoniaRank, column.name = "Pneumonia")

# Let's start from the beginning without using the accursed data.table format that keeps breaking things... ####
rm(outcomes)
rm(outcomes.split)
rm(get.PneumoniaRank)
rm(outcomes.df)
rm(outcomes.df.split)
rm(AttackRanks)
rm(FailureRanks)
rm(PneumoniaRanks)
rm(rankhospital)
rm(rankhospitalfull)

outcomes <- fread("C:/Users/corma/OneDrive/Documents/R/Assignment3/hospitaldata/outcomes.csv",
                  header = TRUE, sep = ",", stringsAsFactors = FALSE,
                  na.strings = "Not Available", select = c(2,7,11,17,23)) %>%
      naniar::replace_with_na_all(condition = ~.x %in% "Not Available") %>% # Doing it with :: removes the need to load another package we're only going to use for one function call one time.
      as_tibble %>%
      mutate(across(3:5, as.numeric)) %>%
      mutate(across(2, as.factor)) %>%
      setnames(c("Hospital","State","Heart Attack","Heart Failure","Pneumonia"))

outcomes.split <- split(outcomes, outcomes$State)

get.AttackRank <- function(df, column.name) {
      AttackRank <- rank(df[[column.name]], ties.method = "min")
      return(AttackRank)
}
sapply(X = outcomes.split, FUN = get.AttackRank, column.name = "Heart Attack")

# That gives us our vectors, now to see how we can bind them back to their respective
# data frames...

# Ignore this:

# getandbind.Rank <- function(df, column.name) {
#       ColumnRank <- rank(df[[column.name]], ties.method = "min")
#       outcomes.split$OutcomeRank <- ColumnRank
# }
# PneumoniaRanks <- sapply(X = outcomes.split, FUN = getandbind.Rank, column.name = "Pneumonia")

# THIS IS THE ORIGINAL FORMULA BUT IT DOESN'T IGNORE HOSPITALS WITH NO DATA
# JUST KIDDING EASILY FIXED, ADD na.last = "keep"
rm(outcomes.split)
rm(getRank)

getRank <- function(df, column.name) {
      ColumnRank <- rank(df[[column.name]], ties.method = "first", na.last = "keep")
      ColumnRank
}

PneumoniaRanks <- sapply(X = outcomes.split, FUN = getRank, column.name = "Pneumonia")
AttackRanks <- sapply(X = outcomes.split, FUN = getRank, column.name = "Heart Attack")
FailureRanks <- sapply(X = outcomes.split, FUN = getRank, column.name = "Heart Failure")

names(outcomes.split)
names(PneumoniaRanks)
names(FailureRanks)

# EXCEPT ties.method = "min" led to errors, I have to fix it.

?rank

ranktest <- c("a","z","b","b","c","d","d","d","e","f","g")


aaaba
rank(ranktest)

rank(ranktest, ties.method = "min")
rank(ranktest, ties.method = "max")
rank(ranktest, ties.method = "average")

rank(ranktest, ties.method = "first")

rank(ranktest, ties.method = "last")

# I think what I need is "first"...?


# LET'S FIGURE OUT HOW TO GET IT TO IGNORE HOSPITALS WITH NO DATA

?rank


# Let's practice binding with one state ####

# BindRanks <- function(df, vector) {
#       df$Rank1 <-
# }



nyoutcomes <- as.data.table(outcomes)[outcomes$State == "NY"]

nyoutcomes <- as_tibble(nyoutcomes)

is.data.table(nyoutcomes)

is_tibble(nyoutcomes)

PneumoniaRankNY <- rank(nyoutcomes$Pneumonia, ties.method = "min")

nyoutcomes$PneumoniaRank <- PneumoniaRankNY

nyoutcomes

# Okay, binding worked with one state. Now let's do it using sapply for all states... ####
getRank <- function(df, column.name) {
      ColumnRank <- rank(df[[column.name]], ties.method = "min")
      ColumnRank
}

BindRanks <- function(df, vector) {
      df$Rank1 <- vector
}



sapply(X = outcomes.split, FUN = BindRanks, vector = PneumoniaRanks)

cbind(nyoutcomes, PneumoniaRankNY)

# Binding using gpt output - THIS ACTUALLY WORKED. Don't change the order of these! Run top to bottom!####

for (i in 1:length(outcomes.split)) {outcomes.split[[i]] <- cbind(outcomes.split[[i]], PneumoniaRanks[[i]])
colnames(outcomes.split[[i]])[ncol(outcomes.split[[i]])] <- "PneumoniaRank"
}

for (i in 1:length(outcomes.split)) {outcomes.split[[i]] <- cbind(outcomes.split[[i]], AttackRanks[[i]])
colnames(outcomes.split[[i]])[ncol(outcomes.split[[i]])] <- "AttackRank"
}

for (i in 1:length(outcomes.split)) {outcomes.split[[i]] <- cbind(outcomes.split[[i]], FailureRanks[[i]])
colnames(outcomes.split[[i]])[ncol(outcomes.split[[i]])] <- "FailureRank"
}

outcomes.split$AK


# Everything is read in, ranked and bound! Now to write the actual function.... ####

# First, get out statesubset...
rankhospital <- function(x) {
      statesubset <- outcomes.split[[x]]
      statesubset

}

# Index time...
rm(rankAK)

rankAK <- rankhospital("AK")
names(rankAK)
index <- as.numeric(which(names(rankAK) == "AttackRank"))

rankAK[, c(1,index)]


rankhospital <- function(x,y) {
      statesubset <- outcomes.split[[x]]
      statesubset
      index <- as.numeric(which(names(statesubset) == y))
      select(statesubset, c(1,3, index))
}

rankhospital("AK","FailureRank")

# Now to make the 2nd argument in c(1,2,3) into a variable as well...

rankhospital <- function(x,y) {
      statesubset <- outcomes.split[[x]]
      statesubset
      index <- as.numeric(which(names(statesubset) == y))
      if (index == 6) {
            rate <- 5
      } else if (index == 7) {
            rate <- 3
      } else if (index == 8) {
            rate <- 4
      }
      select(statesubset, c(1,rate, index))
}

rankhospital("AK","AttackRank")

# Whoops except I set these in the wrong order, let's fix it...

rankhospital <- function(x,y) {
      statesubset <- outcomes.split[[x]]
      statesubset
      index <- as.numeric(which(names(statesubset) == y))
      if (index == 5) {
            rank <- 6
      } else if (index == 3) {
            rank <- 7
      } else if (index == 4) {
            rank <- 8
      } else if (length(index == 0)) {
            stop("invalid outcome")
      }
      select(statesubset, c(1,rank, index))
}

## Trying to get that invalid outcome stop message to work - copy and pasting the above in case
# I mess stuff up....
rankhospital <- function(x,y) {
      statesubset <- outcomes.split[[x]]
      statesubset
      index <- as.numeric(which(names(statesubset) == y))
      if (length(index) == 0) {
            stop("invalid outcome")
      } else if (index == 5) {
            rank <- 6
      } else if (index == 3) {
            rank <- 7
      } else if (index == 4) {
            rank <- 8
      } else if (index %in% c(1, 2, 6, 7, 8)) {
            stop("invalid outcome")
      }

      select(statesubset, c(1,rank, index))
}


which(names(rankAK) == "Heart Failure")

which(names(rankAK) == "Anime")

length(which(names(rankAK) == "Heart Failure"))

length(which(names(rankAK) == "Anime"))

?stop
names(rankAK)
rankhospital("AK","Heart Failure")
rankhospital("AK","Anime Girls")
rankhospital("AK","State")

# Now we need to add the "invalid state" stop message...
rankhospitalfull <- function(x,y) {
      statesubset <- outcomes.split[[x]]
      statesubset
      statenames <- names(outcomes.split)
      if (!(x %in% statenames)){
            stop("invalid state")
      }
      index <- as.numeric(which(names(statesubset) == y))
      if (length(index) == 0) {
            stop("invalid outcome")
      } else if (index == 5) {
            rank <- 6
      } else if (index == 3) {
            rank <- 7
      } else if (index == 4) {
            rank <- 8
      } else if (index %in% c(1, 2, 6, 7, 8)) {
            stop("invalid outcome")
      }

      select(statesubset, c(1,rank, index))
}



rankhospitalfull("AK","Heart Failure")


rankhospital("AK","Anime Girls")
rankhospital("AK","State")
rankhospital("Obama","Heart Failure")

names(outcomes.split)

# Yo I figured that out fast! Now...


# MOST RECENT POINT IS THE FORMULA ABOVE ####

# To do:
# Accept a numerical input for z
# Set it so NA's for the Y results in the entire row being dropped and thus not ranked...
# Fuck I have to change outcomes.split for that to work, oh well...
# All that best, worst stuff, etc.

# Now to just finalize function variable z and I think we have it!
rankhospital <- function(x,y,z) {
      statesubset <- outcomes.split[[x]]
      statesubset
      statenames <- names(outcomes.split)
      if (!(x %in% statenames)){
            stop("invalid state")
      }
      index <- as.numeric(which(names(statesubset) == y))
      if (length(index) == 0) {
            stop("invalid outcome")
      } else if (index == 5) {
            rank <- 6
      } else if (index == 3) {
            rank <- 7
      } else if (index == 4) {
            rank <- 8
      } else if (index %in% c(1, 2, 6, 7, 8)) {
            stop("invalid outcome")
      }
      stateoutcomesubset <- select(statesubset, c(1,rank, index)) %>%
            filter(stateoutcomesubset[ , 2] == z) %>%
            select(1)
}



# Trying without the filter() function ...

rankhospital <- function(x,y,z) {
      statesubset <- outcomes.split[[x]]
      statesubset
      statenames <- names(outcomes.split)
      if (!(x %in% statenames)){
            stop("invalid state")
      }
      index <- as.numeric(which(names(statesubset) == y))
      if (length(index) == 0) {
            stop("invalid outcome")
      } else if (index == 5) {
            rank <- 6
      } else if (index == 3) {
            rank <- 7
      } else if (index == 4) {
            rank <- 8
      } else if (index %in% c(1, 2, 6, 7, 8)) {
            stop("invalid outcome")
      }
      outcome <- select(statesubset, c(1,rank, index))
      output <- outcome[outcome[,2] == z, 1]
      finaloutput <- head(output[complete.cases(output)],1)

      if (length(finaloutput) == 0) {
            print("NA")
      }
      else finaloutput
}

rankhospital("AK","Heart Failure", 1)


rankhospital("AK","Heart Failure", 2)
rankhospital("AK","Heart Failure", 3)
rankhospital("AK","Heart Failure", 4)
rankhospital("AK","Heart Failure", 5)
rankhospital("AK","Heart Failure", 6)
rankhospital("AK","Heart Failure", 7)
rankhospital("AK","Heart Failure", 8)
rankhospital("AK","Heart Failure", 9)
rankhospital("AK","Heart Failure", 10)
rankhospital("AK","Heart Failure", 11)
rankhospital("AK", "Heart Failure",9001)
rankhospital("AK","Heart Failure", -5)

test1 <- rankhospital("AK","Heart Failure", 9001)
test1
length(test1)
# DID IT! DONE!! OH EXCEPT FOR BEST OR WORST... #####
rankhospital <- function(x,y,num) {


      statesubset <- outcomes.split[[x]]
      statesubset
      statenames <- names(outcomes.split)
      if (!(x %in% statenames)){
            stop("invalid state")
      }
      index <- as.numeric(which(names(statesubset) == y))
      if (length(index) == 0) {
            stop("invalid outcome")
      } else if (index == 5) {
            rank <- 6
      } else if (index == 3) {
            rank <- 7
      } else if (index == 4) {
            rank <- 8
      } else if (index %in% c(1, 2, 6, 7, 8)) {
            stop("invalid outcome")
      }
      outcome <- select(statesubset, c(1,rank, index))
      output <- outcome[outcome[,2] == z, 1]
      finaloutput <- head(output[complete.cases(output)],1)

      if (length(finaloutput) == 0) {
            print("NA")
      }
      else finaloutput
}


rankhospital("AK","Heart Failure", 5)
rankhospital("AK","Heart Failure", 2)
rankhospital("AK","Heart Failure", -2)
rankhospital("AK","Heart Failure", 200)

rankCT <- rankhospital("CT","Heart Failure")

rankCT

rankCT[,2]

rankCT[rankCT[ ,2] == 5, ]
rankCT[rankCT[ ,2] == 5, 1]

BPT <- na.omit(rankCT[rankCT[ ,2] == 5, 1])

head(BPT)

cases <- rankhospital("AK","Heart Failure", 5)

cases

complete.cases(cases)

cases[complete.cases(cases)]


rankhospital("AK","Anime Girls")
rankhospital("AK","State")
rankhospital("Obama","Heart Failure")
rankhospital("AK","Heart Attack")
rankhospital("AK","Pneumonia")

# So the Rank is always the second column... so I can subset by the column index...?







# Just make sure it's setting rate properly...

rankhospital <- function(x,y) {
      statesubset <- outcomes.split[[x]]
      statesubset
      index <- as.numeric(which(names(statesubset) == y))
      if (index == 6) {
            rate <- 5
      } else if (index == 7) {
            rate <- 3
      } else if (index == 8) {
            rate <- 4
      }
      print(index)
      print(rate)
}
rankhospital("AK","PneumoniaRank")


# Now,find only the rows where rank = the number specified.
rankhospital <- function(x, y) {
      statesubset <- outcomes.split[[x]]
      statesubset

      if (y == "Heart Attack")
            OutcomeRank = AttackRank
      else if (y == "Heart Failure")
            OutcomeRank = FailureRank
      else if (y == "Pneumonia")
            OutcomeRank = PneumoniaRank

      OutcomeRank
}

rankhospital("AK","Heart Failure")


AKSubset$FailureRank

AKSubset %>% subset(State)


AKSubset <- outcomes.split$AK

typeof(AKSubset)

# Yo what the hell, my function works on the list of data frames, iris.split ####
sapply(X = iris.split, FUN = get.PneumoniaRank, column.name = "Sepal.Length")

dim(iris.df)
dim(outcomes)
class(iris.df)
class(outcomes)

# The function works properly if there's only one data frame...
get.PneumoniaRank(nyoutcomes, "Pneumonia")

get.PneumoniaRank(outcomes.split$CT, "Pneumonia")

# Does iris.split have a different class or type than outcomes.split?

class(iris.split)
typeof(iris.split)
is.data.frame(iris.split)
str(iris.split)

class(outcomes.split)
typeof(outcomes.split)
is.data.frame(outcomes.split)
str(outcomes.split)


outcomes.split[[]]

class(outcomes.split)


outcomes.split <- split(outcomes, outcomes$State)
str(outcomes.split)

nyoutcomes$AttackRank2 <- rank(nyoutcomes[["Heart Attack"]], ties.method = "min")

# Try to bind attack rank....

outcomes.split$AttackRank <- rank(outcomes.split$`Heart Attack`, ties.method = "min")

# Or Pneumonia

outcomes.split$PneumoniaRank <- rank(outcomes.split$, ties.method = "min")