#' Print Method for Objects of Class \code{ggmix_fit}

#'

#' @description print method for objects of class \code{ggmix_fit}

#' @param x an object of class objects of class \code{ggmix_fit}

#' @param digits significant digits in printout. Default: \code{max(3,

#'   getOption("digits") - 3)}

#' @param ... other arguments passed to \code{print}

#' @seealso \code{\link{ggmix}}

#' @return The call that produced the object \code{x} is printed, followed by a

#'   three-column matrix with columns \code{Df}, \code{\%Dev}, and and

#'   \code{Lambda}. The \code{Df} columns correspond to the number of nonzero

#'   coefficients including variance components. \code{\%dev} is the percent

#'   deviance explained (relative to the null deviance). \code{Lambda} is the

#'   sequence of converged tuning parameters.

#' @export

print.ggmix_fit <- function(x, ..., digits = max(3, getOption("digits") - 3)) {

  ))

}

#' @export

#' @rdname print.ggmix_fit

print.ggmix_gic <- function(x, ..., digits = max(3, getOption("digits") - 3)) {

  ))

}

#' Make predictions from a \code{ggmix_fit} object

#'

#' @description Similar to other predict methods, this functions predicts fitted

#'   values, coefficients and more from a fitted \code{ggmix_fit} object.

#' @param object Fitted \code{ggmix_fit} model object from the

#'   \code{\link{ggmix}} function

#' @param newx matrix of values for \code{x} at which predictions are to be

#'   made. Do not include the intercept. Must be a matrix. This argument is not

#'   used for \code{type = c("coefficients","nonzero","all")}. This matrix must

#'   have the same number of columns originally supplied to the

#'   \code{\link{ggmix}} fitting function.

#' @param s Value(s) of the penalty parameter \code{lambda} at which predictions

#'   are required. Default is the entire sequence used to create the model.

#' @param type Type of prediction required. Type \code{"link"} gives the fitted

#'   values \eqn{X \beta}. Type \code{"response"} is equivalent to type

#'   \code{"link"}. Type \code{"coefficients"} computes the coefficients at the

#'   requested values for \code{s} and returns the regression coefficients only,

#'   including the intercept. Type \code{"all"} returns both the regression

#'   coefficients and variance components at the requested value of \code{s}.

#'   Type \code{"nonzero"} returns a 1 column matrix of the the nonzero fixed

#'   effects, as well as variance components for each value of \code{s}. If more

#'   than one \code{s} is provided, then \code{"nonzero"} will return a list of

#'   1 column matrices. Default: "link"

#' @param covariance covariance between test and training individuals. if there

#'   are q testing individuals and N-q training individuals, then this

#'   covariance matrix is q x (N-q)

#' @return The object returned depends on type.

#' @method predict ggmix_fit

#' @details \code{s} is the new vector at which predictions are requested. If

#'   \code{s} is not in the lambda sequence used for fitting the model, the

#'   predict function will use linear interpolation to make predictions. The new

#'   values are interpolated using a fraction of predicted values from both left

#'   and right lambda indices. \code{coef(...)} is equivalent to

#'   \code{predict(ggmix_fit, type="coefficients",...)}. To get individual level

#'   predictions at each value of lambda, you must provide the lambda sequence

#'   to the s argument. You can pass either a ggmix_fit or ggmix_gic object. See

#'   examples for more details.

#' @examples

#' data("admixed")

#' fitlmm <- ggmix(x = admixed$xtrain, y = admixed$ytrain,

#'                 kinship = admixed$kin_train,

#'                 estimation = "full")

#' bicGGMIX <- gic(fitlmm,

#'                 an = log(length(admixed$ytrain)))

#' plot(bicGGMIX)

#' coef(bicGGMIX, s = "lambda.min")

#' yhat_test <- predict(bicGGMIX, s="lambda.min",

#'                      newx = admixed$xtest, type = "individual",

#'                      covariance = admixed$kin_test_train)

#' cor(yhat_test, admixed$ytest)

#' yhat_test_population <- predict(bicGGMIX, s="lambda.min",

#'                                 newx = admixed$xtest,

#'                                 type = "response")

#' @export

predict.ggmix_fit <- function(object, newx, s = NULL,

                              type = c(

                                "link", "response", "coefficients",

                                "all", "nonzero", "individual"), covariance, ...) {

  # if you use predict on a gic_fit object, then by the time the function gets here

  # s has been converted to a numeric

    }

  }

    }

  }

  # a0 <- t(as.matrix(object[["b0"]]))

  # rownames(a0) <- "(Intercept)"

  # nbeta <- rbind(a0, object[["beta"]])

    } else {

    }

  }

    } else {

    }

  }

    # The user must not input the first column as a intercept

    # once the rotation is done on the Xs and Y, we use them for fitting the function

    # but after that we dont use the rotated Xs or Y anymore. We use the original Xs and Ys for

    # prediction, residuals, ect.

  }

        # browser()

        # see ranef.R

        )

      } else {

          # browser()

        })

      }

    } else {

    }

    # The user must not input the first column as a intercept

    # once the rotation is done on the Xs and Y, we use them for fitting the function

    # but after that we dont use the rotated Xs or Y anymore. We use the original Xs and Ys for

    # prediction, residuals, ect.

  }

}

#' @rdname predict.ggmix_fit

#' @param ... additional arguments to pass to predict function

#' @export

coef.ggmix_fit <- function(object, s = NULL, type, ...) {

  } else {

  }

}

#' @title Make predictions from a \code{ggmix_gic} object

#' @description This function makes predictions from a \code{ggmix_gic} object,

#'   using the stored "ggmix_fit" object, and the optimal value chosen for

#'   lambda using the gic.

#' @param object fitted \code{ggmix_gic} object

