make_gram <- function(Xcolnames){
  library(gramEvol)
  ruleDef <- list(
    
    res = grule(t(as.data.frame(multi.expr))),
    
    multi.expr = grule( c(single.expr, single.expr, single.expr,
                          single.expr, single.expr, single.expr)),
    
    single.expr = grule(list(r=c( go_rules   = as.character(expression(Expr)),
                                  stop_rules = as.character(expression(Expr))))),
    
    
    Expr     = grule(expr, expr & expr ),
    
    expr     = grule(logy_op(one_var,one_var) ),
    one_var  = gsrule('X[<id>,<var_name>]'),
    
    id       = grule(i,numb,i+numb),
    numb     = gvrule(1:10),
    var_name = gvrule(Xcolnames),
    logy_op  = grule(">","<"))
  
  grammarDef <- CreateGrammar(ruleDef)
  #gr <- GrammarRandomExpression(grammarDef, 1)
  return(grammarDef)}

# Функция make_gram принимает на вход имена признаков , создает граматику которая 
# устанавливаеться пользователем и на выходе получаем граматику которая будет 
# преобразована в выражение, в этом случаи правила
# 
# 
# feature_names <- c("open","high","low","close")
# 
# my_gram <- make_gram(feature_names)
# 
# rand_expr <- gramEvol::GrammarRandomExpression(my_gram)   
# 
# as.data.frame( eval(rand_expr) )








seq_rules <- function(mat_X, Go_rules , Stop_rules){
  if(nrow(mat_X)<20) stop("mat_dat должна иметь строк >=20") 
  res <- FALSE
  steps <- 0
  sum_go_rules <- 0
  sum_stop_rules <- 0
  
  
  m_debug <- matrix(ncol = 2,nrow = nrow(mat_X)) ; colnames(m_debug) <- c("GO_rule","STOP_rule")
  len_rules <- length(Go_rules)
  n <- 1
  
  
  for(i in 1:(nrow(mat_X)-10)){
    steps <- i
    Go_rule <- eval(str2expression(Go_rules[n]))
    Stop_rule <- eval(str2expression(Stop_rules[n]))
    
    if(Stop_rule){
      sum_stop_rules <- sum_stop_rules+1
      m_debug[i,"STOP_rule"] <- Stop_rules[n]
      break
    }
    
    if(Go_rule){
      sum_go_rules <- sum_go_rules+1
      m_debug[i,"GO_rule"] <- Go_rules[n]
      n <- n+1
      if(n>len_rules) {res <- TRUE ; break}
    }
    
    if(n>len_rules) break
  }
  
  
  result <- list(res = res,
                 steps = steps,
                 sum_stop_rules = sum_stop_rules,
                 sum_go_rules = sum_go_rules,
                 mat_debug = m_debug)
  return(result)}



# Фунция seq_rules принимает ОДИН кадр данных в виде матрицы,
# матрица должна иметь имя "Х" , и должна иметь те же имена признаков
# которые были заявлены для функции make_gram.
# Фунция seq_rules проходит по матрице "Х" и проверяет выполнилась ли 
# последовательность из правил которые были созданы из граматики.
# функуия возвращает логическую переменную "res" что означает 
# выполнилось последовательность из правил или нет, также
# seq_rules возвразает еще несколько переменных которые могут быть
# полезны для создания фитнес функции в будущем
# set.seed(39)
# 
# X <- round(matrix(rnorm(100),ncol = 4),2)
# colnames(X) <- c("open","high","low","close")
# 
# my_gram <- make_gram(colnames(X))
# rand_expr <- gramEvol::GrammarRandomExpression(my_gram)  
# 
# rule <- eval(rand_expr)
# 
#       seq_rules(mat_X = X , 
#              Go_rules = rule[,"go_rules"] , 
#            Stop_rules = rule[,"stop_rules"])