JULHO DE 2015

Linguagem de Programação R:Introdução ao R para Programadoresde C#Por James McCaffrey (https://msdn.microsoft.com/pt-br/magazine/mt149362?author=james+mccaffrey) | Julho de 2015 | Obtenha o código: C#(http://download.microsoft.com/download/1/F/3/1F3A206F-8648-4CA7-9585-AAECA220370A/Code_McCaffrey.R.0715.zip)   VB(http://download.microsoft.com/download/1/F/3/1F3A206F-8648-4CA7-9585-AAECA220370A/VBCode_McCaffrey.R.0715.zip)

A linguagem R é muito usada por programadores e cientistas de dados para computar estatísticas.Em parte devido a quantidade cada vez maior de dados coletados por sistemas de software, e pelanecessidade de analisar esses dados, o R é uma das tecnologias com crescimento mais rápido entremeus colegas que usam C#. A familiaridade com o R certamente será uma novidade valiosa em seuconjunto de habilidades técnicas.

A linguagem R é um projeto GNU, e é software livre. O R derivou de uma linguagem chamada S (de"statistics"), criada na Bell Laboratories nos anos 70. Há vários tutoriais online excelentes para o R,mas a maioria desses tutoriais pressupõe que você seja um estudante universitário de estatísticas.Este artigo destina-se a ajudar programadores de C# a compreender o R o mair rápido possível.

A melhor maneira de demonstrar o rumo que este artigo tomará é examinar a sessão de exemplo deR na Figura 1. A sessão de exemplo tem dois tópicos independentes. O primeiro conjunto decomandos demostram o chamado teste qui-quadrado para uma distribuição uniforme. O segundoconjunto de comandos demonstra um exemplo de regressão linear, que, na minha opinião, é atécnica de Hello World da computação de estatísticas.

NÚMERO 7 DO VOLUME 30

Edições e downloads / 2015 (https://msdn.microsoft.com/pt-br/magazine/mt267548.aspx) / Julho de 2015 (https://msdn.microsoft.com/pt-

br/magazine/mt238393.aspx) / Linguagem de Programação R: Introdução ao R para Programadores de C# (https://msdn.microsoft.com/pt-

br/magazine/mt238409.aspx)