#' @inheritParams predict.ggmix_fit

#' @param s Value(s) of the penalty parameter \code{lambda} at which predictions

#'   are required. Default is the value \code{s="lambda.min"} can be used. If

#'   \code{s} is numeric, it is taken as the value(s) of \code{lambda} to be

#'   used.

#' @param ... other arguments passed to \code{\link{predict.ggmix_fit}}

#' @return The object returned depends the ... argument which is passed on to

#'   the predict method for \code{ggmix_fit} objects.

#' @details This function makes it easier to use the results of gic chosen model

#'   to make a prediction.

#' @rdname predict.ggmix_gic

#' @seealso \code{\link{predict.ggmix_fit}}

#' @export

predict.ggmix_gic <- function(object, newx, s = c("lambda.min"), ...) {

  } else

    }

  else {

  }

}

#' @inheritParams predict.ggmix_gic

#' @rdname predict.ggmix_gic

#' @export

coef.ggmix_gic <- function(object, s = c("lambda.min"), type, ...) {

  } else

    }

  else {

  }

  } else {

  }

}

# not used under this line ------------------------------------------------

#' @param s lamda at which to predict the random effects. current option is only

#'   "lambda.min"

#'

#' @details For objects of class "gic.ggmix", this function returns the

#'   subject-specific random effect value for the model which minimizes the GIC

#'   using the maximum a posteriori principle

#'

#' @method ranef gic.ggmix

#' @rdname ranef

# ranef.gic.ggmix <- function(object, s = "lambda.min", ...) {

#

#   # object = res

#   # s = "lambda.min"

#   # ==================

#

#   if (s == "lambda.min") {

#     ranef(object = object$ggmix.fit, s = object$lambda.min, ...)

#   } else if (is.numeric(s)) {

#

#   }

# }

#' @param s index of tuning parameter. Must be a character and an element of

#'   "s1","s2",...."s100", where "s100" is the index of the last pair of tuning

#'   parameters. Default is \code{NULL}

#' @details For objects of class "ggmix", this function returns the

#'   subject-specific random effect value for the model which minimizes the GIC

#'   using the maximum a posteriori principle

#'

#' @method ranef ggmix

#' @rdname ranef

# ranef.ggmix <- function(object, new.x, new.u, new.d, s = NULL,

#                         type = c("fitted", "predicted")) {

#

#   # object = res$ggmix.fit

#   # s = c(0.5, 0.3, 0.1)

#   # type = "link"

#   # new.x = dat$x[,1:500]

#   # new.u = U

#   # new.d = Lambda

#   # type = "fitted"

#   # s = "lambda.min"

#   # ==================

#

#   type <- match.arg(type)

#

#   if (any(missing(new.x), missing(new.u), missing(new.d))) {

#     if (!match(type, c("fitted"), FALSE)) {

#       stop("You need to supply a value for 'new.x', 'new.u' and 'new.d'")

#     }

#   }

#

#   a0 <- t(as.matrix(object$b0))

#   eta <- as.matrix(object$eta)

#   sigma2 <- as.matrix(object$sigma2)

#   rownames(a0) <- "(Intercept)"

#   rownames(eta) <- "eta"

#   rownames(sigma2) <- "sigma2"

#   nbeta <- rbind(a0, object$beta, eta, sigma2)

#

#   if (!is.null(s)) {

#     vnames <- dimnames(nbeta)[[1]]

#     dimnames(nbeta) <- list(NULL, NULL)

#     lambda <- object$lambda

#     lamlist <- lambda.interp(lambda, s)

#     if (length(s) == 1) {

#       nbeta <- nbeta[, lamlist$left, drop = FALSE] * lamlist$frac +

#         nbeta[, lamlist$right, drop = FALSE] * (1 -

#           lamlist$frac)

#     } else {

#       nbeta <- nbeta[, lamlist$left, drop = FALSE] %*%

#         diag(lamlist$frac) + nbeta[, lamlist$right,

#           drop = FALSE

#         ] %*% diag(1 - lamlist$frac)

#     }

#     dimnames(nbeta) <- list(vnames, paste(seq(along = s)))

#   }

#

#   if (type == "fitted") {

#     bis <- lapply(seq_along(s), function(i) {

#       eta_next <- nbeta["eta", i]

#       beta_next <- nbeta[c("(Intercept)", object$cov_names[-1]), i, drop = F]

#       bi(

#         eta = eta_next, beta = beta_next, eigenvalues = object$eigenvalues,

#         eigenvectors = object$u, x = object$utx, y = object$uty

#       )

#     })

#

#     bisall <- do.call(cbind, bis)

#     dim(bisall)

#     dimnames(bisall) <- list(rownames(object$x), paste(seq(along = s)))

#     return(bisall)

#   }

# }

#' @method random.effects gic.ggmix

#' @rdname ranef

# random.effects.gic.ggmix <- function(object, s = "lambda.min") {

#

#   # object = res

#   # s = "lambda.min"

#   # ==================

#

#   U <- object$ggmix.fit[["u"]]

#   estimates <- coef(object, s = s)

#   eta_next <- estimates["eta", ]

#   beta_next <- estimates[c("(Intercept)", object$ggmix.fit$cov_names[-1]), , drop = F]

#   eigenvalues <- object$ggmix.fit$eigenvalues

#

#   di <- 1 + eta_next * (eigenvalues - 1)

#   D_tilde_inv <- diag(1 / di)

#   bi <- as.vector(U %*% diag(1 / (1 / di + 1 / (eta_next * eigenvalues))) %*% t(U) %*%

#     U %*% D_tilde_inv %*% (object$ggmix.fit$uty - object$ggmix.fit$utx %*%

#       beta_next))

#   bi

# }