Structure de la programmation avec R

R est un langage structuré en bloc comme C, C ++, Python, Perl, etc. Comme vous l'avez fait déjà vu, les blocs sont délimités par des accolades, bien que les accolades soient facultatives si le bloc se compose d'une simple déclaration. Les déclarations sont séparées par des caractères de nouvelle ligne ou par des points-virgules.
Dans cette partie, nous allons couvrir la structure de base de R en tant que langage de programmation. Nous allons passer en revue quelques détails supplémentaires sur les boucles, ensuite nous allons aller tout droit dans les fonctions, qui occuperont la majeure partie de cette partie.

Détails
Catégorie parente: Logiciel R
Catégorie : Structure de la programmation avec R

Fonctions anonymes
Comme l'a souligné plusieurs points de ce livre, le but de la fonction R
Function () est de créer des fonctions. Par exemple, considérez ce code:
Inc <- function (x) return (x + 1)
Il ordonne à R de créer une fonction qui ajoute 1 à son argument et ensuite
Attribue cette fonction à inc. Cependant, cette dernière étape - l'affectation - n'est pas
Toujours pris. Nous pouvons simplement utiliser l'objet de fonction créé par notre appel à
Function () sans nommer cet objet. Les fonctions dans ce contexte sont
Appelés anonymes, puisqu'ils n'ont aucun nom. (C'est quelque peu trompeur,
Car même les fonctions non anonymes ont un nom dans le sens qu'une
La variable les indique.)
Les fonctions anonymes peuvent être utiles si elles sont courtes
Sont appelés par une autre fonction. Revenons à notre exemple d'utilisation.
Dans la section 3.3:

> Z
[, 1] [, 2]
[1,] 1 4
[2,] 2 5
[3,] 3 6
> F <- fonction (x) x / c (2,8)
> Y <- appliquer (z, 1, f)
> Y
[, 1] [, 2] [, 3]
[1,] 0,5 1.000 1.50
[2,] 0,5 0,625 0,75
Ignorons l'intermédiaire, c'est-à-dire ignorer l'affectation en f-using
Une fonction anonyme dans notre appel à appliquer (), comme suit:
> Y <- appliquer (z, 1, fonction (x) x / c (2,8))
> Y
[, 1] [, 2] [, 3]
[1,] 0,5 1.000 1.50
[2,] 0,5 0,625 0,75
Qu'est-ce qui s'est passé ici? Le troisième argument formel à appliquer () doit
Être une fonction, ce qui est exactement ce que nous avons fourni ici, puisque la valeur de retour
De function () est une fonction!
Faire de cette façon est souvent plus clair que de définir la fonction à l'extérieur.
Bien sûr, si la fonction est plus compliquée, cette clarté n'est pas
Atteint.

Détails
Catégorie parente: Logiciel R
Catégorie : Structure de la programmation avec R

Écriture de vos propres opérations binaires
Vous pouvez inventer vos propres opérations! Il suffit d'écrire une fonction dont le nom commence
Et se termine par%, avec deux arguments d'un certain type et un retour
Valeur de ce type.
Par exemple, voici une opération binaire qui ajoute le double de la seconde
Opérande au premier:
> "% A2b%" <- fonction (a, b) retour (a + 2 * b)
> 3% a2b% 5
[1] 13
Un exemple moins trivial est donné dans la section sur les opérations définies dans la section
8.5.

Détails
Catégorie parente: Logiciel R
Catégorie : Structure de la programmation avec R

11 Outils pour composer le code de fonction
Si vous écrivez une fonction courte qui ne nécessite que temporairement,
Un moyen sale de le faire est de l'écrire sur place, juste là dans votre interaction
Session de terminal. Voici un exemple:
> G <- function (x) {
+ Retour (x + 1)
+}
Cette approche est incontournable pour des fonctions plus longues et plus complexes.
Maintenant, regardons quelques meilleurs moyens de composer le code R.