(https://msdn.microsoft.com/pt-br)

Assinaturas do MSDN (https://msdn.microsoft.com/subscriptions/manage/hh442900)Obter ferramentas (https://go.microsoft.com/fwlink/?

LinkId=309297&clcid=0x416&slcid=0x416&campaign=o~msft~msdn~gettools-header~dn308572)

Developer Network

Magazine (https://msdn.microsoft.com/pt-br/magazine/)

Edições e downloads Assinar Enviar o artigo

Figura 1: exemplo de uma sessão em R

O site da Web de R é o r-project.org (http://r-project.org/). O site contém links para vários sitesespelhados, dos quais você pode baixar e instalar o R, através de um executável auto-extraívelsimples. O R é oficialmente suportado no Windows XP e posteriores, e também nas plataformas nãoWindows mais comuns. Eu já instalei o R em computadores com Windows 7 e Windows 8 semproblemas. Por padrão, o processo de instalação fornece versões de 32 bits e 64 bits.

Este artigo pressupõe que você tenha pelo menos uma habilidade intermediária de programação emC# (para que você possa entender as explicações sobre as semelhanças e diferenças entre o C# e oR), mas não pressupõe que tenha qualquer conhecimento sobre o R. Vou apresentar um programade demonstração em C# em sua totalidade, que também está disponível no arquivo de downloadque acompanha este artigo.

O teste de qui-quadrado usando o R

Ao analisar a Figura 1, a primeira coisa que se nota é que o uso de R é muito diferente do uso deC#. Embora seja possível escrever scripts de R, o R é geralmente usado no modo interativo em umshell de comando. O primeiro exemplo de R é uma análise para ver se um dado normal de seis ladosé honesto ou não. Ao ser lançado muitas vezes, espera-se que um dado honesto retorneaproximadamente a mesma contagem para cada um dos seis resultados possíveis.

O prompt de R é indicado pelo token (>) no shell. A primeira instrução digitada na Figura 1 iniciacom o caractere (#), que é o token de R para indicar um comentário.

O primeiro comando real na sessão de exemplo é:

Isso cria um vetor chamado observado usando a função c (de concatenar). Um vetor contém objetoscom o mesmo tipo de dados. Uma instrução levemente equivalente em C# seria:

O primeiro valor, 20, é o número de ocorrências com o resultado um, 28 é o número de ocorrênciascom o resultado dois, e assim por diante. A soma das seis contagens é 20 + 28 + . . + 36 = 150.Assim, espera-se que um dado honesto tenha 150/6 = 25 contagens de cada resultado possível.Mas a contagem observada para o resultado três (12) parece baixa demais.

Após criar o vetor, um teste de qui-quadrado é executado usando a função chisq.test:

Em R, o caractere de ponto (.) geralmente é usado em vez do caractere de sublinhado (_) para facilitara leitura dos nomes de variáveis e de funções. O resultado da chamada da função chisq.test é umaboa quantidade de texto:

Teste qui-quadrado para probabilidades determinadas

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

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

> chisq.test(observed)

Em termos de C#, a maior parte das funções de R retornam uma estrutura de dados que pode serignorada, mas também contêm muitas instruções equivalentes de Console.WriteLine que expõem asaída. Observe que cabe a você decifrar o significado da saída de R. Ainda neste artigo, mostrareicomo criar o teste qui-quadrado equivalente usando código C# bruto (sem bibliotecas).

Neste exemplo, o valor "X-quadrado" de 15,28 é a estatística calculada de qui-quadrado (a letragrega qui lembra o X maiúsculo). O valor 0,0 indica que os valores observados são exatamente osque se esperam de um dado honesto. Valores maiores de qui-quadrado indicam uma probabilidadecrescente de que as contagens observadas não poderiam ter ocorrido aleatoriamente se o dadofosse honesto. O valor df de 5 está dentro dos "graus de liberdade," sendo um a menos do que onúmero de valores observados. O df não é muito importante para esta análise.

O valor p de 0,009231 é a probabilidade de que as contagens observadas poderiam ter ocorridoaleatoriamente se o dado fosse honesto. Como o valor de p é muito pequeno, menos de 1%, vocêdeve concluir que é muito improvável que os valores observados ocorreram aleatoriamente e que,portanto, há evidência estatística que o dado em questão é desonesto.

Análise de regressão linear usando o R

O segundo conjunto de instruções na Figura 1 demonstra um exemplo de regressão linear. Aregressão linear é uma técnica estatística usada para descrever a relação entre uma variável numérica(na estatística, chamada de variável dependente) e uma ou mais variáveis explicativas (chamadas devariáveis independentes) que podem ser numéricas ou categóricas. Quando há apenas uma únicavariável explicativa/de previsão, a técnica é chamada de regressão linear simples. Quando houverduas ou mais variáveis independentes, como no exemplo de demonstração, a técnica é chamada deregressão linear múltipla.

Antes de fazer a análise de regressão linear, criei um arquivo de texto com oito itens delimitados porvírgula denominado DummyData.txt no diretório C:\IntroToR com este conteúdo:

Esse arquivo representa dados de flores com a cor da flor, o comprimento e a largura da pétala e ataxa de crescimento. A ideia é prever valores da Taxa (Rate) (a última coluna) dos valores de Cor(Color), Comprimento (Length) e Largura (Width). Depois de uma instrução de comentário, os três

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

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

primeiros comandos de R na análise de regressão linear são:

O primeiro comando define o diretório de trabalho para que não precise qualificar totalmente ocaminho para o arquivo de dados de origem. Em vez de usar o token (\\), como é comum em C#, eupoderia ter usado o (/) como é comum em plataformas não-Windows.

O segundo comando carrega os dados na memória em um objeto de tabela chamado data. Observeque o R usa parâmetros nomeados. O parâmetro de cabeçalho informa se a primeira linha é deinformações de cabeçalho (TRUE ou T de forma abreviada) ou não (FALSE ou F). O R diferenciamaiúsculas de minúsculas e você geralmente pode usar o operador (<-) para atribuir valores, ou ooperador (=). Essa escolha é uma questão de preferência pessoal. Tipicamente, eu uso (<-) paraatribuição de objetos e (=) para atribuição de valores de parâmetro.

O parâmetro sep (separador) indica como os valores em cada linha são separados. Por exemplo, (\t)indica valores delimitados por tabulação, e (" ") indica valores delimitados por espaço.

A função de impressão exibe a tabela de dados na memória. A função de impressão tem muitosparâmetros opcionais. Observe que a saída na Figura 1 exibe índices de item de dados, começandoem 1. Para índices de matriz e objeto, o R é uma linguagem de base 1, ao invés de base 0 como alinguagem C#.

A análise de regressão linear é executada com estes dois comandos de R:

Você pode interpretar o primeiro comando como "o resultado da análise da função de ml (modelolinear) em que a variável dependente a ser prevista é a coluna Taxa no objeto de tabela (data$Rate), eas variáveis independentes de previsão são Cor, Comprimento e Largura". O segundo comandosignifica "exibir apenas os resultados básicos da análise armazenada no objeto chamado modelo".

A função de ml gera uma grande quantidade de informações. Suponha que você queria prever ovalor da Taxa quando os valores de entrada são Cor = rosa (pink), Comprimento = 5,0 e Largura =1,9. (Observe que isso corresponde ao item de dados [4], que tem um valor real de Taxa de 0,4). Parafazer uma previsão, você usaria os valores na coluna Previsão (Estimate):

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

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

Se X representa os valores de variável independente e Y representa a previsão de Taxa, então:

Observe que a previsão de Taxa de 0,43 é bem próxima à taxa real de 0,40.

Em palavras, para fazer uma previsão usando o modelo, você calcula uma soma linear de produtosdos valores da Previsão multiplicados pelos seus valores correspondentes em X . O valor deinterceptação (Intercept) é uma constante não associada a qualquer variável. Quando você temvariáveis explicativas categóricas, um dos valores é descartado; nesse caso, azul (blue).

As informações na parte inferior da tela de saída indicam como as variáveis independentes Cor,Comprimento e Largura, explicam a variável dependente Taxa:

O valor múltiplo de qui-quadrado (0,9927) é a porcentagem de variação na variável dependenteexplicada pela combinação linear das variáveis independentes. De uma maneira levemente diferente,R-quadrado é um valor entre 0 e 1, em que os valores mais altos significam um modelo de previsãomelhor. Aqui, o valor R-quadrado é extremamente alto, indicando que Cor, Comprimento e Largurapodem prever a Taxa com bastante precisão. A estatística F, o valor R-quadrado ajustado e o valor dep são outras medidas de ajuste do modelo.

Um dos pontos deste exemplo é que, ao programar usando o R, sem dúvida o maior desafio écompreender as estatísticas por detrás das funções de linguagem. A maior parte das pessoasaprendem o R de maneira incremental, acumulando conhecimentos uma técnica por vez, conforme anecessidade de responder uma questão específica. Uma analogia do C# seria conhecer os vários

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 *

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

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

objetos de coleção no namespace Collections.Generic, como as classes de Tabela de Hash e Fila. Amaior parte dos desenvolvedores aprendem uma estrutura de dados por vez, ao invés de tentarmemorizar as informações de todas as classes antes de usar qualquer uma em um projeto.

Outro teste qui-quadrado

O tipo de teste qui-quadrado na Figura 1 geralmente é chamado de teste para distribuição uniformeporque testa se todos os dados observados têm contagens iguais; ou seja, se os dados sãodistribuídos de maneira uniforme. Há vários outros tipos de testes qui-quadrados, incluindo umachamado de um teste qui-quadrado de independência.

Suponha que você tenha um grupo de 100 pessoas e quiser descobrir se o sexo masculino (male) oufeminino (female) possui independência em relação à filiação ao partido político Democrata(Democrat), Republicano (Republican) ou Outros (Other). Imagine que seus dados estejam em umamatriz de contingência conforme a Figura 2. Parece que a probabilidade de homens seremRepublicanos é maior do que a de mulheres.

Figura 2: matriz de contingência

  Dem Rep Outro  

Masculino 15 25 10 50

Feminino 30 15 5 50

  45 40 15 100Para usar o R para testar se os dois fatores, sexo e filiação, são estatisticamente independentes,primeiro você colocaria os dados em uma matriz numérica com este comando:

Observe que, em R, os dados de matriz são armazenados por colunas (de cima para baixo, daesquerda para a direita) em vez de linhas (da esquerda para a direita, de cima para baixo), como emC#.

O comando de teste qui-quadrado de R é:

O resultado do valor de p do teste é 0,01022, que indica que, no nível de significância de 5 porcento, os dois fatores não são independentes. Em outras palavras, há uma relação estatística entresexo e filiação.

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

> chisq.test(cm)

Observe que no primeiro exemplo de dados de qui-quadrado, o parâmetro de entrada é um vetor,mas no segundo exemplo filiação-sexo, a entrada é uma matriz. A função chisq.test tem um total desete parâmetros, sendo que um é obrigatório (uma matriz ou um vetor), seguido por seis parâmetrosnomeados opcionais.

Como muitos métodos C# nos namespaces do Microsoft .NET Framework, a maior parte das funçõesde R são extremamente sobrecarregadas. Em C#, a sobrecarga normalmente é implementada usandovários métodos com o mesmo nome, mas com parâmetros diferentes. O uso de genéricos também éuma forma de sobrecarregar. Em R, a sobrecarga é implementada usando uma função simples comvários parâmetros nomeados opcionais.

Gráficos com R

Como um programador de C#, quando quero fazer um gráfico de algum programa de saída dedados, normalmente executo o meu programa, copio os dados de saída, colo com Ctrl + V os dadosno bloco de notas para remover caracteres estranhos de controle, copio os dados, colo no Excel e,em então, crio um gráfico usando o Excel. Isso é pouco complicado, mas funciona bem na maioriadas situações.

Um dos pontos fortes do sistema R é sua habilidade nativa para gerar gráficos. Vamos examinar umexemplo na Figura 3. Este é um tipo de gráfico que não é possível no Excel sem algum tipo desuplemento.

Figura 3: um gráfico 3D usando R

Além do programa de shell mostrado na Figura 1, R também tem uma interface semi-GUI, RGui.exe,para quando você quiser criar gráficos.

O gráfico na Figura 3 mostra a função z = f(x,y) = x * e^(-(x^2 + y^2)). Os três primeiros comandosR para gerar o gráfico são:

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

A função rm exclui um objeto do espaço de trabalho atual na memória. O comando usado é umencanto mágico de R para excluir todos os objetos. O segundo e o terceiro comandos criam vetoresde 25 valores, com espaçamento uniforme, de -2 para + 2 inclusivo. Ao invés disso, eu poderia terusado a função c.

Os próximos dois comandos são:

O primeiro comando mostra como definir uma função em R usando a palavra-chave function. Afunção R interna com o nome outer cria uma matriz de valores usando vetores de x e y e umadefinição de função f. O resultado é uma matriz de 25 x 25 em que o valor de cada célula é o valorda função f que corresponde a x e y.

Os próximos dois comandos são:

As funções nrow e ncol retornam o número de linhas ou o número de colunas no seu argumento dematriz. Aqui, os dois valores seriam 25.

O próximo comando de R usa a função colorRampPalette para criar uma paleta de cores gradientepersonalizada para pintar o gráfico:

Ao digitar uma linha longa em R, se você pressionar a tecla <Enter>, o sistema pulará o cursor para apróxima linha e colocará um caractere + como um prompt, para indicar que seu comando ainda nãoestá concluído. Próximo:

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

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

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

O resultado desses dois comandos é um vetor chamado cor (color), que contém 64 diferentesvalores de cores, de um azul muito escuro, passando por verde e amarelo, até um vermelho muitoescuro. Próximo:

Se você examinar atentamente o gráfico na Figura 3, você verá que a superfície é feita de 25 x 25 =625 pequenos quadrados ou facetas. Os dois comandos anteriores criam uma matriz de 25 x 25, emque o valor de cada célula é uma das 64 cores a ser usada para a faceta de superfíciecorrespondente.

Por fim, o gráfico 3D é exibido usando a função persp (gráfico de perspectiva):

A função persp possui muitos parâmetros opcionais nomeados. O parâmetro da coluna é a cor (oucores) a ser usada. Os parâmetros theta e phi definem o ângulo de exibição (à esquerda e à direita epara cima e para baixo) do gráfico. O parâmetro ticktype controla como os valores nos eixos x, y e zsão exibidos. Os parâmetros r e d controlam a distância percebida pelo olho ao gráfico, e o efeitopercebido em 3D. O parâmetro denominado shade controla o sombreamento simulado de umafonte de luz virtual. O parâmetro denominado expand controla a proporção entre a altura e largurado gráfico. A função persp tem muitos outros parâmetros, mas aqueles usados aqui serão suficientesna maior parte das situações.

Este exemplo indica que R tem recursos de gráficos nativos muito poderosos e flexíveis, mas quetendem a um nível relativamente baixo e exigem uma boa quantidade de esforço.

O teste de qui-quadrado em C#

Para compreender as semelhanças e diferenças entre as análises de linguagem R e a linguagem deprogramação C#, será útil examinamos uma implementação em C# de um teste de qui-quadrado.Além disso, o código C# pode vir a ser um importante acréscimo à sua biblioteca pessoal de códigos.Vejamos o programa de demonstração de C# na Figura 4.

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

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

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

Figura 4: Teste qui-quadrado usando C#

O programa de demonstração é semelhante ao teste qui-quadrado de um dado na linguagem R daFigura 1. Observe que os valores de saída da demonstração em C# são exatamente os mesmos dasessão em R.

Para criar o programa de demonstração, iniciei o Visual Studio e criei um novo projeto de aplicativono console C# denominado ChiSquare. Após o código de modelo ser carregado no editor, na janelaGerenciador de Soluções, eu cliquei com o botão direito no arquivo Program.cs e renomeei comoChiSquareProgram.cs e permiti que o Visual Studio automaticamente renomeasse a classe Programpara ChiSquareProgram.

O programa de demonstração em C# completo está listado na Figura 5. Você observará que ocódigo-fonte é maior do que o esperado. Implementar programação de estatísticas usando C# brutonão é tão difícil assim, mas a tendência é que o código seja bem longo.

Figure 5: programa de demonstração de qui-quadrado em C#

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

O método principal consiste principalmente de instruções WriteLine. O código de chamada essencialé:

O teste qui-quadrado em C# aceita uma matriz de valores observados, calcula o valor estatístico dequi-quadrado e o exibe; calcula e exibe os graus de liberdade; e calcula e retorna o valor de p.

O método ChiSquareTest chama três métodos auxiliares:

O método ShowVector exibe o vetor de entrada, semelhante à abordagem usada pela função de Rchisq.test de ecoar valores de parâmetro de entrada. O método ChiSquareStatistic retorna o qui-quadrado calculado ("X-quadrado" na saída R), e o método ChiSquareProb usa o retorno deChiSquareStatistic para calcular a probabilidade (o "valor de p" na saída R).

O método ChiSquareStatistic é um teste simples para distribuição uniforme. A equação estatísticapara a estatística qui-quadrada é:

+ 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

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

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

Portanto, antes de calcular qui-quadrado, você precisa calcular os valores esperados associados aosvalores observados. Conforme explicado anteriormente, para fazer isso, você adiciona o valor decontagem da matriz observada (150 na demonstração), e então divide essa soma pelo número devalores na matriz (6 na demonstração), para fornecer o valor esperado (25) para todas as células.

A parte mais difícil de escrever um teste qui-quadrado é o cálculo do valor de p. Se você examinar adefinição do método ChiSquareProb na Figura 5, você logo perceberá que são necessáriosprofundos conhecimentos especializados. Além disso, o método chama um método auxiliardenominado Gauss igualmente complexo.

É muito fácil codificar funções numéricas complicadas, porque a maior parte das funções já foramsolucionados há décadas. Dois dos recursos que uso com maior frequência são a Association forComputing Machinery (ACM) e o "Handbook of Mathematical Functions with Formulas, Graphs, andMathematical Tables" (Manual de Funções Matemáticas com Fórmulas, Gráficos e TabelasMatemáticas) de Abramowitz e Stegun (Dover Publications, 1965), tão famosos que são chamadosapenas de "A & S". Ambas estão disponíveis gratuitamente em vários lugares na Web.

Por exemplo, o método ChiSquareProb implementa o algoritmo nº 299 da ACM e o método auxiliar,Gauss, o nº 209. Uma alternativa ao nº 209 da ACM é a equação nº 7.1.26 de A & S, além de umasimples instrução de wrapping.

Muitas das funções dos algoritmos ACM e A & S são implementadas em bibliotecas C# existentes;no entanto, a maior parte dessas bibliotecas são muito grandes. Sempre que possível, prefiroescrever códigos a partir do começo, usando apenas os métodos que preciso e evitando adependência externa.

Alguns comentários

Este artigo cobre apenas uma pequena fração da linguagem R, o suficiente para que você possacompreendê-lo. A tendência é que programadores de C# entrem em contato com o R de duasmaneiras. Primeiro, usando o R para executar suas próprias análises estatísticas. Como mostra esteartigo, usar o R é bem fácil, se você possui domínio sobre as estatísticas subjacentes. Em segundo, aointeragir com alguém que usa o R como linguagem primária e, portanto, com a necessidade decompreender o ambiente R e a terminologia.

Existem algumas ferramentas de desenvolvimento de linguagem integrada à R que você pode usar.Um projeto bastante conhecido é o RStudio. Eu geralmente prefiro usando o console nativo de R.Vários produtos da Microsoft trabalham com R. Por exemplo, o serviço de aprendizado de máquinado Microsoft Azure pode usar scripts de linguagem R, e suspeito que suporte para R acabe sendoadicionado ao Visual Studio em algum momento.

Dr. James McCaffrey  trabalha para a Microsoft Research em Redmond, Washington. Eletrabalhou em vários produtos da Microsoft, incluindo Internet Explorer e Bing. Entre em contatocom o Dr. McCaffrey pelo email jammc@microsoft.com (mailto:jammc@microsoft.com).

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

Agradecemos ao seguinte especialista técnico da Microsoft Research pela revisão deste artigo: DanLiebling e Robin Reynolds-Haertle Robin Reynolds-Haertle escreve documentação para o desenvolvimento de plataforma cruzada como Visual Studio. Seus interesses atuais são o .NET Core, C#, Swift e R

MSDN Magazine Blog(http://blogs.msdn.com/msdnmagazine/)14 Top Features of Visual Basic 14: The Q&A(https://blogs.msdn.microsoft.com/msdnmagazine/2015/01/07/14-top-features-of-visual-basic-14-the-qa/)Wednesday, jan 7Big Start to the New Year at MSDN Magazine(https://blogs.msdn.microsoft.com/msdnmagazine/2015/01/02/big-start-to-the-new-year-at-msdn-magazine/)Friday, jan 2

More MSDN Magazine Blog entries >(http://blogs.msdn.com/msdnmagazine/)

Current Issue

(https://msdn.microsoft.com/pt-br/magazine/mt833435)

Browse All MSDN Magazines(https://msdn.microsoft.com/pt-

br/magazine/ee310108.aspx)

Subscribe to MSDN Flash newsletter

(https://msdn.microsoft.com/en-us/aa570311.aspx?ocid=msdn_magazine)

Receive the MSDN Flash e-mail newsletterevery other week, with news and informationpersonalized to your interests and areas offocus.

Esta página é útil? Sim NãoSiga-nos Inscrição na MSDN Newsletter

Centros do desenvolvedor

Windows

Office

Visual Studio

Microsoft Azure

Mais...

Recursos de aprendizagem

Microsoft Virtual Academy

(https://www.microsoftvirtualacademy.com/)

Channel 9

(https://channel9.msdn.com/)

MSDN Magazine

(https://msdn.microsoft.com/magazine/)

Comunidade

Fóruns

(https://social.msdn.microsoft.com/forums/pt-

br/home)

Blogs

(https://blogs.msdn.com/b/developer-

tools/)

Codeplex

(https://www.codeplex.com)

Suporte

Suporte autônomo

(https://msdn.microsoft.com/hh36169

Programas

BizSpark (para iniciantes)

(https://www.microsoft.com/bizspark/)

Imagine (for students)

(https://imagine.microsoft.com)

Brasil (Português) Boletim informativo (https://msdn.microsoft.com/newsletter.aspx)

Privacidade & cookies (https://go.microsoft.com/fwlink/?

LinkId=521839)

Termos de uso (https://msdn.microsoft.com/cc300389)

Marcas comerciais (https://www.microsoft.com/en-

us/legal/intellectualproperty/Trademarks/)

© 2019 Microsoft