laba4

#НОРМАЛЬНОЕ
N_median<-vector(length = 1000)
N_mad<-vector(length = 1000)
N_s<- vector(length = 1000)
N_mean <- vector(length = 1000)
N_iqr<-vector(length = 1000)
N_sigma_a <- 0
N_sigma_b <- 0
N_tuky <- 0
N_UQ <-0
N_LQ <-0
N_k <- 0
N_m <- 0
N_z<-0


for(i in 1:1000)
{
  n<-rnorm(100, mean = 0, sd =1)
  n<-sort(n)

  N_mean[i]<-mean(n)
  N_s[i]<-sd(n, FALSE)
  N_median[i]<-median(n)
  N_mad[i]<-mad(n, median(n), 1.46, FALSE, FALSE, FALSE)
  N_iqr<-IQR(n)
  N_UQ <- n[75]
  N_LQ <- n[25]

  for (j in 1:100){
    if( (abs(n[j] - N_mean[i]) / (N_s[i]))>3) {N_k<-N_k+1}
    if ( (abs (n[j] - N_median[i]) / (N_mad[i]))>3) {N_m<-N_m+1}
    if ((n[j] > (N_UQ + 3/2*(N_iqr)))| (n[j] < (N_LQ - 3/2*(N_iqr)))) {N_z<-N_z+1}
  }
}

N_sigma_a <- N_k/1000
N_sigma_b <- N_m/1000
N_tuky <- N_z/1000

#Равномерное
R_median<-vector(length = 1000)
R_mad<-vector(length = 1000)
R_s<- vector(length = 1000)
R_mean <- vector(length = 1000)
R_iqr<-vector(length = 1000)
R_sigma_a <- 0
R_sigma_b <- 0
R_tuky <- 0
R_UQ <-0
R_LQ <-0
R_k <- 0
R_m <- 0
R_z<-0

for(i in 1:1000)
{
  r<-runif(100, min = -sqrt(3), max = sqrt(3))
  r<-sort(r)

  R_mean[i]<-mean(r)
  R_s[i]<-sd(r, FALSE)
  R_median[i]<-median(r)
  R_mad[i]<-mad(r, median(r), 1.46, FALSE, FALSE, FALSE)
  R_iqr<-IQR(r)
  R_UQ <- r[75]
  R_LQ <- r[25]

  for (j in 1:100){
    if( (abs(r[j] - R_mean[i]) / (R_s[i]))>3) {R_k<-R_k+1}
    if ( (abs (r[j] - R_median[i]) / (R_mad[i]))>3) {R_m<-R_m+1}
    if ((r[j] > (R_UQ + 3/2*(R_iqr)))| (r[j] < (R_LQ - 3/2*(R_iqr)))) {R_z<-R_z+1}
  }
}

R_sigma_a <- R_k/1000
R_sigma_b <- R_m/1000
R_tuky <- R_z/1000

#Лапласс
L_median<-vector(length = 1000)
L_mad<-vector(length = 1000)
L_s<- vector(length = 1000)
L_mean <- vector(length = 1000)
L_iqr<-vector(length = 1000)
L_sigma_a <- 0
L_sigma_b <- 0
L_tuky <- 0
L_UQ <-0
L_LQ <-0
L_k <- 0
L_m <- 0
L_z<-0

for(i in 1:1000)
{
  l<-rlaplace(100,0,1/sqrt(2))
  l<-sort(l)

  L_mean[i]<-mean(l)
  L_s[i]<-sd(l, FALSE)
  L_median[i]<-median(l)
  L_mad[i]<-mad(l, median(l), 1.46, FALSE, FALSE, FALSE)
  L_iqr<-IQR(l)
  L_UQ <- l[75]
  L_LQ <- l[25]

  for (j in 1:100){
    if( (abs(l[j] - L_mean[i]) / (L_s[i]))>3) {L_k<-L_k+1}
    if ( (abs (l[j] - L_median[i]) / (L_mad[i]))>3) {L_m<-L_m+1}
    if ((l[j] > (L_UQ + 3/2*(L_iqr)))| (l[j] < (L_LQ - 3/2*(L_iqr)))) {L_z<-L_z+1}
  }
}

L_sigma_a <- L_k/1000
L_sigma_b <- L_m/1000
L_tuky <- L_z/1000

#Коши
K_median<-vector(length = 1000)
K_mad<-vector(length = 1000)
K_s<- vector(length = 1000)
K_mean <- vector(length = 1000)
K_iqr<-vector(length = 1000)
K_sigma_a <- 0
K_sigma_b <- 0
K_tuky <- 0
K_UQ <-0
K_LQ <-0
K_k <- 0
K_m <- 0
K_z<-0

for(i in 1:1000)
{
  x<-rcauchy(100, location=0, scale=1)
  x<-sort(x)

  K_mean[i]<-mean(x)
  K_s[i]<-sd(x, FALSE)
  K_median[i]<-median(x)
  K_mad[i]<-mad(x, median(x), 1.46, FALSE, FALSE, FALSE)
  K_iqr<-IQR(x)
  K_UQ <- x[75]
  K_LQ <- x[25]

  for (j in 1:100){
    if( (abs(x[j] - K_mean[i]) / (K_s[i]))>3) {K_k<-K_k+1}
    if ( (abs (x[j] - K_median[i]) / (K_mad[i]))>3) {K_m<-K_m+1}
    if ((x[j] > (K_UQ + 3/2*(K_iqr)))| (x[j] < (K_LQ - 3/2*(K_iqr)))) {K_z<-K_z+1}
  }
}

K_sigma_a <- K_k/1000
K_sigma_b <- K_m/1000
K_tuky <- K_z/1000

#GEM
GEM_median<-vector(length = 1000)
GEM_mad<-vector(length = 1000)
GEM_s<- vector(length = 1000)
GEM_mean <- vector(length = 1000)
GEM_iqr<-vector(length = 1000)
GEM_sigma_a <- 0
GEM_sigma_b <- 0
GEM_tuky <- 0
GEM_UQ <-0
GEM_LQ <-0
GEM_k <- 0
GEM_m <- 0
GEM_z<-0
x<-vector(length=100);

for(i in 1:1000)
{
  for (n in 1:100){
  alpha<-runif(1,0,1)
  if (alpha>0.1) { x[n] <- rnorm(1, 0, 1)  }
  else { x[n] <- rnorm(1,0,10) }
  }

  x<-sort(x)

  GEM_mean[i]<-mean(x)
  GEM_s[i]<-sd(x, FALSE)
  GEM_median[i]<-median(x)
  GEM_mad[i]<-mad(x, median(x), 1.46, FALSE, FALSE, FALSE)
  GEM_iqr<-IQR(x)
  GEM_UQ <- x[75]
  GEM_LQ <- x[25]

  for (j in 1:100){
    if( (abs(x[j] - GEM_mean[i]) / (GEM_s[i]))>3) {GEM_k<-GEM_k+1}
    if ( (abs (x[j] - GEM_median[i]) / (GEM_mad[i]))>3) {GEM_m<-GEM_m+1}
    if ((x[j] > (GEM_UQ + 3/2*(GEM_iqr)))| (x[j] < (GEM_LQ - 3/2*(GEM_iqr)))) {GEM_z<-GEM_z+1}
  }
}

GEM_sigma_a <- GEM_k/(1000)
GEM_sigma_b <- GEM_m/(1000)
GEM_tuky <- GEM_z/1000