7.11.1 Éditeurs de texte et environnements de développement intégrés
Vous pouvez utiliser un éditeur de texte tel que Vim, Emacs, ou même le Bloc-notes, ou un éditeur
Dans un environnement de développement intégré (IDE) pour écrire votre code dans
Un fichier, puis lisez-le dans le fichier R. Pour faire ce dernier, vous pouvez utiliser les R
Source ().
Par exemple, supposons que nous avons les fonctions f () et g () dans un fichier xyz.R. Dans R,
Nous donnons cette commande:
> Source ("xyz.R")
Cela lit f () et g () dans R comme si nous les avions tapés à l'aide de la vitesse rapide
Manière indiquée au début de cette section.
Si vous n'avez pas beaucoup de code, vous pouvez couper et coller de votre éditeur
Fenêtre sur votre fenêtre R.
Certains éditeurs à usage général ont des plug-ins spéciaux disponibles pour R, tellement
Comme ESS pour Emacs et Vim-R pour Vim. Il existe également des IDE pour R, tels que le
Commercial par Revolution Analytics, et des produits open source tels que
Statet, JGR, Rcmdr et RStudio.


7.11.2 La fonction edit ()
Une bonne implication du fait que les fonctions sont des objets est que vous pouvez modifier
Fonctions à partir du mode interactif de R. La plupart des programmeurs R font leurs
Édition de code avec un éditeur de texte dans une fenêtre séparée, mais pour un petit, rapide
Changer, la fonction edit () peut être utile.
Par exemple, nous pourrions modifier la fonction f1 () en tapant ceci:
> F1 <- edit (f1)
Cela ouvre l'éditeur par défaut sur le code pour f1, que nous pourrions alors
Éditez et affectez de nouveau à f1.
Ou, nous pourrions être intéressés à avoir une fonction f2 () très similaire à f1 ()
Et ainsi exécuter ce qui suit:
> F2 <- edit (f1)
Cela nous donne une copie de f1 () à partir de. Nous ferions un peu d'édition et
Puis enregistrez sur f2 (), comme indiqué dans la commande précédente.
L'éditeur impliqué dépendra de l'éditeur de variables d'options internes de R.
Dans les systèmes de classe UNIX, R définira ceci à partir de l'environnement EDITEUR ou VISUEL de votre shell
Variable, ou vous pouvez la configurer comme suit:
> Options (éditeur = "/ usr / bin / vim")
Pour plus de détails sur l'utilisation des options, consultez la documentation en ligne en tapant
le suivant:
>? Options
Vous pouvez également utiliser edit () pour modifier les structures de données.

Détails
Catégorie parente: Logiciel R
Catégorie : Structure de la programmation avec R

Rappelons l'exemple suivant du chapitre 2:
> X <- c (1,2,4)
> Noms (x)
NUL
> Noms (x) <- c ("a", "b", "ab")
> Noms (x)
[1] "a" "b" "ab"
> X
A b ab
1 2 4
Considérons une ligne en particulier:
> Noms (x) <- c ("a", "b", "ab")
As-tu totalement inoffensif, hein? Et bien non. En fait, c'est scandaleux! Comment
Terre peut-on attribuer une valeur au résultat d'un appel de fonction? La résolution
À cette étrange situation réside dans la notion R des fonctions de remplacement.
La ligne précédente du code R en fait est le résultat de l'exécution de la
Suivant:
X <- "noms <-" (x, valeur = c ("a", "b", "ab"))
Non, ce n'est pas une faute de frappe. L'appel ici est en effet à une fonction nommée
Noms <- (). (Nous devons insérer les guillemets en raison des caractères spéciaux
impliqué.)


