zc.modules = function(interactions, members)
  
{
  #########################################################################################
  ##### Criando um data.frame que contem uma lista das interacoes das especies da rede ####
  ##### e o modulo em que se encontram. ###################################################
  #########################################################################################
  
  colnames(interactions)=c("spp.row","spp.col")
  
  # Ordenando a tabela, isso sera necessario quando fizermos o ciclo
  interactions = interactions[order(interactions$spp.col),]
  
  colnames(members)=c("spp", "module")
  
  # Ordenamos a outra tabela
  members = members[order(members$spp),]
  
  n.col = length(interactions$spp.col)  # Comprimento da tabela
  results.col = rep(NA, n.col) # Vetor de NAs para colocarmos os resultados do ciclo
  
  for (i in 1 : n.col)
    
  {
    # O modulo da especie i da tabela members. Este i eh o primeiro level do fator spp
    module.col = members$module[members$spp[i]] 
    
    # Primeiro fazemos um teste logico com a tabela interactions, que coloca TRUE  
    # nas posicoes que contem o level i do fator spp.col. Depois pegamos somente as posicoes
    # em que temos TRUE (com which) e colocamos o modulo dessa especie nessas posicoes.
    results.col[(which((interactions$spp.col)==levels(interactions$spp.col)[i]))] = module.col  
    
  }
  
  # Agora fazemos a mesma coisa com o fator spp.row, que contem os levels Ri
  n.row = length(interactions$spp.row)
  results.row = rep(NA, n.row)
  
  for (i in 1: n.row)
    
  {
    # Para fazer essa indexacao somamos o comprimento dos levels da tabela interactions 
    # a i. Como a tabela members esta ordenada, comecamos a atribuir o modulo a module.row 
    # a partir do primeiro Ri.
    module.row = members$module[members$spp[i + length(levels(interactions$spp.col))]] 
    
    # Aqui criamos o vetor module.row da mesma forma que criamos results.col
    results.row[(which((interactions$spp.row)==levels(interactions$spp.row)[i]))] = module.row
    
  }
  
  # Criamos um data.frame com os resultados
  results = data.frame(interactions, results.row, results.col)
  
  
  ######################################################################################
  ################################# Calculando z e c ###################################
  ######################################################################################
  
  
  ################################## Calculo do z ######################################
  
  
  #### Calculando kis, numero de interacoes de cada especie i dentro do seu modulo ####
  
  levels.col = length(levels(interactions$spp.col)) # Numero de especies em interacions$spp.col
  kis.col = rep(NA, levels.col)
  modules.col = rep(NA, levels.col)
  
  for (i in 1 : levels.col)
  {
    
    modules.col[i] = members$module[members$spp[i]] # Modulo da primeira especie (Ci) 
    
    # Soma de quantas interacoes a especie i possuem dentro do seu modulo
    kis.col[i] = sum((results$spp.col == levels(results$spp.col)[i]) & (results$results.row == modules.col[i] & results$results.col == modules.col[i]))
    
  }
  
  kis.col # Vetor com os valores de kis para cada Ci
  modules.col # Vetor com os modulos de cada um dos Ci do vetor kis.col
  
  ###### Calculando kis para os Ri ######
  
  levels.row = length(levels(interactions$spp.row))
  kis.row = rep(NA, levels.row)
  modules.row = rep(NA, levels.row)
  
  for (i in 1 : levels.row)
  {
    # Modulo da primeira especie Ri
    modules.row[i] = members$module[members$spp[i + length(levels(interactions$spp.col))]]
    
    # Criamos o vetor kis.row da mesma forma que criamos kis.col
    kis.row[i] = sum((results$spp.row == levels(results$spp.row)[i]) & (results$results.row == modules.row[i] & results$results.col == modules.row[i]))
    
  }
  
  kis.row # Vetor com os valores de kis para cada Ri
  modules.row # Vetor com os modulos de cada um dos Ri do vetor kis.r
  
  
  #### Fazendo um ciclo que percorra todos os modulos e para cada um calcular ks e SDks ####
  
  n.modules = rep(NA, length(unique(members$module)))
  
  # Criamos um vetor que tenha em cada posicao o numero de especies do modulo
  # que so tem interacoes dentro do modulo
  for (i in min(members$module) : max(members$module))
  {
    n.modules[i + 1] = length(c(kis.col[modules.col == i], kis.row[modules.row == i]))
    
  }
  
  ##### Calculando o z de cada especie e colocando os valores em um vetor #####
  z.list = list()
  
  for (i in min(members$module) : max(members$module))
  {
    
    ks.mean = mean(c(kis.col[modules.col == i], kis.row[modules.row == i]))
    ks.sd = sd(c(kis.col[modules.col == i], kis.row[modules.row == i]))
    
    z.list[[i + 1]] = (c(kis.col[modules.col == i], kis.row[modules.row == i]) - ks.mean) / ks.sd
    
  }
  
  # Cada posicao da lista kis.list contem os valores de z das especies de um modulo,
  # concatenamos esses valores em um unico vetor
  z.vetor = c()
  
  for (i in 1 : length(z.list))
  {
    z.vetor = c(z.vetor, z.list[[i]])
  }
  
  ###### Criando uma tabela final que contem as especies e os respectivos valores de z ######
  
  # Precisamos criar uma lista que contenha, em cada posicao, vetores com as especies
  # (Ci e Ri) que possuem interacoes dentro de um modulo. A lista tera o mesmo numero
  # de posicoes que o numero de modulos. Precisamos fazer isso para parear essas especies
  # com os valores de z calculados.
  spp.list = list()
  
  for (i in min(members$module) : max(members$module))
  {
    spp.list[[i + 1]] = members$spp[members$module == i, drop = T]
  }
  
  spp.vetor = c()
  
  for (i in 1 : length(spp.list))
  {
    spp.vetor = c(spp.vetor, levels(spp.list[[i]]))
  }
  
  z.vetor = round(z.vetor, 3)
  
  # Guardamos os resultados de z pareados com as especies correspondentes em um data.frame
  results.z = data.frame(spp.vetor, z.vetor)
  colnames(results.z) = c("spp","z")
  
  # Ordenamos as especies
  results.z[order(results.z$spp),]
  
  
  ################################## Calculo do c #####################################
  
  ##### Criando um vetor que contem o numero de interacoes total (k) de cada especie da rede #####
  
  k.spp = rep(NA, length(members$spp))
  
  # Primeiro colocamos no vetor os valores para as especies Ci
  for (i in 1 : length(levels(results$spp.col)))
  {
    k.spp[i] = sum(results$spp.col == levels(results$spp.col)[i])
  }
  
  # Agora preenchemos o resto com os valores para as especies Ri
  for (i in 1 : length(levels(results$spp.row)))
  {
    k.spp[i + length(levels(results$spp.col))] = sum(results$spp.row == levels(results$spp.row)[i])
  }
  
  ##### Fazer uma lista (kit.list) que contenha os valores de Kit de cada especie em cada posicao #####
  
  # Esse vetor tera em cada posicao o numero de interacoes que a especie realiza com o 
  # modulo (uma posicao para cada modulo)
  sum.kit = rep(NA, length(unique((members$module))))
  
  kit.list = list()
  
  # Os valores de m percorrem todas as especies Ci. Para cada uma delas, criamos o vetor
  # sum.kit que contem os valores de Kit daquela especie para cada modulo. Colocamos
  # o vetor de cada especie em uma posicao da lista kit.list
  for (m in 1 : length(levels(results$spp.col)))
  { 
    
    for (i in min(members$module) : max(members$module))
    {
      sum.kit[i + 1] = sum(results$spp.col == levels(results$spp.col)[m] & results$results.row == i) 
    }
    
    kit.list[[m]] = sum.kit 
    
  }
  
  # Agora colocamos na lista kit.list os vetores sum.kit das especies Ri
  for (m in 1 : length(levels(results$spp.row)))
  {
    
    for (i in min(members$module) : max(members$module))
    {
      sum.kit[i + 1] = sum(results$spp.row == levels(results$spp.row)[m] & results$results.col == i)
    }
    
    kit.list[[m +  length(levels(results$spp.col))]] = sum.kit
    
  }
  
  
  ####### Usando o vetor k.spp e a lista kit.list, calculamos o c de cada especie ########
  
  results.c = rep(NA, length(members$spp))
  
  for (i in 1 : length(members$spp))
  {
    results.c[i] = 1 - sum((kit.list[[i]]/k.spp[i])^2) # Formula para calcular o c
  }
  
  results.c = round(results.c, 3)
  results.c = data.frame(members$spp, results.c)
  colnames(results.c) = c("spp","c")
  
  
  ################ Colocando os valores de z e c em uma mesma tabela ################
  
  members.z.c = data.frame(members, results.z$z, results.c$c)
  colnames(members.z.c) = c("spp", "module", "z", "c")
  
  colnames(results) = c("spp.row", "spp.col", "module.row", "module.col")
  
  results.final = list(results, members.z.c)
  
}