Partager via

Juillet 2015

Volume 30, numéro 7

Langage de programmation R - Introduction à R pour les programmeurs c#

Par James McCaffrey

Le langage R est utilisé par les données scientifiques et des programmeurs pour le calcul statistique. En partie à cause des quantités croissantes de données recueillies par les systèmes logiciels et la nécessité d'analyser ces données, R est une des technologies plus forte croissance parmi mes collègues qui utilisent c#. Une familiarité avec R peut être un ajout précieux à votre ensemble de compétences techniques.

Le langage R est un projet GNU et est un logiciel libre. R a été dérivé d'une langue appelée S (pour "statistiques"), qui a été créée dans les laboratoires Bell dans les années 1970. Il existe de nombreux excellents tutoriels en ligne pour R, mais la plupart de ces tutoriels suppose que vous êtes un étudiant universitaire de statistiques. Cet article vise à aider les programmeurs c# à se mettre au diapason avec R aussi rapidement que possible.

Le meilleur moyen de voir où va cet article est de jeter un oeil à la session exemple R en Figure 1. La session de l'exemple a deux sujets indépendants. Le premier ensemble peu de commandes montrent ce qu'on appelle un test de khi-deux (aussi appelé le test de khi-deux) pour une distribution uniforme. Le deuxième jeu de commandes montre un exemple de la régression linéaire, qui, à mon avis, est la technique de Hello World de calcul statistique.

exemple R session
Figure 1 exemple R session

Le site Web de R est situé à r-Project.org. Le site propose des liens vers plusieurs sites miroirs où vous pouvez télécharger et installer R. L'installation est un simple fichier exécutable auto-extractible. R est officiellement supporté sur Windows XP et plus tard et aussi sur les principales plates-formes autres que Windows. J'ai installé R sur des ordinateurs Windows 7 et Windows 8 sans aucun problème. Par défaut, le processus d'installation vous donne les versions 32-bit et 64-bit.

Cet article suppose que vous avez au moins intermédiaire c#, programmation des compétences (donc vous pouvez comprendre les explications des similarités et des différences entre c# et R), mais ne suppose que vous savez quelque chose sur R. Il présente un programme de démonstration de c# dans son intégralité, qui est également disponible à partir du fichier de téléchargement qui accompagne cet article.

Le Test du chi carré à l'aide de R

En regardant Figure 1, la première chose à noter est que l'utilisation de R est tout à fait un peu différent à l'aide de c#. Bien qu'il soit possible d'écrire des scripts de R, R est le plus souvent utilisé en mode interactif dans un interpréteur de commandes. Le premier exemple de R est une analyse pour voir si un dé à six faces normal est juste ou non. Lorsque enroulé plusieurs fois, une filière équitable devrait donner environ le même nombre pour chacun des six résultats possibles.

Le R invite est indiquée par le jeton (>) dans l'interpréteur de commandes. La première instruction tapée dans Figure 1 commence par le caractère (#), qui est le jeton de R pour indiquer un commentaire.

La première commande réelle dans la session de l'exemple est :

> observed <- c(20, 28, 12, 32, 22, 36)

Cela crée un vecteur nommé observés à l'aide de la ch. (pour concaténer) fonction. Un vecteur contient des objets avec le même type de données. Une instruction c# équivalent serait :

var observed = new int[] { 20, 28, 12, 32, 22, 36 };

La première valeur, 20, est le nombre de fois une place une s'est produite, 28 est le nombre de fois un two-spot s'est produite et ainsi de suite. La somme des six chefs d'accusation est 20 + 28 +. . + 36 = 150. Vous pouvez vous attendre d'une filière équitable d'avoir environ 150/6 = 25 points pour chaque résultat possible. Mais le nombre de taches observées trois (12) ressemble étrangement faible.

Après avoir créé le vecteur, un test du Khi carré est effectué à l'aide de la fonction chisq.test :

> chisq.test(observed)

