r_lab1

2343 days ago by macieksk

%html <a href="http://sage.mimuw.edu.pl/help/">Pomoc do notatnika Sage</a> 
       
# Podswietlanie skladni - tylko przy pomocy wtyczek do przegladarki: # It's All Text : https://addons.mozilla.org/en-US/firefox/addon/its-all-text/ 
       
%r #%r - dyrektywa przelaczajaca tryb pracy na srodowisko R # Tryb R mozna takze wlaczyc stale w pasku na gorze # Przyklad wykresu hist(rnorm(1000),breaks=30) dev.off() 
       
null device 
          1 
%sage #Mała próbka środowiska Sage (to jest python + moduły sage) R = PolynomialRing(QQ,"x") x = R.gen() p = x^2 + 1 p.derivative() 
       
2*x
show(p.integral()) 
       
\newcommand{\Bold}[1]{\mathbf{#1}}\frac{1}{3} x^{3} + x
f1 = x -1 f2 = 0*x+2 f = Piecewise([[(0,pi/2),f1],[(pi/2,pi),f2]]) show(f) 
       
\newcommand{\Bold}[1]{\mathbf{#1}}\begin{cases} x - 1 &\text{on $(0, 1/2*pi)$}\cr 2 &\text{on $(1/2*pi, pi)$}\cr \end{cases}
latex(f) 
       
\begin{cases}
x - 1 &\text{on $(0, 1/2*pi)$}\cr
2 &\text{on $(1/2*pi, pi)$}\cr
\end{cases}
%latex $ \begin{cases} x - 1 &\text{on $(0, 1/2*pi)$}\cr 2 &\text{on $(1/2*pi, pi)$}\cr \end{cases} $ 
       
%html <h1>Zadanie 1</h1> Przeczytaj o metodzie <a href=http://en.wikipedia.org/wiki/Fair_coin#Fair_results_from_a_biased_coin>Fair_results_from_a_biased_coin</a> <p> Przeczytaj poniższy kod R</p> 
       

Zadanie 1

Przeczytaj o metodzie Fair_results_from_a_biased_coin

Przeczytaj poniższy kod R

%r faircoin1 <- function(c1,c2){ if (c1==c2) NA else c1 } 
       
%r faircoin1(F,F) faircoin1(T,F) faircoin1(T,T) faircoin1(F,T) 
       
[1] NA
[1] TRUE
[1] NA
[1] FALSE
%r # Losujemy monete niefair v <- rnorm(20000, 0.5) < 0 head(v) summary(v) 
       
[1] FALSE FALSE FALSE FALSE FALSE  TRUE
   Mode   FALSE    TRUE    NA's 
logical   13741    6259       0 
%r #Make-it-fair - przeczytaj help do funkcji mapply res <- mapply(faircoin1, v[1:10000], v[10001:20000]) summary(res) summary(res[!is.na(res)]) 
       
   Mode   FALSE    TRUE    NA's 
logical    2196    2121    5683 
   Mode   FALSE    TRUE    NA's 
logical    2196    2121       0 
%html <h1>Zadanie 1 c.d.</h1> <p>Napisz funkcję <b>faircoin</b>(nf_vec), gdzie nf_vec to wektor losowań monetą niefair. Użyj funkcji <b>matrix</b>(...,ncol=2) by podzielić wektor na 2 wektory równej długości, sprawdź parzystość.</p> <p>Wynikiem <b>faircoin</b> powinien być wektor losowań monetą "fair" (bez elementów NA - użyj funkcji <b>is.na</b> i indeksowania wektorów zmiennymi boolowskimi). </p> Wykonuj operacje wektorowo (==). Można użyc wbudowanej funkcji <b>ifelse</b> (która działa wektorowo). </p> <p>Przetestuj funkcję. Wykonaj także testy używając funkcji <b>binom.test</b></p> 
       

Zadanie 1 c.d.

Napisz funkcję faircoin(nf_vec), gdzie nf_vec to wektor losowań monetą niefair. Użyj funkcji matrix(...,ncol=2) by podzielić wektor na 2 wektory równej długości, sprawdź parzystość.

Wynikiem faircoin powinien być wektor losowań monetą "fair" (bez elementów NA - użyj funkcji is.na i indeksowania wektorów zmiennymi boolowskimi).

Wykonuj operacje wektorowo (==). Można użyc wbudowanej funkcji ifelse (która działa wektorowo).

Przetestuj funkcję. Wykonaj także testy używając funkcji binom.test

%html <h1>Zadanie 2 </h1> Przeczytaj o metodzie rejection sampling, przeczytaj <a href=http://en.wikipedia.org/wiki/Rejection_sampling#Examples>przykład o losowaniu jednostajnym z koła.</a> <p> Napisz funckję <b>rucircle(n)</b>, która wylosuje n punktów (par (x,y)) jednostajnie z wnętrza koła o promieniu 1.</p> <p> W implementacji użyj rejection sampling: wylosuj punkty jednostajnie z kwadratu za pomocą <b>runif</b> i odrzuć punkty spoza koła. </p> <p>Użyj odpowiedniej estymacji potrzebnych losowań funkcją runif (pole kwadaratu/pole kola). Pamiętaj, że estymacja może być niewystarczająca - losuj, aż otrzymasz n punktów.</p> <p>Przetestuj funkcję. Sprawdź, czy kąt i promień mają odpowiednie rozkłady przy pomocy histogramów.</p> 
       

Zadanie 2

Przeczytaj o metodzie rejection sampling, przeczytaj przykład o losowaniu jednostajnym z koła.

Napisz funckję rucircle(n), która wylosuje n punktów (par (x,y)) jednostajnie z wnętrza koła o promieniu 1.

W implementacji użyj rejection sampling: wylosuj punkty jednostajnie z kwadratu za pomocą runif i odrzuć punkty spoza koła.

Użyj odpowiedniej estymacji potrzebnych losowań funkcją runif (pole kwadaratu/pole kola). Pamiętaj, że estymacja może być niewystarczająca - losuj, aż otrzymasz n punktów.

Przetestuj funkcję. Sprawdź, czy kąt i promień mają odpowiednie rozkłady przy pomocy histogramów.

%html http://cran.r-project.org/doc/manuals/R-intro.html#Index-vectors 
       
http://cran.r-project.org/doc/manuals/R-intro.html#Index-vectors
%r #Operacje na liczbach całkowitych - mod, div - przydatne do sprawdzania parzystości. ?"%%" 
       
Arithmetic                package:base                 R
Documentation

_A_r_i_t_h_m_e_t_i_c _O_p_e_r_a_t_o_r_s

_D_e_s_c_r_i_p_t_i_o_n:

     These binary operators perform arithmetic on numeric or complex
     vectors (or objects which can be coerced to them).

_U_s_a_g_e:

     x + y
     x - y
     x * y
     x / y
     x ^ y
     x %% y
     x %/% y
     
_A_r_g_u_m_e_n_t_s:

    x, y: numeric or complex vectors or objects which can be coerced
to
          such, or other objects for which methods have been
written.

_D_e_t_a_i_l_s:

     The binary arithmetic operators are generic functions: methods
can
     be written for them individually or via the 'Ops' group generic
     function.  (See 'Ops' for how dispatch is computed.)

     If applied to arrays the result will be an array if this is
     sensible (for example it will not if the recycling rule has
been
     invoked).

     Logical vectors will be coerced to integer or numeric vectors,
     'FALSE' having value zero and 'TRUE' having value one.

     '1 ^ y' and 'y ^ 0' are '1', _always_.  'x ^ y' should also
give
     the proper limit result when either argument is infinite (i.e.,
     '+- Inf').

     Objects such as arrays or time-series can be operated on this
way
     provided they are conformable.

     For real arguments, '%%' can be subject to catastrophic loss of
     accuracy if 'x' is much larger than 'y', and a warning is given
if
     this is detected.

_V_a_l_u_e:

     These operators return vectors containing the result of the
     element by element operations.  The elements of shorter vectors
     are recycled as necessary (with a 'warning' when they are
recycled
     only _fractionally_).  The operators are '+' for addition, '-'
for
     subtraction, '*' for multiplication, '/' for division and '^'
for
     exponentiation.

     '%%' indicates 'x mod y' and '%/%' indicates integer division. 
It
     is guaranteed that 'x == (x %% y) + y * ( x %/% y )' (up to
     rounding error) unless 'y == 0' where the result is
'NA_integer_'
     or 'NaN' (depending on the 'typeof' of the arguments).  See
<URL:
     http://en.wikipedia.org/wiki/Modulo_operation> for the
rationale.

     If either argument is complex the result will be complex, and
if
     one or both arguments are numeric, the result will be numeric. 
If
     both arguments are integer, the result of '/' and '^' is
numeric
     and of the other operators integer (with overflow returned as
'NA'
     with a warning).

     The rules for determining the attributes of the result are
rather
     complicated.  Most attributes are taken from the longer
argument,
     the first if they are of the same length.  Names will be copied
     from the first if it is the same length as the answer,
otherwise
     from the second if that is.  For time series, these operations
are
     allowed only if the series are compatible, when the class and
     'tsp' attribute of whichever is a time series (the same, if
both
     are) are used.  For arrays (and an array result) the dimensions
     and dimnames are taken from first argument if it is an array,
     otherwise the second.

_S_4 _m_e_t_h_o_d_s:

     These operators are members of the S4 'Arith' group generic,
and
     so methods can be written for them individually as well as for
the
     group generic (or the 'Ops' group generic), with arguments
'c(e1,
     e2)'.

_N_o_t_e:

     '**' is translated in the parser to '^', but this was
undocumented
     for many years.  It appears as an index entry in Becker _et al_
     (1988), pointing to the help for 'Deprecated' but is not
actually
     mentioned on that page.  Even though it has been deprecated in
S
     for 20 years, it is still accepted.

_R_e_f_e_r_e_n_c_e_s:

     Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New
S
     Language_.  Wadsworth & Brooks/Cole.

_S_e_e _A_l_s_o:

     'sqrt' for miscellaneous and 'Special' for special mathematical
     functions.

     'Syntax' for operator precedence.

     '%*%' for matrix multiplication.

_E_x_a_m_p_l_e_s:

     x <- -1:12
     x + 1
     2 * x + 3
     x %% 2 #-- is periodic
     x %/% 5