R-3.3.0.tar.gz (codename “Supposedly Educational”) liberado

RlogoO Time do Rproject anunciou na  Terça-Feira (03/05/2016)  a mais recente versão do software de análise estatística R.  Esta versão recebeu o título de  “Supposedly Educational” (Supostamente Educacional). Nos pŕoximos dias devem aparecer nos espelhos (“mirrors”) do CRAN de sua preferência para atualização.  Você pode instalá-lo manualmente a partir do código fonte http://cran.r-project.org/src/base/R-3/R-3.3.0.tar.gz.  Usuários Windows podem atualizar utilizando o código abaixo (Nova versão será instalada caso esteja disponível no CRAN mirrror:

install.packages(installr) # install
setInternet2(TRUE)
installr::updateR() # updating R.

 

Usuários Linux devem configurar seu arquivo sources.list para adicionar o seu CRAN mirror. A nova versão será instalada caso ela se encontre nos repositórios Debian e Ubuntu.

sudo gedit /etc/apt/sources.list # abre o arquivo sources.list
# adicione seu favorito cran-mirror e a versão de sua Linux distro. Para
# as versões mais recentes do Debian e Ubuntu são.
deb http://<favourite-cran-mirror>/bin/linux/debian jessie-cran3/
deb https://<my.favorite.cran.mirror>/bin/linux/ubuntu xenial/
sudo apt-get update
sudo apt-get upgrade

A lista com as mudanças são apresentadas abaixo:

CHANGES IN R 3.3.0:

SIGNIFICANT USER-VISIBLE CHANGES:

  • nchar(x, *)’s argument keepNA governing how the result for NAs in
    x is determined, gets a new default keepNA = NA which returns NA
    where x is NA, except for type = “width” which still returns 2,
    the formatting / printing width of NA.

  • All builds have support for https: URLs in the default methods
    for download.file(), url() and code making use of them.

Unfortunately that cannot guarantee that any particular https:
URL can be accessed. For example, server and client have to
successfully negotiate a cryptographic protocol (TLS/SSL, …)
and the server’s identity has to be verifiable via the
available certificates. Different access methods may allow
different protocols or use private certificate bundles: we
encountered a https: CRAN mirror which could be accessed by one
browser but not by another nor by download.file() on the same
Linux machine.

NEW FEATURES:

  • The print method for methods() gains a byclass argument.

  • New functions validEnc() and validUTF8() to give access to the
    validity checks for inputs used by grep() and friends.

  • Experimental new functionality for S3 method checking, notably
    isS3method().

Also, the names of the R ‘language elements’ are exported as
character vector tools::langElts.

  • str(x) now displays “Time-Series” also for matrix (multivariate)
    time-series, i.e. when is.ts(x) is true.

  • (Windows only) The GUI menu item to install local packages now
    accepts *.tar.gz files as well as *.zip files (but defaults to
    the latter).

  • New programmeR’s utility function chkDots().

  • D() now signals an error when given invalid input, rather than
    silently returning NA. (Request of John Nash.)

  • formula objects are slightly more “first class”: e.g., formula()
    or new(“formula”, y ~ x) are now valid. Similarly, for “table”,
    “ordered” and “summary.table”. Packages defining S4 classes with
    the above S3/S4 classes as slots should be reinstalled.

  • New function strrep() for repeating the elements of a character
    vector.

  • rapply() preserves attributes on the list when how = “replace”.

  • New S3 generic function sigma() with methods for extracting the
    estimated standard deviation aka “residual standard deviation”
    from a fitted model.

  • news() now displays R and package news files within the HTML help
    system if it is available. If no news file is found, a visible
    NULL is returned to the console.

  • as.raster(x) now also accepts raw arrays x assuming values in
    0:255.

  • Subscripting of matrix/array objects of type “expression” is now
    supported.

  • type.convert(“i”) now returns a factor instead of a complex value
    with zero real part and missing imaginary part.

  • Graphics devices cairo_pdf() and cairo_ps() now allow non-default
    values of the cairographics ‘fallback resolution’ to be set.

