Suppression d'éléments de la diagonale de la matrice dans la R

La R langage de programmation? J'aime C mieux, il est plus facile à épeler.

Une façon est de créer une matrice avec les numéros de la façon dont je l'aime à regarder:

a<-t(matrix(1:16,nrow=4,ncol=4))

qui ressemble à:

     [,1] [,2] [,3] [,4]
[1,]    1    2    3    4
[2,]    5    6    7    8
[3,]    9   10   11   12
[4,]   13   14   15   16

Supprimer les valeurs sur la diagonale:

diag(a)=NA

qui se traduit par:

     [,1] [,2] [,3] [,4]
[1,]   NA    2    3    4
[2,]    5   NA    7    8
[3,]    9   10   NA   12
[4,]   13   14   15   NA

Pour SUPPRIMER réellement les valeurs, plutôt que de simplement faire disparaître, nous avons besoin d'une refonte de:

a<-t(matrix(t(a)[which(!is.na(a))],nrow=3,ncol=4))

Qui se traduit par:

     [,1] [,2] [,3]
[1,]    2    3    4
[2,]    5    7    8
[3,]    9   10   12
[4,]   13   14   15

qui est la même chose que nous avons obtenu en C, ci-dessus.

C'est un peu long, mais il en résulte ce que je vois comme une bonne réponse. Je serais intéressé à voir une meilleure solution, par quelqu'un qui sait R mieux que moi.

Un peu d'explication sur l'affectation:

a<-t(matrix(t(a)[which(!is.na(a))],nrow=3,ncol=4))

1. La !is.na(a) nous donne une liste de VRAI, de FAUSSES valeurs pour les éléments qui ont été annulées.
2. La which(!is.na(a)) nous donne une liste d'indices pour chacune des vrais éléments.
3. La t(a) transpose la matrice puisque nous devons tirer basée sur les indices en #2.
4. t(a)[which(!is.na(a))] nous donne une liste de nombres qui est absent de la diagonale NA valeurs.
5. matrix(t(a)[which(!is.na(a))],nrow=3,ncol=4) convertit la liste de #4 dans une matrice, qui est la transposition de ce que nous voulons.
6. a<-t(matrix(1:16,nrow=4,ncol=4)) (le tout) transpose #5 dans la forme que nous voulons et l'attribue à l' a variable.

Cela fonctionne avec des cas comme a<-t(matrix(11:26,nrow=4,ncol=4)).

OriginalL'auteur

Gardez à l'esprit que la diagonale va avoir le même X et de Y index. Un programme rapide à zéro sur la diagonale en C suit:

#include <stdio.h>
static void printMat(char mat[4][4], char *comment)
{
    printf("%s:\n", comment);
    for(int jj=0; jj<4; jj++) {
        for(int ii=0; ii<4; ii++) {
            printf("%2d ",mat[jj][ii]);
        }
        printf("\n");
    }
}
main()
{
    static char matrix[4][4]= {
        { 1, 2, 3, 4},
        { 5, 6, 7, 8},
        { 9,10,11,12},
        {13,14,15,16}
    };


    printMat(matrix,"Before");
    for(int ii=0; ii<4; ii++) {
        matrix[ii][ii]=0;

    }
    printMat(matrix,"After");
}

Il en résulte:

Before:
 1  2  3  4
 5  6  7  8
 9 10 11 12
13 14 15 16
After:
 0  2  3  4
 5  0  7  8
 9 10  0 12
13 14 15  0

Pour SUPPRIMER plutôt que de simplement effacer la diagonale est plus compliqué.

Cela devrait faire l'affaire: (Gardez à l'esprit qu'un memcpy de zéro octets peuvent inclure des éléments qui ne sont pas là.)

#include <stdio.h>
#include <strings.h>
static void printMat(char *mat, int xDim, int yDim,char *comment)
{
    printf("%s:\n", comment);
    for(int jj=0; jj<yDim; jj++) {
        for(int ii=0; ii<xDim; ii++) {
            printf("%2d ",(mat[(jj)*xDim+ii]) );
        }
        printf("\n");
    }
}
main()
{
    static char matrix[4][4]= {
        { 1, 2, 3, 4},
        { 5, 6, 7, 8},
        { 9,10,11,12},
        {13,14,15,16}
    };
    static char new[4][3];

    printMat((char*)matrix,4,4,"Before");

    for(int ii=0; ii<4; ii++) {
        memcpy(&new[ii][0], &matrix[ii][0],ii);
        memcpy(&new[ii][ii],&matrix[ii][ii+1], 4-ii);
    }

    printMat((char*)new,3,4,"After");
}

Résultats dans:

Before:
 1  2  3  4
 5  6  7  8
 9 10 11 12
13 14 15 16
After:
 2  3  4
 5  7  8
 9 10 12
13 14 15

Bien sûr, si vous voulez quelque chose dans une autre langue, il contribue à poser.

OriginalL'auteur