Comment ignorer une erreur dans une boucle

Je veux passer un message d'erreur (si elles existent) dans une boucle et continuer à la prochaine itération. Je veux calculer 100 inverse des matrices de un 2 par 2 de la matrice avec des éléments choisis au hasard à partir de {0, 1, 2}. Il est possible d'avoir une matrice singulière (par exemple, 

1 0
2 0

Voici mon code

set.seed(1)
count <- 1
inverses <- vector(mode = "list", 100)
repeat {
    x <- matrix(sample(0:2, 4, replace = T), 2, 2)
    inverses[[count]] <- solve(x)
    count <- count + 1
    if (count > 100) break
}

À la troisième itération, la matrice est singulière et le code s'arrête avec un message d'erreur. Dans la pratique, je voudrais d'ignorer cette erreur et de continuer à la prochaine boucle. Je sais que j'ai besoin d'utiliser un try ou tryCatch fonction mais je ne sais pas comment les utiliser. Des questions similaires ont été posées ici, mais ils sont tous vraiment compliqué, et les réponses sont bien au-delà de ma compréhension. Si quelqu'un peut me donner un code complet spécifiquement pour cette question, je l'apprécie vraiment.

InformationsquelleAutor Patrick Li | 2012-12-27
  1. 29

    Ce serait NULLs en inverses pour le singulier matrices:

    inverses[[count]] <- tryCatch(solve(x), error=function(e) NULL)

    Si la première expression dans un appel à tryCatch génère une erreur, il s'exécute et renvoie la valeur de la fonction fourni à ses error argument. La fonction fournie à l' error arg doit prendre l'erreur elle-même comme un argument (ici je l'appelle e), mais vous n'avez pas à faire quelque chose avec elle.

    Vous pouvez ensuite déposer la NULL entrées avec inverses[! is.null(inverses)].

    Sinon, vous pouvez utiliser le niveau inférieur try. Le choix est vraiment une question de goût.

    count <- 0
repeat {
    if (count == 100) break
    count <- count + 1
    x <- matrix(sample(0:2, 4, replace = T), 2, 2)
    x.inv <- try(solve(x), silent=TRUE)
    if ('try-error' %in% class(x.inv)) next
    else inverses[[count]] <- x.inv
}

    Si votre expression génère une erreur, try renvoie un objet de classe try-error. Il affiche le message à l'écran si silent=FALSE. Dans ce cas, si x.inv a classe try-error, nous appelons next pour arrêter l'exécution de l'itération en cours et passer à la suivante, autrement nous ajouter x.inv à inverses.

    Edit:

    Vous pourriez éviter d'utiliser le repeat boucle avec replicate et lapply.

    matrices <- replicate(100, matrix(sample(0:2, 4, replace=T), 2, 2), simplify=FALSE)
inverses <- lapply(matrices, function(mat) if (det(mat) != 0) solve(mat))

    Il est intéressant de noter que le deuxième argument de replicate est traité comme un expression, sens, il est exécuté à nouveau pour chaque répétition. Cela signifie que vous pouvez utiliser replicate de faire un list de n'importe quel nombre d'objets aléatoires sont générés à partir de la même expression.

    • Je vous remercie beaucoup.
    InformationsquelleAutor Matthew Plourde
  2. 9

    Au lieu d'utiliser tryCatch, il vous suffit de calculer le déterminant de la matrice avec la fonction det. Une matrice est inversible si et seulement si le déterminant est nul.

    Par conséquent, vous pouvez tester si le déterminant est différent de zéro et calculer l'inverse que si le test est positif:

    set.seed(1)
count <- 1
inverses <- vector(mode = "list", 100)
repeat {
  x <- matrix(sample(0:2, 4, replace = T), 2, 2)
  # if (det(x)) inverses[[count]] <- solve(x)
  # a more robust replacement for the above line (see comment):
  if (is.finite(determinant(x)$modulus)) inverses[[count]] <- solve(x)
  count <- count + 1
  if (count > 100) break
}

    Mise à jour:

    Il est, cependant, possible d'éviter de générer de singulières de matrices. Le déterminant d'une 2-par-2 matrice mat est défini comme mat[1] * mat[4] - mat[3] * mat[2]. Vous pouvez utiliser cette connaissance pour l'échantillonnage aléatoire des nombres. Il suffit de ne pas le nombre d'échantillons qui va produire une matrice singulière. Bien entendu, cela dépend du nombre échantillonné avant.

    set.seed(1)