This now defaults to 300 on all platforms: that is the default
documented by cairographics, but apparently was not used by all
system installations.

  • file() gains an explicit method argument rather than implicitly
    using getOption(“url.method”, “default”).

  • Thanks to a patch from Tomas Kalibera, x[x != 0] is now typically
    faster than x[which(x != 0)] (in the case where x has no NAs, the
    two are equivalent).

  • read.table() now always uses the names for a named colClasses
    argument (previously names were only used when colClasses was too
    short). (In part, wish of PR#16478.)

  • (Windows only) download.file() with default method = “auto” and a
    ftps:// URL chooses “libcurl” if that is available.

  • The out-of-the box Bioconductor mirror has been changed to one
    using https://: use chooseBioCmirror() to choose a http:// mirror
    if required.

  • The data frame and formula methods for aggregate() gain a drop
    argument.

  • available.packages() gains a repos argument.

  • The undocumented switching of methods for url() on https: and
    ftps: URLs is confined to method = “default” (and documented).

  • smoothScatter() gains a ret.selection argument.

  • qr() no longer has a … argument to pass additional arguments to
    methods.

  • [ has a method for class “table”.

  • It is now possible (again) to replayPlot() a display list
    snapshot that was created by recordPlot() in a different R
    session.

It is still not a good idea to use snapshots as a persistent
storage format for R plots, but it is now not completely silly to
use a snapshot as a format for transferring an R plot between two
R sessions.

The underlying changes mean that packages providing graphics
devices (e.g., Cairo, RSvgDevice, cairoDevice, tikzDevice) will
need to be reinstalled.

Code for restoring snapshots was contributed by Jeroen Ooms and
JJ Allaire.

Some testing code is available at .

  • tools::undoc(dir = D) and codoc(dir = D) now also work when D is
    a directory whose normalizePath()ed version does not end in the
    package name, e.g. from a symlink.

  • abbreviate() has more support for multi-byte character sets – it
    no longer removes bytes within characters and knows about Latin
    vowels with accents. It is still only really suitable for (most)
    European languages, and still warns on non-ASCII input.

abbreviate(use.classes = FALSE) is now implemented, and that is
more suitable for non-European languages.

  • match(x, table) is faster (sometimes by an order of magnitude)
    when x is of length one and incomparables is unchanged, thanks to
    Peter Haverty (PR#16491).

  • More consistent, partly not back-compatible behavior of NA and
    NaN coercion to complex numbers, operations less often resulting
    in complex NA (NA_complex_).

  • lengths() considers methods for length and [[ on x, so it should
    work automatically on any objects for which appropriate methods
    on those generics are defined.

  • The logic for selecting the default screen device on OS X has
    been simplified: it is now quartz() if that is available even if
    environment variable DISPLAY has been set by the user.

The choice can easily be overridden via environment variable
R_INTERACTIVE_DEVICE.

  • On Unix-like platforms which support the getline C library
    function, system(*,intern = TRUE) no longer truncates (output)
    lines longer than 8192 characters, thanks to Karl Millar.
    (PR#16544)

  • rank() gains a ties.method = “last” option, for convenience (and
    symmetry).

  • regmatches(invert = NA) can now be used to extract both
    non-matched and matched substrings.

  • data.frame() gains argument fix.empty.names; as.data.frame.list()
    gets new cut.names, col.names and fix.empty.names.

  • plot(x ~ x, *) now warns that it is the same as plot(x ~ 1, *).

  • recordPlot() has new arguments load and attach to allow package
    names to be stored as part of a recorded plot. replayPlot() has
    new argument reloadPkgs to load/attach any package names that
    were stored as part of a recorded plot.

  • S4 dispatch works within calls to .Internal(). This means
    explicit S4 generics are no longer needed for unlist() and
    as.vector().

  • Only font family names starting with “Hershey” (and not “Her” as
    before) are given special treatment by the graphics engine.

  • S4 values are automatically coerced to vector (via as.vector)
    when subassigned into atomic vectors.

  • findInterval() gets a left.open option.

  • The version of LAPACK included in the sources has been updated to
    3.6.0, including those ‘deprecated’ routines which were
    previously included. Ca 40 double-complex routines have been
    added at the request of a package maintainer.

As before, the details of what is included are in
src/modules/lapack/README and this now gives information on
earlier additions.

  • tapply() has been made considerably more efficient without
    changing functionality, thanks to proposals from Peter Haverty
    and Suharto Anggono. (PR#16640)

  • match.arg(arg) (the one-argument case) is faster; so is
    sort.int(). (PR#16640)

  • The format method for object_size objects now also accepts
    “binary” units such as “KiB” and e.g., “Tb”. (Partly from
    PR#16649.)

  • Profiling now records calls of the form foo::bar and some similar
    cases directly rather than as calls to . Contributed
    by Winston Chang.

  • New string utilities startsWith(x, prefix) and endsWith(x,
    suffix). Also provide speedups for some grepl(“^…”,*) uses
    (related to proposals in PR#16490).

  • Reference class finalizers run at exit, as well as on garbage
    collection.

  • Avoid parallel dependency on stats for port choice and random
    number seeds. (PR#16668)

  • The radix sort algorithm and implementation from data.table
    (forder) replaces the previous radix (counting) sort and adds a
    new method for order(). Contributed by Matt Dowle and Arun
    Srinivasan, the new algorithm supports logical, integer (even
    with large values), real, and character vectors. It outperforms
    all other methods, but there are some caveats (see ?sort).

  • The order() function gains a method argument for choosing between
    “shell” and “radix”.

  • New function grouping() returns a permutation that stably
    rearranges data so that identical values are adjacent. The
    return value includes extra partitioning information on the
    groups. The implementation came included with the new radix
    sort.

  • rhyper(nn, m, n, k) no longer returns NA when one of the three
    parameters exceeds the maximal integer.

  • switch() now warns when no alternatives are provided.

  • parallel::detectCores() now has default logical = TRUE on all
    platforms – as this was the default on Windows, this change only
    affects Sparc Solaris.

Option logical = FALSE is now supported on Linux and recent
versions of OS X (for the latter, thanks to a suggestion of Kyaw
Sint).

  • hist() for “Date” or “POSIXt” objects would sometimes give
    misleading labels on the breaks, as they were set to the day
    before the start of the period being displayed. The display
    format has been changed, and the shift of the start day has been
    made conditional on right = TRUE (the default). (PR#16679)

  • R now uses a new version of the logo (donated to the R Foundation
    by RStudio). It is defined in .svg format, so will resize
    without unnecessary degradation when displayed on HTML
    pages-there is also a vector PDF version. Thanks to Dirk
    Eddelbuettel for producing the corresponding X11 icon.

  • New function .traceback() returns the stack trace which
    traceback() prints.

  • lengths() dispatches internally.

  • dotchart() gains a pt.cex argument to control the size of points
    separately from the size of plot labels. Thanks to Michael
    Friendly and Milan Bouchet-Valat for ideas and patches.

  • as.roman(ch) now correctly deals with more diverse character
    vectors ch; also arithmetic with the resulting roman numbers
    works in more cases. (PR#16779)

  • prcomp() gains a new option rank. allowing to directly aim for
    less than min(n,p) PC’s. The summary() and its print() method
    have been amended, notably for this case.

  • gzcon() gains a new option text, which marks the connection as
    text-oriented (so e.g. pushBack() works). It is still always
    opened in binary mode.

  • The import() namespace directive now accepts an argument except
    which names symbols to exclude from the imports. The except
    expression should evaluate to a character vector (after
    substituting symbols for strings). See Writing R Extensions.

  • New convenience function Rcmd() in package tools for invoking R
    CMD tools from within R.

  • New functions makevars_user() and makevars_site() in package
    tools to determine the location of the user and site specific
    Makevars files for customizing package compilation.

UTILITIES:

  • R CMD check has a new option –ignore-vignettes for use with
    non-Sweave vignettes whose VignetteBuilder package is not
    available.

  • R CMD check now by default checks code usage (via codetools)
    with only the base package attached. Functions from default
    packages other than base which are used in the package code but
    not imported are reported as undefined globals, with a suggested
    addition to the NAMESPACE file.

  • R CMD check –as-cran now also checks DOIs in package CITATION
    and Rd files.

  • R CMD Rdconv and R CMD Rd2pdf each have a new option
    –RdMacros=pkglist which allows Rd macros to be specified before
    processing.

DEPRECATED AND DEFUNCT:

  • The previously included versions of zlib, bzip2, xz and PCRE have
    been removed, so suitable external (usually system) versions are
    required (see the ‘R Installation and Administration’ manual).

  • The unexported and undocumented Windows-only devices cairo_bmp(),
    cairo_png() and cairo_tiff() have been removed. (These devices
    should be used as e.g. bmp(type = “cairo”).)

  • (Windows only) Function setInternet2() has no effect and will be
    removed in due course. The choice between methods “internal” and
    “wininet” is now made by the method arguments of url() and
    download.file() and their defaults can be set via options. The
    out-of-the-box default remains “wininet” (as it has been since R
    3.2.2).

  • [ into its own list such that the end result is roughly equivalent
    to using [[ S4 value will be coerced to a list with as.list().

  • Package tools’ functions package.dependencies(), pkgDepends(),
    etc are deprecated now, mostly in favor of package_dependencies()
    which is both more flexible and efficient.

INSTALLATION and INCLUDED SOFTWARE:

  • Support for very old versions of valgrind (e.g., 3.3.0) has been
    removed.

  • The included libtool script (generated by configure) has been
    updated to version 2.4.6 (from 2.2.6a).

  • libcurl version 7.28.0 or later with support for the https
    protocol is required for installation (except on Windows).

  • BSD networking is now required (except on Windows) and so
    capabilities(“http/ftp”) is always true.

  • configure uses pkg-config for PNG, TIFF and JPEG where this is
    available. This should work better with multiple installs and
    with those using static libraries.

  • The minimum supported version of OS X is 10.6 (‘Snow Leopard’):
    even that has been unsupported by Apple since 2012.

  • The configure default on OS X is –disable-R-framework: enable
    this if you intend to install under /Library/Frameworks and use
    with R.app.

  • The minimum preferred version of PCRE has since R 3.0.0 been 8.32
    (released in Nov 2012). Versions 8.10 to 8.31 are now deprecated
    (with warnings from configure), but will still be accepted until
    R 3.4.0.

  • configure looks for C functions __cospi, __sinpi and __tanpi and
    uses these if cospi etc are not found. (OS X is the main
    instance.)

  • (Windows) R is now built using gcc 4.9.3. This build will
    require recompilation of at least those packages that include C++
    code, and possibly others. A build of R-devel using the older
    toolchain will be temporarily available for comparison purposes.

During the transition, the environment variable R_COMPILED_BY has
been defined to indicate which toolchain was used to compile R
(and hence, which should be used to compile code in packages).
The COMPILED_BY variable described below will be a permanent
replacement for this.

  • (Windows) A make and R CMD config variable named COMPILED_BY has
    been added. This indicates which toolchain was used to compile R
    (and hence, which should be used to compile code in packages).

PACKAGE INSTALLATION:

  • The make macro AWK which used to be made available to files such
    as src/Makefile is no longer set.

C-LEVEL FACILITIES:

  • The API call logspace_sum introduced in R 3.2.0 is now remapped
    as an entry point to Rf_logspace_sum, and its first argument has
    gained a const qualifier. (PR#16470)

Code using it will need to be reinstalled.

Similarly, entry point log1pexp also defined in Rmath.h is
remapped there to Rf_log1pexp

  • R_GE_version has been increased to 11.

  • New API call R_orderVector1, a faster one-argument version of
    R_orderVector.

  • When R headers such as R.h and Rmath.h are called from C++ code
    in packages they include the C++ versions of system headers such
    as rather than the legacy headers such as .
    (Headers Rinternals.h and Rinterface.h already did, and inclusion
    of system headers can still be circumvented by defining
    NO_C_HEADERS, including as from this version for those two
    headers.)

The manual has long said that R headers should not be included
within an extern “C” block, and almost all the packages affected
by this change were doing so.

  • Including header S.h from C++ code would fail on some platforms,
    and so gives a compilation error on all.

  • The deprecated header Rdefines.h is now compatible with defining
    R_NO_REMAP.

  • The connections API now includes a function R_GetConnection()
    which allows packages implementing connections to convert R
    connection objects to Rconnection handles used in the API. Code
    which previously used the low-level R-internal getConnection()
    entry point should switch to the official API.

BUG FIXES:

  • C-level asChar(x) is fixed for when x is not a vector, and it
    returns “TRUE”/”FALSE” instead of “T”/”F” for logical vectors.

  • The first arguments of .colSums() etc (with an initial dot) are
    now named x rather than X (matching colSums()): thus error
    messages are corrected.

  • A coef() method for class “maov” has been added to allow vcov()
    to work with multivariate results. (PR#16380)

  • method = “libcurl” connections signal errors rather than
    retrieving HTTP error pages (where the ISP reports the error).

  • xpdrows.data.frame() was not checking for unique row names; in
    particular, this affected assignment to non-existing rows via
    numerical indexing. (PR#16570)

  • tail.matrix() did not work for zero rows matrices, and could
    produce row “labels” such as “[1e+05,]”.

  • Data frames with a column named “stringsAsFactors” now format and
    print correctly. (PR#16580)

  • cor() is now guaranteed to return a value with absolute value
    less than or equal to 1. (PR#16638)

  • Array subsetting now keeps names(dim(.)).

  • Blocking socket connection selection recovers more gracefully on
    signal interrupts.

  • The data.frame method of rbind() construction row.names works
    better in borderline integer cases, but may change the names
    assigned. (PR#16666)

  • (X11 only) getGraphicsEvent() miscoded buttons and missed mouse
    motion events. (PR#16700)

  • methods(round) now also lists round.POSIXt.

  • tar() now works with the default files = NULL. (PR#16716)

  • Jumps to outer contexts, for example in error recovery, now make
    intermediate jumps to contexts where on.exit() actions are
    established instead of trying to run all on.exit() actions before
    jumping to the final target. This unwinds the stack gradually,
    releases resources held on the stack, and significantly reduces
    the chance of a segfault when running out of C stack space. Error
    handlers established using withCallingHandlers() and
    options(“error”) specifications are ignored when handling a C
    stack overflow error as attempting one of these would trigger a
    cascade of C stack overflow errors. (These changes resolve
    PR#16753.)

  • The spacing could be wrong when printing a complex array.
    (Report and patch by Lukas Stadler.)

  • pretty(d, n, min.n, *) for date-time objects d works again in
    border cases with large min.n, returns a labels attribute also
    for small-range dates and in such cases its returned length is
    closer to the desired n. (PR#16761) Additionally, it finally
    does cover the range of d, as it always claimed.

  • tsp(x) both “ts” and “mts”. (PR#16769)

  • install.packages() could give false errors when
    options(“pkgType”) was “binary”. (Reported by Jose Claudio
    Faria.)

  • A bug fix in R 3.0.2 fixed problems with locator() in X11, but
    introduced problems in Windows. Now both should be fixed.
    (PR#15700)

  • download.file() with method = “wininet” incorrectly warned of
    download file length difference when reported length was unknown.
    (PR#16805)

  • diag(NULL, 1) crashed because of missed type checking.
    (PR#16853)

Anúncios
Publicado em Dicas R, R Notícias | Marcado com , , , | 3 Comentários

Assistente para ajuste de modelos de degradação in situ e produção de gases

blog13

           As técnicas de digestibilidade in situ e produção de gases, são bastante utilizadas na nutrição de ruminantes para se avaliar o valor dos alimentos. Estas técnicas permitem estimar a taxa de degradação dos alimentos no ambiente ruminal e quando associado a um marcador, que nos forneça informações sobre a taxa de passagem, podemos estimar a degradabilidade ruminal do alimento.

             Os principais modelos utilizados para ajustar o desaparecimento ruminal do alimento ao longo do tempo ou a produção cumulativa de gases ao longo do tempo são funções não lineares. A solução para estimativa dos parâmetros nesta funções somente pode ser obtido por métodos numéricos , seguindo procedimentos te otimização interativas. Procedimentos de otimização interativas exigem que o analista forneça os valores iniciais dos parâmetros e após sucessivas interações os parâmetros vão sendo ajustados de tal forma que a soma de quadrados dos resíduos (SQR) é reduzida em cada passo. O critério de convergência será atendido quando a SQR atingir valor mínimo ( ou máxima probabilidade da variável resposta for obtida), a partir deste ponto nenhuma melhora no ajuste do modelo é possível através dos parâmetros.

            Os valores iniciais devem ser próximos aos valores desconhecidos dos parâmetros que serão estimados ou o procedimento de otimização pode não convergir. Além disso valores iniciais inadequados podem levar o algoritmo a convergir para um minimo local ao invés do minimo global, esperado na estimativa dos quadrados mínimos.

            No post de hoje apresento um assistente útil no processo de ajuste de modelos não lineares, para análise de experimentos de digestibilidade in situ e produção de gasses. Este assistente é uma extensão do script fornecido pelo Prof. Walmes em seu blog Ridículas que modifiquei para trabalhar com vários modelos. O código depende dos pacotes Rpanel e nlme estarem instalados em seu sistema. Os modelos utilizados foram descritos nos trabalhos de López et al (1999) e France et al (2000) para modelos de digestibilidade in situ e produção de gases respectivamente. Segue algumas observações para seu uso: (veja vídeo)

a) Para utilizar este assistente os dados devem estar no formato CSV (separado por vírgula);
b) Pare selecionar subgrupos de dados escreva uma expressão logical indicando qual subgrupo de dados selecionar (não usar aspas)
p.ex: dieta==1 & concentracao==10 para selecionar os dados identificados por dieta==1 e concentração igual a 10 ; dieta==2 | dieta ==4 & concentracao==40 para selecionar dietas identificados por 2 ou 4 e concentração igual a 40, veja manual da função gnls {nlme} para mais informações.

c) Nas caixas “nome da variável dependente (y)” e ” nome da variável independente (x)” insira o nome das variáveis dependente e independente conforme encontra-se em seu banco de dados importado.

d) Ao clicar em ajustar uma curva de cor azul será sobreposta ao gráfico, para indicar convergência. Quando não houver convergência uma mensagem será apresentada sobre o gráfico. Quando outro motivo, além do limite para critério de convergência, gerar erro nenhuma mensagem ou curva na cor azul será mostrada e a mensagem de erro/warnings pode ser vista no console;

e) Clique em ajustar para ver o modelo ajustado sobre o R console (equivalente a digitar “summary(modelo))

f) O modelo Gompertz para produção de gases onde são fornecidos dois modelos Gompertz I e Gompertz II esses modelos diferem quanto ao ponto de inflexão da curva: Ambos os modelos não são simétricos sobre o ponto de inflexão M. Para o modelo Gompertz I M é obtido da fórmula K = exp [–exp (cM)] e para Gompertz II M=(1/c)*ln(c/b). Veja France et al 2000 e López (2008) (cap 3 , pag. 55) para mais detalhes

até a proxima dica!


#Baixe o arquivo em algum diretório em seu computador
# Em "destfile=" coloque o endereço do diretório onde deseja salvar o arquivo

Windows
download.file("https://www.dropbox.com/s/el82xcu4fft3tpg/gases.csv?raw=1",destfile="c:\Users\(username)\Desktop\gases.csv")

Linux 
download.file("https://www.dropbox.com/s/el82xcu4fft3tpg/gases.csv?raw=1",destfile="~/Área de trabalho/gases.csv")

#================================================
# Interface gráfica para ajuste de modelos de digestibilidade in situ e produção de gases
# Autor: Fernando Souza
# Data: 22/04/2016
#================================================
#--------Verifica se os pacotes necessários estão instalados e instala-os em caso negativo--------

packages <- c("rpanel","nlme") # Verifica se os pacotes necessários estão instalados, em caso negativo faz a instalação if (length(setdiff(packages, rownames(installed.packages()))) > 0) {
install.packages(setdiff(packages, rownames(installed.packages())))
}

# ativa os pacotes necessários
for (i in 1:length(packages)){
library(packages[i],character.only = TRUE)
print(paste("O seguinte pacote foi carregado:",packages[i],sep=""))
}

#-------------------------Seleciona o banco de dados---------------------
#------------banco dados deve ser salvo como csv-------------------------
database<-function(panel){
dados<<-read.csv(file.choose(), header=TRUE)
print(head(dados));
return(panel)
}
#Altera o nome da variável dependente e independente definida pelo usuário para y e x
ren_y<-function(panel){
var_dep<<-panel$var_y
colnames(dados)[grep(var_dep,colnames(dados))]<<-"y"
print(colnames(dados)); return(panel)}

ren_x <- function(panel){
var_indep<<-panel$var_x
colnames(dados)[grep(var_indep,colnames(dados))]<<-"x"
print(colnames(dados)); return(panel)}

#================================================#-----------------Ajusta os modelos de degradabilidade in situ e produção de gases------------------
#---Referencias in situ: Lopez et al,(1999); produção gases : France et al  (2000)----------------
#================================================
#nlsajust é excutada quando clicar no botão "Ajustar"

nlsajust <- function(panel){
## ajuste do modelo não linear
controle<<-nlmeControl(nlmStepMax=1000,nlsTol=0.01,maxIter=100)
if(panel$modelo == "Orskov & McDonald"){
n0 <<- try(gnls(y~a+b*(1-exp(-c*(x-d))), # modelo de Orskov & McDonanld (1979)
data=da,control=controle,na.action=na.omit,
start=start),)
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*(1-exp(-c*(x-d))),
add=TRUE, col="blue"))
aju <<- n0
}

}
if(panel$modelo=="Michaelis-Menten"){
n0 <<- try(gnls(y~a+b*((x-d)/(x-d+c)), # modelo Michaelis-Menten (ou Inversa Polinomial)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*((x-d)/(x-d+c)),
add=TRUE, col="blue"))
aju <<- n0
}

}
if(panel$modelo=="Van Milgen"){
n0 <<- try(gnls(y~a+b*(1-((c*exp(-d*x)-d*exp(-c*x))/(c-d))), # modelo lag compartimental (Van Milgen et al (1991)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*(1-((c*exp(-d*x)-d*exp(-c*x))/(c-d))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if(panel$modelo=="France"){
n0 <<- try(gnls(y~a+b*(1-exp(-c*(x-e)-d*(sqrt(x)-sqrt(e)))), # Modelo Generalized Mitscherlich Dhanoa et al (1995)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*(1-exp(-c*(x-e)-d*(sqrt(x)-sqrt(e)))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if(panel$modelo=="Michaelis-Menten Generalizado"){
n0 <<- try(gnls(y~a+b*((x^c)/((x^c)+(d^c))), # modelo Michaelis-Menten Generalizado (France et al,1998)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*((x^c)/((x^c)+(d^c))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if (panel$modelo=="Inversa Exponencial"){
n0 <<- try(gnls(y~a+b*((1-exp(-c*x))/(1+d*exp(-c*x))), # modelo inversa exponencial (France et al,1990)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*((1-exp(-c*x))/(1+d*exp(-c*x))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if(panel$modelo=="Gompertz I"){
n0 <<- try(gnls(y~a+b*((d-d^exp(-c*x))/(d-1)),
# Gompertz curve, asymmetrical about an inflection point M, # which can be calculated from K = exp[−exp (cM)] (France et al., 1990)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*((d-d^exp(-c*x))/(d-1)),
add=TRUE, col="blue"))
aju <<- n0
}
}

if(panel$modelo=="Von Bertallanffy"){
n0 <<- try(gnls(y~a+b*((1-exp(-c*x))^1/d), # modelo Von Bertallanfy (Ricker,1979)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a+b*((1-exp(-c*x))^1/d),
add=TRUE, col="blue"))
aju <<- n0
}

}
if(panel$modelo == "PG-Oskov & McDonald"){
n0 <<- try(gnls(y~a*(1-exp(-c*(x-b))), # modelo Oskov & McDonald (1979)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*(1-exp(-c*(x-b))),
add=TRUE, col="blue"))
aju <<- n0
}

}
if(panel$modelo=="PG-Michaelis-Menten"){
n0 <<- try(gnls(y~a*((x-b)/(x-b+c)), # modelo Michaelis-Menten
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*((x-b)/(x-b+c)),
add=TRUE, col="blue"))
aju <<- n0
}

}
if(panel$modelo=="PG-Van Milgen"){
n0 <<- try(gnls(y~a*(1-((c*exp(-b*x)-b*exp(-c*x))/(c-b))), # modelo Van Mingen et al (1991)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*(1-((c*exp(-b*x)-b*exp(-c*x))/(c-b))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if(panel$modelo=="PG-France"){
n0 <<- try(gnls(y~a*(1-exp(-c*(x-d)-b*(sqrt(x)-sqrt(d)))), # modelo Mitscherlich (France 2000)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*(1-exp(-c*(x-d)-b*(sqrt(x)-sqrt(d)))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if(panel$modelo=="PG-Michaelis-Menten Generalizado"){
n0 <<- try(gnls(y~a*((x^c)/((x^c)+(b^c))), # modelo Michaelis-Menten Generalizado (France,2000)
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*((x^c)/((x^c)+(b^c))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if (panel$modelo=="PG-Inversa Exponencial"){
n0 <<- try(gnls(y~a*((1-exp(-c*x))/(1+b*exp(-c*x))), # modelo inversa exponencial
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*((1-exp(-c*x))/(1+b*exp(-c*x))),
add=TRUE, col="blue"))
aju <<- n0
}
}
if(panel$modelo=="PG-Gompertz I"){
#Modelo Gompertz, non-symmetrical about an inflection point M, which can be calculated from
#K = exp [–exp (cM)]
n0 <<- try(gnls(y~a*((b-b^exp(-c*x))/(b-1)),
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*((b-b^exp(-c*x))/(b-1)),
add=TRUE, col="blue"))
aju <<- n0
}
}

if(panel$modelo=="PG-Gompertz II"){
#Modelo Gompertz, non-symmetrical about an inflection point M=(1/c)*ln(c/b)
n0 <<- try(gnls(y~a*((1-exp((-b/c)*(exp(c*x)-1)))), # modelo Gompertz II
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*((1-exp((-b/c)*(exp(c*x)-1)))),
add=TRUE, col="blue"))
aju <<- n0
}

}

if(panel$modelo=="Von Bertalanffy"){
n0 <<- try(gnls(y~a*((1-exp(-c*x))^1/b), # modelo Von Bertalanffy modificado
data=da,control=controle,na.action=na.omit,
start=start))
if(class(n0)=="try-error"){
par(usr=c(0, 1, 0, 1))
text(0.5, 0.5, "Não convergiu!\nAproxime mais.", col="red", cex=2)
}else{

with(as.list(coef(n0)), curve(a*((1-exp(-c*x))^1/b),
add=TRUE, col="blue"))
aju <<- n0
}

}
panel
}

#================================================#--------------------------Seleciona subgrupo dos dados--------------------------------------------------------
#================================================
subgrupo <- function(panel){


if(panel$grupo ==""){
da<<-dados
} else{

da <<- subset(dados,subset=eval(parse(text=panel$grupo)))

}
return(panel)
}

#================================================
#--Função que cria o gráfico,e sobrepoe a curva sobre os pontos quando os sliders são #deslizados.
#================================================
vg <- function(panel){

if (panel$modelo == "Orskov & McDonald"|panel$modelo=="Michaelis-Menten"|panel$modelo=="Van Milgen"|panel$modelo=="Michaelis-Menten Generalizado"|panel$modelo=="Inversa Exponencial"|panel$modelo=="Gompertz I"|panel$modelo=="Von Bertalanffy"){

start <<-panel[c("a","b","c","d")]
}
if (panel$modelo =="France"){
## lista com valores iniciais vindos dos deslizadores
start <<- panel[c("a","b","c","d","e")]
}
if (panel$modelo == "PG-Orskov & McDonald"|panel$modelo=="PG-Michaelis-Menten"|panel$modelo=="PG-Van Milgen"|panel$modelo=="PG-Michaelis-Menten Generalizado"|panel$modelo=="PG-Inversa Exponencial"|panel$modelo=="PG-Gompertz I"|panel$modelo=="PG-Gompertz II"|panel$modelo=="PG-Von Bertalanffy"){

start<<-panel[c("a","b","c")]
}
if(panel$modelo=="PG-France"){

start<<-panel[c("a","b","c","d")]

}

par(mar=c(4.1,4.2,3.1,1))
with(da,plot(x,y,ylab= var_dep,xlab=var_indep))

if(panel$modelo =="Orskov & McDonald"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b(1-exp(-c*(x-d)))')))
with(start, curve(a+b*(1-exp(-c*(x-d))),
add=TRUE, col=2, lty=2))}

if(panel$modelo=="Michaelis-Menten"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b((x-d)/(x-d+c))')))
with(start, curve(a+b*((x-d)/(x-d+c)),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="Van Milgen"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b(1-((c*exp(-c*x))/(c-d)))')))
with(start, curve(a+b*(1-((c*exp(-d*x)-d*exp(-c*x))/(c-d))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="France"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b(1-exp(-c*(x-e)-d*(sqrt(x)-sqrt(e))))')))
with(start, curve(a+b*(1-exp(-c*(x-e)-d*(sqrt(x)-sqrt(e)))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="Michaelis-Menten Generalizado"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b((x^c)/((x^c)+(d^c)))')))
with(start, curve(a+b*((x^c)/((x^c)+(d^c))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="Inversa Exponencial"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b((1-exp(-c*x))/(1+d*exp(-c*x)))')))
with(start, curve(a+b*((1-exp(-c*x))/(1+d*exp(-c*x))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="Gompertz I"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b((d-d^exp(-c*x))/(d-1))')))
with(start, curve(a+b*((d-d^exp(-c*x))/(d-1)),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="Von Bertalanffy"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a+b((1-exp(-c*x))^1/d)')))
with(start, curve(a+b*((1-exp(-c*x))^1/d),
add=TRUE, col=2, lty=2))}
if(panel$modelo =="PG-Orskov & McDonald"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a(1-exp(-c*(x-b)))')))
with(start, curve(a*(1-exp(-c*(x-b))),
add=TRUE, col=2, lty=2))}

if(panel$modelo=="PG-Michaelis-Menten"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a((x-b)/(x-b+c))')))
with(start, curve(a*((x-b)/(x-b+c)),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-Van Milgen"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a(1-((c*exp(-b*x)-b*exp(-c*x)/(c-b)))')))
with(start, curve( a*(1-((c*exp(-b*x)-b*exp(-c*x))/(c-b))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-France"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a(1-exp(-c*(x-d)-b*(sqrt(x)-sqrt(d))))')))
with(start, curve(a*(1-exp(-c*(x-d)-b*(sqrt(x)-sqrt(d)))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-Michaelis-Menten Generalizado"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a*((x^c)/((x^c)+(b^c)))')))
with(start, curve(a*((x^c)/((x^c)+(b^c))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-Inversa Exponencial"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a*((1-exp(-c*x))/(1+b*exp(-c*x)))')))
with(start, curve(a*((1-exp(-c*x))/(1+b*exp(-c*x))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-Gompertz I"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a*((b-b^exp(-c*x))/(b-1))')))
with(start, curve(a*((b-b^exp(-c*x))/(b-1)),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-Gompertz II"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a*((1-exp((-b/c)*(exp(c*x)-1))))')))
with(start, curve(a*((1-exp((-b/c)*(exp(c*x)-1)))),
add=TRUE, col=2, lty=2))}
if(panel$modelo=="PG-Von Bertalanffy"){
## sobrepõe a curva controlada pelos deslizadores
title(main= expression(paste(Y,'=','a*((1-exp(-c*x))^1/b)')))
with(start, curve(a*((1-exp(-c*x))^1/b),
add=TRUE, col=2, lty=2))}

return(panel)
}

#================================================
#----------------mostra o resultado quando o botão ver ajuste é acionado----------------------
#================================================
verajust <- function(panel){
a<-summary(aju)
print(a)
panel
}

# cria objetos vazios que serão preenchidos durante processo
da <- c(); start <- list();
#================================================
# Gera a interface gráfica para trabalho
#================================================
panel <- rp.control()
#botão para importar banco de dados
rp.button(panel, action=database,foreground="black",background = "orange",title="IMPORTAR DADOS")
# Obtem os
#nomes das variáveis dependentes
rp.textentry(panel=panel, variable=var_y,width = 10,foreground = "black", background = "gray87",
labels="NOME DA VARIÁVEL DEPENDENTE (y):",
initval="",
action=ren_y)

rp.textentry(panel=panel, variable=var_x,width=10,foreground = "black", background = "gray87",
labels="NOME DA VARIÁVEL INDEPENDENTE(x):",
initval="",
action=ren_x)
rp.textentry(panel,variable=grupo,initval="",labels="SUBGRUPO DE DADOS", ,
foreground = "black",background="gray87",action=subgrupo)

models_name<<- c("--Modelos Dig. in Situ--","Orskov & McDonald","Inversa Polinomial","Van Milgen","France","Michaelis-Menten Generalizado","Inversa Exponencial","Gompertz I","Von Bertalanffy","--Modelos Prod. Gases--","PG-Orskov & McDonald","PG-Michaelis-Menten","PG-Van Milgen","PG-France","PG-Michaelis-Menten Generalizado","PG-Inversa Exponencial","PG-Gompertz I","PG-Gompertz II","PG-Von Bertalanffy")

mod_id<<- c("--Modelos Dig. in situ--","MOD1","MOD2","MOD3","MOD4","MOD5","MOD6","MOD7","MOD8","---Modelos Prod. Gases---","PG1","PG2","PG3","PG4","PG5","PG6","PG7","PG8","PG9")

rp.listbox(panel,modelo, vals=models_name,rows=5,title="Modelos",foreground = "black",background="gray87",action=vg)

rp.text(panel,"Parâmetros do modelo")

# controla parâmetros do modelo

rp.slider(panel, a,0.001,100.001, initval=50.001,foreground="black",background="gray87", title="a", showvalue=TRUE,showvaluewidth=4, action=vg)
rp.slider(panel, b,-5.001,5.001, initval=0.001,foreground="black",background="gray87",title="b", showvalue=TRUE,showvaluewidth=4, action=vg)
rp.slider(panel, c, -1.001,1.001, initval=0.001,foreground="black",background="gray87",title="c", showvalue=TRUE,showvaluewidth=4, action=vg)
rp.slider(panel, d, -2.001,2.001, initval=0.001,foreground="black",background="gray87", title="d", showvalue=TRUE,showvaluewidth=4, action=vg)
rp.slider(panel, e, 0.001,5.001, initval=2.5,foreground="black",background="gray87",title="e", showvalue=TRUE,showvaluewidth=4, action=vg)

# cria botão "Ajustar"
rp.button(panel, action=nlsajust,foreground="black",background = "orange", title="AJUSTAR")
rp.button(panel, action=verajust,foreground="black",background="springgreen",title="VER AJUSTE")


#================================================
Publicado em Experimentos, Regressões | Marcado com , , , , , , | 2 Comentários

Nova Versão do Rstudio liberada

RStudio-BallOs desenvolvedores do editor Rstudio anunciaram a liberação da versão v0.99.878  do  editor . O novo editor está disponível para download na página do Rstudio. O Rstudio é um dos mais utilizados editores R. A nova versão veio repleta de novidades . Um resumo é apresentado abaixo. Mais informações podem ser obtidas aqui

RStudio Addins

Fornece um meio de executar suas funções R interativamente de dentro do Rstudio (através de atalho de teclado ou através do addins menu) . Usuários podem agora escrever código R para interagir e modificar os conteúdos dos documentos abertos. Veja um exemplo do seu uso:

Você pode aprender mais sobre addins no site: http://rstudio.github.io/rstudioaddins/.

subset-addin

R Markdown

Melhoramentos para  utilização do R Markadown. Há agora uma opcional janela que permite a rápida navegação através de grandes documentos

Screen Shot 2015-12-22 at 9.27.34 AM

Adição em linha de interface de usuário para códigos chunks do knitr para rodar individual chunks, executar previous chunks e especificar opções knit comumente utilizada

Screen Shot 2015-12-22 at 9.30.11 AM

Múltipla janela de código:

Existência de duas formas de abrir uma nova janela de código:

Pop out an editor:

Tear off a pane:

Atalhos de teclado personalizáveis

Você pode customizar atalhos de teclado para executar comando de aplicações do Rstudio, comandos do editor ou de funções definidas pelo usuário.

Clique em:  ferramentas -> Modifique atalhos de teclado...:

Atalhos de teclado Emacs

  • C-p, C-n, C-b and C-f to move the cursor up, down left and right by characters
  • M-b, M-f to move left and right by words
  • C-a, C-e to navigate to the start, or end, of line;
  • C-k to ‘kill’ to end of line, and C-y to ‘yank’ the last kill,
  • C-s, C-r to initiate an Emacs-style incremental search (forward / reverse),
  • C-Space to set/unset mark, and C-w to kill the marked region.

Adicionais atalhos do Emacs Speaks Statistics (ESS) :

  • C-c C-v displays help for the object under the cursor,
  • C-c C-n evaluates the current line / selection,
  • C-x b allows you to visit another file,
  • M-C-a moves the cursor to the beginning of the current function,
  • M-C-e moves to the end of the current function,
  • C-c C-f evaluates the current function.

Atalhos que permite interagir como o IDE como normalmente é feito em Emacs

  • C-x C-n to create a new document,
  • C-x C-f to find / open an existing document,
  • C-x C-s to save the current document,
  • C-x k to close the current file
Publicado em Regressões | Deixe um comentário

Arvore de Natal com o R

arvorenatalÉ sempre bom descobrir o quanto o R é poderoso! Gosto  de acompanhar outros blogs e observar o quanto os usuários R desenvolvem idéias  utilizando essa ferramenta. Isso me inspira a aprender cada vez mais sobre o software.

No post de hoje, aproveito a proximidade do natal para  compartilhar   a árvore  criada por Kees Duineveld  e publicada no blog  Wiekvoet . Essa arvore apresenta uma riqueza de detalhes  e  mostra o quanto o R dinâmico.  Espero que ela  possa inspirar vocês a progredir em seus estudos.

Desejo a todos um feliz natal e um 2016 repleto de realizações.


part <- list(x0=0,y0=0,x1=0,y1=1,
branch1=NULL,branch2=NULL,extend=NULL,
lwd=1,depth=0,col="springgreen")

par(mfrow=c(1,1),mar=c(5, 4, 4, 2) + 0.1)

segplot <- function(tree) {
if (is.null(tree)) return()
segments(tree$x0,tree$y0,tree$x1,tree$y1,
col=tree$col,
lwd=tree$lwd)
segplot(tree$branch1)
segplot(tree$branch2)
segplot(tree$extend)
}
#--------------------------------segplot(part)---------------------------------------
<p style="text-align: left;">grow <- function(tree) {
if (is.null(tree) ) return(NULL)

tree$lwd=tree$lwd*1.2

if (tree$lwd>2.5) tree$col <- "brown"
if (is.null(tree$extend)) {
tree$extend <- list(
x0=tree$x1,
y0=tree$y1,
x1=rnorm(1,1,.03)*(2*tree$x1-tree$x0),
y1=(rnorm(1,.98,.02)+.02*(tree$x1==tree$x0))*(2*tree$y1-tree$y0),
branch1=NULL,
branch2=NULL,
extend=NULL,
lwd=1,
depth=tree$depth,
col=tree$col
)
length=sqrt((tree$x1-tree$x0)^2 + (tree$y1-tree$y0)^2)
angle <- asin((tree$x1-tree$x0)/length)
branch <- list(
x0=(tree$x1+tree$x0)/2,
y0=(tree$y1+tree$y0)/2,
branch1=NULL,
branch2=NULL,
extend=NULL,
lwd=1,
depth=tree$depth,
col=tree$col
)
shift <- rnorm(2,.5,.1)
branch$x0 <- shift[1]*tree$x1+(1-shift[1])*tree$x0
branch$y0 <- shift[1]*tree$y1+(1-shift[1])*tree$y0
length=length*rnorm(1,.5,.05)
co <- runif(1,.35,.45)
branch$x1 <- branch$x0+sin(angle+co)*length
branch$y1 <- branch$y0+cos(angle+co)*length
tree$branch1 <- branch
branch$x0 <- shift[2]*tree$x1+(1-shift[2])*tree$x0
branch$y0 <- shift[2]*tree$y1+(1-shift[2])*tree$y0
co <- runif(1,.35,.45)
branch$x1 <- branch$x0+sin(angle-co)*length
branch$y1 <- branch$y0+cos(angle-co)*length
tree$branch2 <- branch
} else {
tree$branch1 <- grow(tree$branch1)
tree$branch2 <- grow(tree$branch2)
tree$extend <- grow(tree$extend)
}
tree$depth <- tree$depth+1
if (tree$depth>2) tree$col <- "green"
if (tree$depth>4) tree$col <- "darkgreen"
if (tree$depth>6) tree$col <- "brown"

tree
}
tree <- part
for (i in 1:9) tree <- grow(tree)</p>
#-------------determina o local onde salvar a imagem ---------------

#setwd("~/Documentos/ProjetosR")#usuários linux

#---------------------------------------------------------------------------------------

setwd("c:/Documentos/minhapasta") #usuários windows
png(filename="arvorenatal.png")
par(mar=c(0,0,0,0))
plot(x=c(-3,3),y=c(0,9),type="n",axes=FALSE,xlab="",ylab="")
segplot(tree)
dev.off()
Publicado em Aplicacao | Marcado com , | Deixe um comentário

Livros R gratuitos para download

54645555O software R é uma poderosa ferramenta para a realização análises de dados.  Por ser o R um ambiente de programação, praticamente toda análise pode ser realizada utilizando as ferramentas disponíveis no pacote base ou utilizando as ferramentas disponíveis nas centenas de pacotes desenvolvidos por voluntários ao redor do mundo e disponibilizado no CRAN.  Aquilo que ainda não foi implementado poderá ser implementado e distribuído aos demais usuários ao redor do mundo.

O desenvolvimento em R entretanto exige estudo e uma constante atualização para que o usuário tire o máximo de proveito de suas funcionalidades. Para isso o R conta com um vasto número de publicações (1 , 2) na forma de livros, tutoriais,  apresentações, conteúdos on line, vídeos, etc. Muito destas publicações são disponibilizadas para downloada gratuitamente pelos seus autores o que torna mais fácil a compreensão da linguagem R aplicada a análises específicas.

No post de hoje disponibilizo vários links para diversos materiais sobre o software R (livros, tutoriais, apresentações, sites) que foram disponibilizados ,gratuitamente, pelos seus autores. Esta é entretanto uma lista parcial e novas atualizações ocorrerão. Caso conheça algum material e queiram compartilha-lo aqui no blog, deixe uma mensagem.

Bom estudo!

  1. Introduction to probability and statistics using R : https://cran.r-project.org/web/packages/IPSUR/vignettes/IPSUR.pdf
  2.  An introduction to R: https://cran.r-project.org/doc/manuals/R-intro.pdf
  3. The art of R programming: http://heather.cs.ucdavis.edu/~matloff/132/NSPpart.pdf
  4. A little book of r for multivariate analysis: https://media.readthedocs.org/pdf/little-book-of-r-for-multivariate-analysis/latest/little-book-of-r-for-multivariate-analysis.pdf
  5. Introduction to statistical learning with application in R: http://www-bcf.usc.edu/~gareth/ISL/ISLR%20First%20Printing.pdf
  6. Statistical foundations of machine learning: https://www.otexts.org/book/sfml (disponível para leitura on line)
  7. Advanced R: http://adv-r.had.co.nz/ (disponível para leitura on line)
  8. The elementals of statistical learning: http://statweb.stanford.edu/~tibs/ElemStatLearn/printings/ESLII_print10.pdf
  9. An Introduction to R:Software for Statistical Modelling & Computing: http://cran.r-project.org/doc/contrib/Kuhnert+Venables-R_Course_Notes.zip
  10. Using r for data analysis and graphics: https://cran.r-project.org/doc/contrib/usingR.pdf
  11. R for SAS and SPSS users: https://docs.google.com/viewer?a=v&pid=sites&srcid=ZGVmYXVsdGRvbWFpbnxyNHN0YXRpc3RpY3N8Z3g6MWNmZDQ4ZjcwODY2Y2I0Yw
  12. The r guide: https://cran.r-project.org/doc/contrib/Owen-TheRGuide.pdf
  13. Introduction to r project for statistical computing for use in ITC: https://cran.r-project.org/doc/contrib/Rossiter-RIntro-ITC.pdf
  14. R for beginners: https://cran.r-project.org/doc/contrib/Paradis-rdebuts_en.pdf
  15. R tips: http://pj.freefaculty.org/R/Rtips.pdf
  16. Introduction to Probability and Statistics Using R: http://download.savannah.gnu.org/releases/ipsur/
  17. Statistics with R : http://zoonek2.free.fr/UNIX/48_R/all.html
  18. R programming : https://en.wikibooks.org/wiki/R_Programming
  19. R inferno : http://www.burns-stat.com/pages/Tutor/R_inferno.pdf
  20. The undergraduate guide to R : https://sites.google.com/site/undergraduateguidetor/manual-files
  21. Simply R: https://cran.r-project.org/doc/contrib/Verzani-SimpleR.pdf
  22. Practical Regression and Anova in R: http://www.maths.bath.ac.uk/~jjf23/book/
  23. Introduction to Statistical Thinking : http://pluto.huji.ac.il/~msby/StatThink/index.html
  24. A little e-book of r for biomedical statistics: http://a-little-book-of-r-for-biomedical-statistics.readthedocs.org/en/latest/index.html
  25. Introdução ao uso do programa R : https://cran.r-project.org/doc/contrib/Landeiro-Introducao.pdf
  26. introdução à Linguagem R para Pós-Graduandos em Ecologia: http://ecologia.ib.usp.br/bie5782/doku.php?id=start
  27. Introdução ao ambiente estatístico R : http://www.leg.ufpr.br/~paulojus/embrapa/Rembrapa/Rembrapa.pdf
  28. Curso de introdução a R: http://www.iesc.ufrj.br/cursos/bioestatistica/topicosanalisedadosII_R/AULA%20R%20IESC%202011%2002.pdf
  29. Minicurso de estatística básica-Introdução ao R: http://www.uft.edu.br/engambiental/prof/catalunha/arquivos/r/r_bruno.pdf
  30. Introdução ao ambiente computacional R: http://www.ufscar.br/~des/docente/josemar/152056/05082008/tutoport-apostilaR_monitoria.pdf
  31. Introdução a estatística básica com R: http://www.quintiliano.prof.ufu.br/index_arquivos/EBR.pdf
  32. Tópicos de estatística com R : https://cran.r-project.org/doc/contrib/Itano-descriptive-stats.pdf
  33. Estatística aplicada a ecologia usando R : https://cran.r-project.org/doc/contrib/Provete-Estatistica_aplicada.pdf
  34. Laboratório de estatística e geoinformação da UFPR : http://www.leg.ufpr.br/doku.php/sofware:material-r
  35. Simpósio de estatística aplicada a experimentação agronômica : http://sigeve.ead.unesp.br/paginas/din.php?p=101
  36. Curso de capacitação no ambiente R : http://www.leg.ufpr.br/~walmes/cursoR/cursoR4.pdf
Publicado em Livros | Marcado com | Deixe um comentário

R Versão 3.2.3 liberada

RlogoNo último dia 10/12/2015 foi liberada a nova versão do R. A versão 3.2.3, codenome “Wooden Christmas-Tree” (árvore natal de madeira) as principais alterações podem ser acessadas na página do r-announce, feitas por Peter Dalgaard.

Usuários Windows podem atualizar seu sistema com o código abaixo:

if(!require(installr)) {install.packages("installr"); require(installr)}updateR()

Usuários linux devem incluir em sua sources.list (/etc/apt/sources.list) os seguintes diretórios de acordo com sua distro e  versão. Inclua seu favorito cran mirror no local indicado.

#Ubuntu wily:

deb https://<my.favorite.cran.mirror>/bin/linux/ubuntu wily/

#Ubuntu vivid

deb https://<my.favorite.cran.mirror>/bin/linux/ubuntu vivid/

#Ubuntu trusty

deb https://<my.favorite.cran.mirror>/bin/linux/ubuntu trusty/

#Debian Jessie

deb http://<favourite-cran-mirror>/bin/linux/debian jessie-cran3/

Abra o terminal e digite

 sudo apt-get update 

ou utilize o utilitário de atualização de pacotes existentes em sua distro.

OBS:

Por ser uma liberação recente pode ocorrer que a nova versão ainda não  esteja disponível em seu cran mirror, e neste caso a atualização não ocorrerá. Neste caso você pode mudar o seu cran mirror, aguardar a inclusão no CRAN mirror ou baixar e instalar o diretamente do cran da seguinte forma

baixe o arquivo R-3.2.2.tar.gz do CRAN para algum local em seu computador. Você pode se orientar por  Aqui 

Publicado em R Notícias | Marcado com , | Deixe um comentário

Entendendo o uso das funções apply, lapply, sapply, tapply, mapply

use apply        A família Apply representa um conjunto de funções básicas do R que permite realizar operações sobre os dados contidos nas várias estruturas disponíveis (vetor, data frame, listas). digite no prompt R o seguinte comando

 ??base::apply 

e você verá o conjunto de funções pertencentes a esta família,algumas delas não serão tratadas neste post.

A utilização destas funções permitem automatizar a aplicação das operações desejadas, permitindo assim ganhos de velocidade durante procedimentos que necessitam ser repetidos sobre todos os dados. No post de hoje vamos ver o funcionamento destas funções. Para iniciar vamos ver como funciona a função apply. O entendimento desta função permitirá a compreensão das demais.

Função Apply:

Considere a seguinte matriz 3×4 contendo números de 1 a 12 preenchidos por linha.


A <- matrix(1:12,nrow=3,byrow=TRUE)
 A #veja a matriz

Vamos supor que desejamos saber o valor total de cada linha desta matriz. Isto poderia ser feito manualmente da seguinte forma:

linha1<-sum(A[1,]) # soma os elementos da linha 1
 linha2<-sum(A[2,]) # soma os elementos da linha 2
 linha3<-sum(A[3,]) # soma os elementos da linha 3

Este processo é de longe a pior escolha. Para grandes conjuntos de dados ele se torna desgastante. No entanto podemos observar que há um padrão nos comandos utilizados, a função sum() é aplicada repetidamente sobre a matriz e somente o identificador da linha altera em cada procedimentos.

Podemos  desenvolver uma função que automatize este processo. Esta função deve receber a estrutura contendo os dados, o sentido de busca (linha ou coluna) e a função que deve ser aplicada. A simples função abaixo pode ser utilizada com uma matriz ou data frame. O argumento “sentido” deve receber os valores “linha” ou “Coluna” (entre aspas). O argumento “função” pode ser uma função base do R (mean, sum, sd, min, max,…) ou uma função definida pelo usuário.


minhafunçãoApply <- function(x,sentido,função){

#sentido: "linha" ou "coluna"
 resultado <- c()
 fc<-função
 if(sentido==){
 for (i in 1:nrow(x)){

resultado[i]<- fc(x[i,])

}
 }

else{
 for (i in 1:ncol(x)){
 resultado[i] <- fc(x[,i])
 }
 }

return(resultado)
 }

minhafunçãoApply(A,sentido="linha",sum)

[1] 10 26

No exemplo acima a função base sum() foi aplicada a cada linha da matriz A e o resultado foi retornado (10,26,42). O mesmo resultado pode ser obtido com a função apply.
A função Apply, presente no pacote base, necessita de 3 argumentos para seu funcionamento: a matriz ou data frame contendo os dados, a indicação do sentido de aplicação da função, representado pelos números 1 (linha) ou 2 (coluna) e a função a ser aplicada

> apply(A,1,sum)

[1] 10 26 42

Podemos também adicionar nossa pŕopria função:


#Função para adicionar 10 ao total da linha ou coluna

funcao_usuario <- function(x){

return(sum(x)+10)

}

minhafuncao( A,sentido="linha",funcao_usuario) ou

[1] 20 36 52

apply(A, 1, funcao_usuario)

[1] 20 36 52

Funções lapply e sapply

As funções lapply e sapply são uma variação utilizada para aplicar um procedimento aos elementos de uma lista. Esta funções diferem somente na forma como os resultados são mostrados. Para a função lapply o resultado esta na forma de lista, enquanto na sapply o resultado é apresentado na forma de vetor.


set.seed(5)
#Cria uma lista contendo os vetores "consumo", "peso" e um data frame "data" contendo duas colunas (a e b) com 10 linhas
minhalista <- list( consumo=c(1.25, 1.54,1.45) , peso = c(45,50,53),data=data.frame(a=rep(1:5,each=2),b=rnorm(10)))

#Soma todos cada um dos elementos da lista e retorna uma lista com os valores
lapply(minhalista,sum)
$consumo
[1] 4.24

$peso
[1] 148

$data
[1] 29.21148
#Soma todos cada um dos elementos da lista e retorna um vetor com os valores
> sapply(minhalista,sum)
consumo peso data
4.24000 148.00000 29.21148

#Soma somente as colunas do elemento data(um dataframe) retorna uma lista com os valores
> lapply(minhalista$data,sum)
$a
[1] 30

$b
[1] -0.7885155

Também é possível utilizar função definida pelo usuário


lapply(minhalista$data,funcao_usuario) # adiciona 10 a cada elemendo do dataframe de nome data contido na lista e soma cada coluna deste dataframe

Tapply

A função tapply é utilizada para aplicar um procedimento a diferentes partes dos dados dentro de um array, matriz ou data frame. Ela difere das demais funções vista até aqui por exigir a existencia de uma variável categórica o qual servirá para agrupar os dados aos diferentes níveis. Ela é muito útil quando queremos saber, por exemplo, a média de cada um dos tratamentos avaliados em um experimento.

A função tapply utiliza 3 argumentos: (1)A estrutura contendo os dados (vetor,matriz,data frame, array) onde será aplicada a operação; (2) Um vetor de variáveis categóricas que determina a estrutura dos dados; (3) a função que desejamos aplicar.


consumo <- c(13.10,15.20,16.10,14.75,15.35,16.20) #cria o vetor de resposta
grupo<-as.factor(c("15%PB","18%PB","18%PB","15%PB","15%PB","18%PB"))#cria vetor de fatores indicando o grupo experimental
#Obtêm a média de consumo em função do concentração de PB da dieta
tapply(consumo,grupo,mean)

mapply

A função mapply é uma versão multivariada da função lapply e sapply. As funções lapply e sapply atuam somente sobre os elementos de uma única lista. No caso da função mapply a função é aplicada sobre o primeiro elemento de cada um dos argumentos, em seguida ao segundo elemento, seguindo ao terceiro, e assim por diante. Os argumentos podem ser listas ou vetores. Vamos ver um simples exemplo para ilustrar seu funcionamento


a<-c(1,2,3,4)
b<-c(5,6,7,8)
mapply(sum, a,b) #soma os elementos dos vetores a e b

O que fizemos ao utilizar esta função foi:


(a[1]+b[1]);(a[2]+b[2]);(a[3]+b[3]);(a[4]+b[4])

Vejamos outro exemplo utilizando uma lista:


L1 <- list(a = LETTERS[c(4,6,12,6)], b = LETTERS[c(1,5,21,1)])
L2 <- list(c = LETTERS[c(4,14,22,20)], d = LETTERS[c(15,15,1,15)])
#duas listas L1 e L2 contendo os elementos a,b e c,d respectivamente contendo letras do alfabeto
#visualize as listas
L1
L2
# une as letras, contidas na mesma posição de cada vetor da lista L1 e L2 para escrever as palavras DADO, FENO,LUVA e FATO
mapply(paste, l1$a, l1$b, l2$c, l2$d)

Publicado em Dicas R | Marcado com , , , | Deixe um comentário