Dans R, le caractère point (.) est souvent utilisé plutôt que le caractère de soulignement (_) pour créer des noms de variable et de fonction qui sont plus faciles à lire. Le résultat de l'appel de la fonction chisq.test est un peu de texte :

Test khi-deux pour donné probabilités

data:  observed
X-squared = 15.28, df = 5, p-value = 0.009231

En termes de langage c#, la plupart des fonctions de R retournent une structure de données qui peut être ignorée, mais contiennent également de nombreuses instructions équivalentes Console.WriteLine qui exposent la sortie. Remarquez que c'est à vous de déchiffrer le sens de R résultat. Plus loin dans cet article, je vais vous montrer comment créer l'équivalent test khi-deux à l'aide de brut (pas de bibliothèque) code c#.

Dans cet exemple, la valeur de "X-squared" de 15.28 est la statistique calculée de khi-deux (cela ressemble à la lettre grecque Khi X majuscule). Une valeur de 0.0 indique que les valeurs observées sont exactement ce que vous attendez si le dé était juste. Des valeurs plus élevées de khi-deux indiquent une probabilité croissante que les dénombrements observés ne pourraient pas arrivé par hasard si le dé était juste. La valeur de df 5 est les « degrés de liberté », c'est-à-dire une inférieur au nombre des valeurs observées. La df n'est pas trop important pour cette analyse.

La p-valeur de 0.009231 est la probabilité que les dénombrements observés pourraient produite par hasard si le dé était juste. Parce que la p-valeur est si faible, moins de 1 %, vous conclurait que les valeurs observées sont très improbables a eu lieu par hasard et, par conséquent, il y a preuve statistique que la matrice en question est probablement biaisée.

Régression linéaire analyse à l'aide de R

La deuxième série de déclarations dans Figure 1 montre un exemple de régression linéaire. Régression linéaire est une technique statistique utilisée pour décrire la relation entre une variable numérique (appelée la variable dépendante dans les statistiques) et d'une ou plusieurs variables explicatives (appelées les variables indépendantes) peuvent être numérique ou catégorielles. Lorsqu'il y a une seule variable explicative/prédicteur indépendant, la technique s'appelle la régression linéaire simple. Lorsqu'il y a deux ou plusieurs variables indépendantes, comme dans l'exemple de démo, la technique s'appelle la régression linéaire multiple.

Avant de procéder à l'analyse de régression linéaire, j'ai créé un fichier texte de huit points, virgules, nommé DummyData.txt dans le répertoire C:\IntroToR avec ce contenu :

Color,Length,Width,Rate
blue, 5.4, 1.8, 0.9
blue, 4.8, 1.5, 0.7
blue, 4.9, 1.6, 0.8
pink, 5.0, 1.9, 0.4
pink, 5.2, 1.5, 0.3
pink, 4.7, 1.9, 0.4
teal, 3.7, 2.2, 1.4
teal, 4.2, 1.9, 1.2

Ce fichier est censé pour représenter les données de fleur avec la couleur de la fleur, la longueur et la largeur de la pétale et le taux de croissance. L'idée est de prédire les valeurs de taux (dans la dernière colonne) les valeurs de couleur, longueur et largeur. Après une instruction de commentaire, les trois premières commandes de R dans l'analyse de régression linéaire sont :

> setwd("C:\\IntroToR")
> data <- read.table("DummyData.txt",
  header=TRUE, sep=",")
> print(data)

La première commande définit le répertoire de travail afin que je n'aurais pas à qualifier complètement le chemin vers le fichier de données source. Au lieu d'utiliser le jeton (\) comme c'est souvent avec c#, j'aurais pu utiliser (/) comme cela est courant sur les plates-formes autres que Windows.

La deuxième commande charge les données en mémoire dans un objet de table nommé data. Remarquez que R utilise des paramètres nommés. Le paramètre d'en-tête indique si la première ligne est informations d'en-tête (T sous une forme abrégée ou TRUE) ou non (FALSE ou F). R est sensible à la casse et vous pouvez généralement utiliser la (<-) opérateur d'assigner des valeurs, ou de l'opérateur (=). Le choix est surtout une question de préférence personnelle. J'utilise habituellement (<-) pour l'assignation d'objet et (=) pour assignation de valeur de paramètre.