count <- 1
inverses <- vector(mode = "list", 100)

set <- 0:2 # the set of numbers to sample from

repeat {

  # sample the first value
  x <- sample(set, 1)
  # if the first value is zero, the second and third one are not allowed to be zero.
  new_set <- ifelse(x == 0, setdiff(set, 0), set)
  # sample the second and third value
  x <- c(x, sample(new_set, 2, replace = T))
  # calculate which 4th number would result in a singular matrix
  not_allowed <- abs(-x[3] * x[2] / x[1])
  # remove this number from the set
  new_set <- setdiff(0:2, not_allowed)
  # sample the fourth value and build the matrix
  x <- matrix(c(x, sample(new_set, 1)), 2, 2)

  inverses[[count]] <- solve(x)
  count <- count + 1
  if (count > 100) break
}

    Cette procédure est de garantir que toutes les matrices générées auront l'inverse.

    • +1, j'étais juste sur le point d'ajouter ce.
    • Dans certains cas, une matrice de déterminant zéro (ou très proche de zéro si la matrice est grand) peuvent avoir une matrice inverse. Par exemple, A <- diag(rep(0.000000000001,1000)) det(A). Mais A est inversible.
    • J'ai effectivement fait ce simple exemple. Le vrai problème est beaucoup plus compliqué, mais il implique également de prendre l'inverse d'une matrice de grosse et parfois solve me donne des messages d'erreur. Il n'est pas possible de suivre votre mise à jour pour obtenir une matrice non singulière.
    • Si la matrice est inversible, son déterminant doit être différent de zéro. Dans votre exemple, A est une matrice non singulière, mais en raison de l'arrondissement des problèmes engendrés par les petits nombres, la fonction det(A) renvoie zéro. Si vous avez un coup d'oeil à determinant(A), vous verrez le (journal) déterminant est différent de zéro. Par conséquent, un meilleur test que det(A) == 0 serait is.finite(determinant(A)$modulus).
    InformationsquelleAutor Sven Hohenstein
  3. 8

    try est juste une façon de dire R: "Si vous commettez une erreur à l'intérieur de la suite de parenthèses, puis de sauter et de se déplacer."

    Donc, si vous êtes inquiet que x <- matrix(sample(0:2, 4, replace = T), 2, 2) vous donnera peut-être une erreur, alors tout ce que vous avez à faire est de:

    try(x <- matrix(sample(0:2, 4, replace = T), 2, 2))

    Cependant, gardez à l'esprit, alors que x sera pas défini si vous le faire et il finit par ne pas être en mesure de calculer la réponse. Que pourrait provoquer un problème lorsque vous arrivez à solve(x) - de sorte que vous pouvez définir x avant try ou tout simplement "d'essayer" de toute chose:

    try(
      {
      x <- matrix(sample(0:2, 4, replace = T), 2, 2)
      inverses[[count]] <- solve(x)
      }
    )
    • vous pouvez affecter x hors de l'appel à try, comme dans: x <- try(matrix(.etc.)) Puis testez x's de la classe
    InformationsquelleAutor Señor O
  4. 5

    La documentation pour essayer explique votre problème plutôt bien. Je vous suggère d'aller à travers elle complètement.

    Edit: La documentation exemple l'air très simple et très similaires à la discussion de la question. Merci pour la suggestion mais. Voici la réponse en suivant l'exemple dans la page de documentation:

    # `idx` is used as a dummy variable here just to illustrate that
# all 100 entries are indeed calculated. You can remove it.
set.seed(1)
mat_inv <- function(idx) {
    print(idx)
    x <- matrix(sample(0:2, 4, replace = T), nrow = 2)
    solve(x)
}
inverses <- lapply(1:100, function(idx) try(mat_inv(idx), TRUE))
    • Une suggestion de lire attentivement cette documentation n'est pas une réponse.
    • Je n'ai pas downvote, mais vous avez juste visé à la fonction générale de try sans répondre à sa question
    InformationsquelleAutor Arun