7.10.1 Qu'est-ce qui est considéré comme une fonction de remplacement?
Toute instruction d'affectation dans laquelle le côté gauche n'est pas seulement un identifiant
(C'est-à-dire un nom de variable) est considéré comme une fonction de remplacement. Quand
Rencontrant ceci:
G (u) <- v
R essayera d'exécuter ceci:
U <- "g <-" (u, value = v)
Notez le "essai" dans la phrase précédente. La déclaration échouera si vous
N'ont pas défini précédemment g <- (). Notez que la fonction de remplacement a
Un argument de plus que la fonction d'origine g (), une valeur d'argument nommée,
Pour les raisons expliquées dans cette section.
Dans les chapitres précédents, vous avez vu cette déclaration innocente:
X [3] <- 8
Le côté gauche n'est pas un nom de variable, donc il doit s'agir d'une fonction de remplacement,
Et en effet c'est comme suit.
Les opérations de souscription sont des fonctions. La fonction "[" () est pour la lecture
Éléments vectoriels, et "[<-" () est utilisé pour écrire. Voici un exemple:
> X <- c (8,88,5,12,13)
> X
Structures de programmation R 183
Www

[1] 8 88 5 12 13
> X [3]
[1] 5
> "[" (X, 3)
[1] 5
> X <- "[<-" (x, 2: 3, valeur = 99: 100)
> X
[1] 8 99 100 12 13
Encore une fois, cet appel compliqué dans cette ligne:
> X <- "[<-" (x, 2: 3, valeur = 99: 100)
Effectue simplement ce qui se passe derrière les scènes lorsque nous exécutons ceci:
X [2: 3] <- 99: 100
Nous pouvons facilement vérifier ce qui se passe de la sorte:
> X <- c (8,88,5,12,13)
> X [2: 3] <- 99: 100
> X
[1] 8 99 100 12 13


7.10.2 Exemple étendu: une classe vectorielle auto-livre
Supposons que nous ayons des vecteurs sur lesquels nous devons suivre les écrits. En d'autre
Mots, lorsque nous exécutons ce qui suit:
X [2] <- 8
Nous souhaitons non seulement modifier la valeur dans x [2] à 8 mais aussi augmenter
Un nombre de fois x [2] a été écrit. Nous pouvons le faire par
Écriture de versions spécifiques aux classes des fonctions de remplacement génériques pour vecteur
Sous-scriptures.
REMARQUE Ce code utilise des classes, dont nous allons discuter en détail au chapitre 9. Pour l'instant, vous tous
Il faut savoir si les classes S3 sont construites en créant une liste puis en l'untissant
En classe en appelant la fonction class ().
1 # classe "bookvec" de vecteurs qui contiennent des écrits de leurs éléments
2
3 # chaque instance de la classe comprend une liste dont les composants sont les
4 valeurs vectorielles et un vecteur de dénombrements
5
6 # construire un nouvel objet de classe bookvec
7 newbookvec <- function (x) {
8 tmp <- list ()
9 tmp $ vec <- x # le vecteur lui-même
10 tmp $ wrts <- rep (0, longueur (x)) # comptes des écritures, un pour chaque élément
11 classe (tmp) <- "bookvec"
12 retour (tmp)
13}
14
15 # fonction à lire
16 "[.bookvec" <- function (bv, subs) {
17 retour (bv $ vec [subs])
18}
19
20 # fonction à écrire
21 "[<-. Bookvec" <- function (bv, subs, value) {
22 bv $ wrts [subs] <- bv $ wrts [subs] + 1 # note le recyclage
23 bv $ vec [subs] <- valeur
24 retour (bv)
25}
26 \ end {Code}
27
28 Testez-le.
29
30 \ begin {Code}
31> b <- newbookvec (c (3,4,5,5,12,13))
32> b
33 $ vec
34 [1] 3 4 5 5 12 13
35
36 $ pistes
37 [1] 0 0 0 0 0 0
38
39 attr (, "classe")
40 [1] "bookvec"
41> b [2]
42 [1] 4
43> b [2] <- 88 # essayez d'écrire
44> b [2] # a travaillé?
45 [1] 88
46> b $ wrts # nombre d'écriture incrémenté?
47 [1] 0 1 0 0 0 0
Nous avons nommé notre classe "bookvec", car ces vecteurs feront leur
La comptabilité propre, c'est-à-dire suivre les comptes d'écriture. Donc, les souscriptions
Les fonctions seront [.bookvec () et [<-. Bookvec ().

Notre fonction newbookvec () (ligne 7) fait la construction pour cette classe. Dans
Vous pouvez voir la structure de la classe: un objet sera constitué du vecteur
Lui-même, vec (ligne 9), et un vecteur de comptes d'écriture, des pistes (ligne 10).
Soit dit en passant, notez dans la ligne 11 que la classe de fonction () elle-même est un remplacement
fonction!
Les fonctions [.bookvec () et [<-. Bookvec () sont assez simples.
N'oubliez pas de retourner l'objet entier dans ce dernier.

  1. Recursion