Le paramètre de la sep (séparateur) indique comment les valeurs de chaque ligne sont séparés. Par exemple, (\t) indique les valeurs délimité par des tabulations, et (" ") semble indiquer des valeurs délimitée par des espaces.

La fonction d'impression affiche la table de données en mémoire. La fonction d'impression possède de nombreux paramètres facultatifs. Notez que la sortie en Figure 1 affiche des indices de point de données à partir de 1. Pour les indices de tableau, de matrice et d'objet, R est un langage de base 1, plutôt que de base comme le langage C# 0.

L'analyse de régression linéaire est réalisée avec ces deux commandes de R :

> model <- lm(data$Rate ~ (data$Color + data$Length + data$Width))
> summary(model)

Vous pouvez interpréter la première commande comme, "modèle de magasin dans un objet nommé le résultat de l'analyse de fonction de lm (modèle linéaire) correspondant à la variable dépendante pour prédire la colonne taux dans l'objet table (taux de données$), et les variables de facteur prédictif indépendant sont couleur, longueur et largeur. » La deuxième commande signifie, « Afficher juste les résultats de base de l'analyse stockées dans l'objet nommé modèle. »

La fonction lm génère une grande quantité d'informations. Supposons que vous vouliez prédire la valeur de taux lorsque les valeurs d'entrée sont couleur = rose, longueur = 5.0 et largeur = 1,9. (Notez que cela correspond à l'élément de données [4], qui a une valeur réelle du taux de 0,4). Pour faire une prédiction, que vous utiliseriez les valeurs dans la colonne de l'estimation :

Coefficients:
               Estimate Std. Error t value Pr(>|t|)
(Intercept)    -0.14758    0.48286  -0.306  0.77986
data$Colorpink -0.49083    0.04507 -10.891  0.00166 **
data$Colorteal  0.35672    0.09990   3.571  0.03754 *
data$Length     0.04159    0.07876   0.528  0.63406
data$Width      0.45200    0.11973   3.775  0.03255 *

Si X représente les valeurs de la variable indépendante, et si Y représente le taux prévu, puis :

X = (blue = NA, pink = 1, teal = 0, Length = 5.0, Width = 1.9)
Y = -0.14758 + (-0.49083)(1) + (0.35672)(0) + (0.04159)(5.0) + (0.45200)(1.9)
  = -0.14758 + (-0.49083) + (0) + (0.20795) + (0.85880)
  = 0.42834

Remarquez que le taux prévu, 0,43, est assez proche du taux réel, 0,40.

Dans les mots, pour faire une prédiction à l'aide du modèle, vous calculez une somme linéaire de produits des valeurs d'estimation multipliées par leur correspondant X valeurs. La valeur de l'ordonnée à l'origine est une constante non associée à n'importe quelle variable. Lorsque vous avez des variables explicatives catégorielles, l'une des valeurs est annulée (bleu dans ce cas).

Les informations au bas de l'écran de sortie indiquent comment bien les variables indépendantes, couleur, longueur et largeur, expliquer la variable dépendante, taux :

Residual standard error: 0.05179 on 3 degrees of freedom
Multiple R-squared:  0.9927,    Adjusted R-squared:  0.9829
F-statistic: 101.6 on 4 and 3 DF,  p-value: 0.00156

La valeur de coefficient de détermination multiple (0,9927) est le pourcentage de variation de la variable dépendante a expliqué par la combinaison linéaire des variables indépendantes. Mettre un peu différemment, R au carré est une valeur comprise entre 0 et 1 où des valeurs plus élevées signifient un meilleur modèle prédictif. Ici, le R² est extrêmement élevé, ce qui indique la couleur, longueur et largeur peuvent prévoir des taux très précisément. La statistique F, R² ajusté et p-valeur existe d'autres mesures d'ajustement du modèle.

Un des points de cet exemple est que lors de la programmation à l'aide de R, votre plus grand défi de loin est de comprendre les statis­tics derrière les fonctions de la langue. La plupart des gens apprennent R de manière incrémentielle, en ajoutant des connaissances d'une technique à la fois, selon les besoins pour répondre à une question précise. Une analogie c# serait apprendre sur les différents objets de collection dans l'espace de noms Collections.Generic, telles que les classes Hashtable et file d'attente. La plupart des développeurs apprennent reinscriptible environ un à un moment plutôt que d'essayer de mémoriser des informations sur toutes les classes avant d'utiliser un quelconque d'entre eux dans un projet.

Un autre Test de khi-deux

Le type de test de khi-deux en Figure 1 est souvent appelé un test pour une distribution uniforme car il teste si les données d'observation tous ont nombre égal ; autrement dit, si les données sont réparties uniformément. Il existe plusieurs autres types de tests de khi-deux, dont l'un appelé un test du Khi deux d'indépendance.

Supposons que vous disposez d'un groupe de 100 personnes et vous êtes intéressé si sexe (masculin, féminin) est indépendant de l'affiliation à un parti politique (démocrate, républicain, autres). Imaginez vos données sont dans une matrice d'intervention comme le montre Figure 2. Il semble que, peut-être, les mâles sont plus susceptibles d'être républicain que sont les femmes.

Figure 2 matrice d'urgence

  Dem REP Autres  
Mâle 15 25 10 50
Femelle 30 15 5 50
  45 40 15 100

Pour utiliser R pour tester si les deux facteurs, le sexe et affiliation, sont statistiquement indépendants, vous placerez tout d'abord les données dans une matrice numérique avec cette commande :

> cm <- matrix( c(15,30,25,15,10,5), nrow=2, ncol=3 )

Remarquez que R, données de matrice sont conservées par colonnes (de haut en bas, de gauche à droite) plutôt que des lignes (de gauche à droite, de haut en bas) comme dans c#.

La commande de test du Khi carré R est :

> chisq.test(cm)

Le résultat de la valeur prédictive du test est 0.01022, ce qui indique qu'au seuil de 5 %, les deux facteurs ne sont pas indépendants. En d'autres termes, il y a une relation statistique entre le sexe et l'affiliation.

Remarquez dans le premier exemple de dés de khi-deux, le paramètre d'entrée est un vecteur, mais dans le deuxième exemple de sex-affiliation, l'entrée est une matrice. La fonction chisq.test a un total de sept paramètres, une nécessaire (un vecteur ou une matrice), suivie par six en option des paramètres nommés.

Comme de nombreuses méthodes c# dans les espaces de noms Microsoft .NET Framework, la plupart des fonctions de R sont fortement surchargées. En c#, une surcharge est généralement implémentée à l'aide de plusieurs méthodes portant le même nom mais avec des paramètres différents. L'utilisation des génériques est également une forme de surcharge. Dans R, une surcharge est implémentée en utilisant une fonction unique avec beaucoup d'option des paramètres nommés.

Graphiques avec R

Comme un programmeur c#, quand je veux faire un graphique de certains programme sortie de données, j'ai généralement exécuter mon programme, copiez les données de sortie, Ctrl + V coller que données dans le bloc-notes pour supprimer les caractères de contrôle bizarre, copier ces données, coller dans Excel et créez ensuite un graphique à l'aide d'Excel. C'est le genre de hacky, mais il fonctionne très bien dans la plupart des situations.

L'un des points forts du système R est sa capacité native de générer des graphiques. Jetez un oeil à un exemple dans Figure 3. Il s'agit d'un type de graphique qui n'est pas possible dans Excel sans un complément quelconque.

3D graphique à l'aide de R
Figure 3 3D graphique à l'aide de R

En plus du programme shell montré Figure 1, R dispose également d'une interface semi-GUI, RGui.exe, à utiliser lorsque vous voulez faire des graphiques.

Le graphique en Figure 3 montre la fonction z = f(x,y) = x * e ^ (-(x ^ 2 + y ^ 2)). Les trois premières commandes de R pour générer le graphique sont :

> rm(list=ls())
> x <- seq(-2, 2, length=25)
> y <- seq(-2, 2, length=25)

La fonction rm supprime un objet de l'espace de travail actuel en mémoire. La commande utilisée est une incantation magique R pour supprimer tous les objets. Les deuxième et troisième commandes créent des vecteurs de 25 valeurs, espacés régulièrement, à partir de -2 à + 2 inclusivement. Je pourrais avez utilisé la fonction c au lieu de cela.

Les deux commandes sont :

> f <- function(x,y) { x * exp(-(x^2
  + y^2)) }
> z <- outer(x,y,f)

La première commande montre comment définir une fonction de R en utilisant le mot clé function. La fonction intégrée de R nommé externe crée une matrice de valeurs à l'aide de vecteurs x et y et une définition de fonction f. Le résultat est une matrice de 25 x 25, où la valeur de chaque cellule est la valeur de la fonction f qui correspond à x et y.

Les deux commandes sont :

> nrz <- nrow(z)
> ncz <- ncol(z)

Les fonctions nrow égale et ncol retournent le nombre de lignes ou le nombre de colonnes dans leur argument de matrice. Ici, les deux valeurs serait de 25.

La prochaine commande R utilise la fonction colorRampPalette pour créer une palette dégradé de couleurs personnalisées pour peindre le graphique :

> jet.colors <- colorRampPalette(c("midnightblue", "blue",
+ "cyan", "green", "yellow", "orange", "red", "darkred"))

Lorsque vous tapez une longue lignée de R, si vous frappez la < entrez > clé, le système va sauter le curseur jusqu'à la prochaine ligne et placer un caractère comme une invite à indiquer votre commande n'est pas encore terminée +. Suivant :

> nbcol <- 64
> color <- jet.colors(nbcol)

Le résultat de ces deux commandes est un vecteur de couleur qui contient 64 valeurs de couleur différente nommé allant d'un bleu très foncé, vert et jaune, d'un rouge très sombre. Suivant :

> zfacet <- z[-1,-1] + z[-1,-ncz] + z[-nrz,-1] + z[-nrz,-ncz]
> facetcol <- cut(zfacet,nbcol)

Si vous regardez attentivement le graphique en Figure 3, vous verrez que la surface est constituée de 25 x 25 = 625 petite carrés ou facettes. Les deux commandes précédentes créent une matrice de 25 x 25, où la valeur de chaque cellule est l'un des 64 couleurs à utiliser pour la facette correspondante de la surface.

Enfin, le graphique 3D est affiché à l'aide de la fonction persp (graphique du point de vue) :

> persp(x,y,z, col=color[facetcol], phi=20, theta=-35,
+ ticktype="detailed", d=5, r=1, shade=0.1, expand=0.7)

La fonction persp a beaucoup d'option, des paramètres nommés. Le paramètre du col est la, ou des couleurs, à utiliser. Theta et phi paramètres définir l'angle de vision (gauche et droite et vers le haut et vers le bas) du graphique. Paramètre ticktype contrôle comment les valeurs sur le x, les axes y et z sont affichés. D et paramètres r contrôlent la distance œil perçue pour le graphique et l'effet 3D perçue. Le paramètre nommé ombre contrôles simulés ombrage provenant d'une source de lumière virtuelle. Le paramètre nommé développez contrôles le rapport entre la hauteur et la largeur du graphique. La fonction persp a beaucoup plus de paramètres, mais ceux utilisés ici sera suffisantes dans la plupart des situations.

Cet exemple fait remarquer que R est très puissantes et flexibles de fonctionnalités graphiques natives, mais ils ont tendance à être relativement faible et nécessitent une bonne quantité d'effort.

Le Test de khi-deux en c#

Pour mieux comprendre les similitudes et les différences entre analyses linguistiques R et programmation de langage de c#, il est utile d'examiner une implémentation c# d'un test de khi-deux. En outre, le code c# peut faire une belle addition à la bibliothèque de votre code personnel. Jetez un oeil sur le programme de démonstration de c# dans Figure 4.

Test de khi-deux à l'aide de c#
Figure 4 Test de khi-deux à l'aide de c#

Le programme de démonstration rapproche le test dés du Khi-deux de langue de R indiqué dans Figure 1. Notez que les valeurs de sortie de la démo de c# sont exactement les mêmes que ceux dans la session de R.

Pour créer le programme de démonstration, j'ai lancé Visual Studio et créé un nouveau langage c# projet d'application console nommé Khi-carré. Après que le code du modèle chargé dans l'éditeur, dans la fenêtre de l'Explorateur de solutions, j'ai cliqué sur fichier Program.cs et renomme à ChiSquareProgram.cs et permis Visual Studio à automatiquement et renommez-le class Program ChiSquareProgram.

Le programme de démonstration c# complet est répertorié dans Figure 5. Vous remarquerez que le code source est plus long que vous vous en doutez. Mise en œuvre de statistiques de programmation à l'aide de raw c# n'est pas extrêmement difficile, mais le code a tendance à être longue.

Programme de démonstration de la figure 5 C# Khi-carré

using System;
namespace ChiSquare
{
  class ChiSquareProgram
  {
    static void Main(string[] args)
    {
      try
      {
        Console.WriteLine("\nBegin Chi-square test using C# demo\n");
        Console.WriteLine(
          "Goal is to see if one die from a set of dice is biased or not\n");
        int[] observed = new int[] { 20, 28, 12, 32, 22, 36 };
        Console.WriteLine("\nStarting chi-square test");
        double p = ChiSquareTest(observed);
        Console.WriteLine("\nChi-square test complete");
        double crit = 0.05;
        if (p < crit)
        {
          Console.WriteLine("\nBecause p-value is below critical value of " +
            crit.ToString("F2"));
          Console.WriteLine("the null hypothsis is rejected and we conclude");
          Console.WriteLine("the data is unlikely to have happened by chance.");
        }
        else
        {
          Console.WriteLine("\nBecause p-value is not below critical value of " +
            crit.ToString("F2"));
          Console.WriteLine(
            "the null hypothsis is accepted (not rejected) and we conclude");
          Console.WriteLine("the observed data could have happened by chance.");
        }
        Console.WriteLine("\nEnd\n");
        Console.ReadLine();
      }
      catch (Exception ex)
      {
        Console.WriteLine(ex.Message);
        Console.ReadLine();
      }
    } // Main
    static void ShowVector(int[] v)
    {
      for (int i = 0; i < v.Length; ++i)
        Console.Write(v[i] + " ");
      Console.WriteLine("");
    }
    static double ChiSquareTest(int[] observed)
    {
      Console.WriteLine("Observed frequencies are: ");
      ShowVector(observed);
      double x = ChiSquareStatistic(observed);
      Console.WriteLine("\nX-squared = " + x.ToString("F2"));
      int df = observed.Length - 1;
      Console.WriteLine("\ndf = " + df);
      double p = ChiSquareProb(x, df);
      Console.WriteLine("\np-value = " + p.ToString("F6"));
      return p;
    }
    static double ChiSquareStatistic(int[] observed)
    {
      double sumObs = 0.0;
      for (int i = 0; i < observed.Length; ++i)
        sumObs += observed[i];
      double expected = (int)(sumObs / observed.Length);
      double result = 0.0;
      for (int i = 0; i < observed.Length; ++i)
      {
        result += ((observed[i] - expected) *
         (observed[i] - expected)) / expected;
      }
      return result;
    }
    public static double ChiSquareProb(double x, int df)
    {
      // x = a computed chi-square value. df = degrees of freedom.
      // output = prob. the x value occurred by chance.
      // So, for example, if result < 0.05 there is only a 5% chance
      // that the x value occurred by chance and, therefore,
      // we conclude that the actual data which produced x is
      // NOT the same as the expected data.
      // This function can be used to create a ChiSquareTest procedure.
      // ACM Algorithm 299 and update ACM TOMS June 1985.
      // Uses custom Exp() function below.
      if (x <= 0.0 || df < 1)
        throw new Exception("parameter x must be positive " +
        "and parameter df must be 1 or greater in ChiSquaredProb()");
      double a = 0.0; // 299 variable names
      double y = 0.0;
      double s = 0.0;
      double z = 0.0;
      double e = 0.0;
      double c;
      bool even; // Is df even?
      a = 0.5 * x;
      if (df % 2 == 0) even = true; else even = false;
      if (df > 1) y = Exp(-a); // ACM update remark (4)
      if (even == true) s = y; else s = 2.0 * Gauss(-Math.Sqrt(x));
      if (df > 2)
      {
        x = 0.5 * (df - 1.0);
        if (even == true) z = 1.0; else z = 0.5;
        if (a > 40.0) // ACM remark (5)
        {
          if (even == true) e = 0.0;
          else e = 0.5723649429247000870717135;
          c = Math.Log(a); // log base e
          while (z <= x)
          {
            e = Math.Log(z) + e;
            s = s + Exp(c * z - a - e); // ACM update remark (6)
            z = z + 1.0;
          }
          return s;
        } // a > 40.0
        else
        {
          if (even == true) e = 1.0;
          else e = 0.5641895835477562869480795 / Math.Sqrt(a);
          c = 0.0;
          while (z <= x)
          {
            e = e * (a / z); // ACM update remark (7)
            c = c + e;
            z = z + 1.0;
          }
          return c * y + s;
        }
      } // df > 2
      else
      {
        return s;
      }
    } // ChiSquare()
    private static double Exp(double x) // ACM update remark (3)
    {
      if (x < -40.0) // ACM update remark (8)
        return 0.0;
      else
        return Math.Exp(x);
    }
    public static double Gauss(double z)
    {
      // input = z-value (-inf to +inf)
      // output = p under Normal curve from -inf to z
      // e.g., if z = 0.0, function returns 0.5000
      // ACM Algorithm #209
      double y; // 209 scratch variable
      double p; // result. called 'z' in 209
      double w; // 209 scratch variable
      if (z == 0.0)
        p = 0.0;
      else
      {
        y = Math.Abs(z) / 2;
        if (y >= 3.0)
        {
          p = 1.0;
        }
        else if (y < 1.0)
        {
          w = y * y;
          p = ((((((((0.000124818987 * w
            - 0.001075204047) * w + 0.005198775019) * w
            - 0.019198292004) * w + 0.059054035642) * w
            - 0.151968751364) * w + 0.319152932694) * w
            - 0.531923007300) * w + 0.797884560593) * y * 2.0;
        }
        else
        {
          y = y - 2.0;
          p = (((((((((((((-0.000045255659 * y
            + 0.000152529290) * y - 0.000019538132) * y
            - 0.000676904986) * y + 0.001390604284) * y
            - 0.000794620820) * y - 0.002034254874) * y
            + 0.006549791214) * y - 0.010557625006) * y
            + 0.011630447319) * y - 0.009279453341) * y
            + 0.005353579108) * y - 0.002141268741) * y
            + 0.000535310849) * y + 0.999936657524;
        }
      }
      if (z > 0.0)
        return (p + 1.0) / 2;
      else
        return (1.0 - p) / 2;
    } // Gauss()
  } // Program class
} // ns

La méthode Main se compose principalement d'instructions WriteLine. Le code appelant essentiel est :

int[] observed = new int[] { 20, 28, 12, 32, 22, 36 };
double p = ChiSquareTest(observed);
double crit = 0.05;
if (p < crit) {
  // Messages
} else {
  // Messages
}

Le test de khi-deux de c# accepte un tableau de valeurs observées, calcule la valeur statistique du Khi carré et l'affiche ; calcule et affiche les degrés de liberté ; calcule et renvoie la valeur p.

Méthode ChiSquareTest appelle trois méthodes d'assistance :

ShowVector(observed);
double x = ChiSquareStatistic(observed);
int df = observed.Length - 1;
double p = ChiSquareProb(x, df);

Méthode ShowVector affiche le vecteur d'entrée, semblable à l'approche utilisée par la fonction chisq.test R se faisant l'écho d'entrée param­eter valeurs. Méthode ChiSquareStatistic renvoie le Khi-carré calculé ("X-squared" dans la sortie de R) et la méthode Khi-carré­Prob utilise le retour de ChiSquareStatistic pour calculer une probabilité (la "p-valeur" dans la sortie de R).

Méthode ChiSquareStatistic est un test simple pour une distribution uniforme. L'équation de statistique de la statistique Khi-deux est :

chi-squared = Sum( (observed - expected)^2 / expected )

Ainsi, avant le calcul de khi-deux, vous devez calculer les valeurs attendues associées avec les valeurs observées. Comme expliqué précédemment, pour cela, vous pouvez ajouter la valeur du compteur dans le tableau observée (150 dans la démo), puis à diviser cette somme par le nombre de valeurs dans le tableau (6 dans la démo), pour donner la valeur attendue (25) pour toutes les cellules.

La partie la plus difficile d'écrire un test du Khi carré est le calcul de la p-valeur. Si vous analysez la définition de méthode Khi-carré­Prob dans Figure 5, vous vous rendrez rapidement compte requiere profonds, des connaissances spécialisées. En outre, la méthode appelle une méthode appelée Gauss qui est tout aussi complexe.

Codage des fonctions numériques complexes est en fait assez facile car la plupart des fonctions ont été résolues depuis des décennies. Deux de mes ressources plus fréquemment utilisées sont l'Association pour le référentiel Computing Machinery (ACM) recueillis des algorithmes et le « manuel des fonctions mathématiques » par Abramowitz et Stegun (Dover Publications, 1965) — si bien connu il est souvent simplement appelé « A & S. » Les deux références sont disponibles gratuitement à plusieurs endroits sur le Web.

Par exemple, la méthode ChiSquareProb implémente l'algorithme de ACM #299 et la méthode d'assistance, Gauss, implémente ACM algorithme #209. Une alternative à ACM #209 est équation de A & S #7.1.26 plus une simple déclaration d'emballage.

Beaucoup des fonctions dans les algorithmes de ACM et A & S imple­photographiées dans des bibliothèques de c# ; Cependant, la plupart de ces bibliothèques sont assez grande. Lorsque cela est possible, je préfère le code à partir de zéro, en utilisant les méthodes j'ai besoin et en évitant des dépendances externes.

Quelques commentaires

Cet article ne montre qu'une infime partie du langage R, mais il devrait être suffisant pour vous obtenir opérationnel. Programmeurs c# ont tendance à entrer en contact avec R de deux façons. Tout d'abord, vous pouvez utiliser R pour réaliser vos propres analyses statistiques. Comme le montre cet article, à l'aide de R est assez facile, en supposant que vous saisissez les statistiques sous-jacentes. Deuxièmement, vous devrez interagir avec une personne qui utilise R comme leur langue maternelle et doivent donc comprendre l'environnement de R et de la terminologie.

Il y a quelques outils de développement de langage intégré de R vous pouvez utiliser. Un projet bien connu s'appelle RStudio. Je préfère généralement à l'aide de la console R native. Plusieurs produits Microsoft travaillent avec R. Par exemple, le service Microsoft Azure Machine Learning peut utiliser des scripts de langage R et j'ai l'impression prise en charge de R s'ajouteront au Visual Studio à un moment donné.

Dr. James McCaffrey travaille pour Microsoft Research à Redmond, Washington  Il a travaillé sur plusieurs produits Microsoft, y compris Internet Explorer et Bing. Dr. McCaffrey est joignable au jammc@microsoft.com.

Grâce à l'expert technique Microsoft Research suivant d'avoir relu cet article : Dan Liebling et Robin Reynolds-Haertle
Robin Reynolds-Haertle écrit la documentation pour le développement multi-plateforme avec Visual Studio. Ses intérêts actuels sont Core .NET, c#, Swift et R