kopia lustrzana https://github.com/gabrielegilardi/SignalFilters
start meboot function
rodzic
f080286c3d
commit
9763bbb652
|
@ -0,0 +1,246 @@
|
||||||
|
|
||||||
|
#meboot <- function(x, reps=999, trim=0.10, reachbnd=TRUE,
|
||||||
|
# expand.sd=TRUE, force.clt=TRUE, elaps=FALSE,
|
||||||
|
# colsubj, coldata, coltimes, ...){
|
||||||
|
# UseMethod("meboot", x)
|
||||||
|
#}
|
||||||
|
|
||||||
|
meboot <- function(x, reps=999, trim=list(trim=0.10, xmin=NULL, xmax=NULL), reachbnd=TRUE,
|
||||||
|
expand.sd=TRUE, force.clt=TRUE,
|
||||||
|
scl.adjustment = FALSE, sym = FALSE, elaps=FALSE,
|
||||||
|
colsubj, coldata, coltimes,...)
|
||||||
|
{
|
||||||
|
if ("pdata.frame" %in% class(x))
|
||||||
|
{
|
||||||
|
res <- meboot.pdata.frame (x, reps, trim$trim, reachbnd,
|
||||||
|
expand.sd, force.clt, scl.adjustment, sym, elaps,
|
||||||
|
colsubj, coldata, coltimes, ...)
|
||||||
|
return(res)
|
||||||
|
}
|
||||||
|
|
||||||
|
if (reps == 1 && isTRUE(force.clt))
|
||||||
|
{
|
||||||
|
force.clt <- FALSE
|
||||||
|
warning("force.clt was set to FALSE since the ensemble contains only one replicate.")
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!is.list(trim)) {
|
||||||
|
trimval <- trim
|
||||||
|
} else {
|
||||||
|
trimval <- if (is.null(trim$trim)) 0.1 else trim$trim
|
||||||
|
}
|
||||||
|
|
||||||
|
ptm1 <- proc.time()
|
||||||
|
|
||||||
|
n <- length(x)
|
||||||
|
|
||||||
|
# Sort the original data in increasing order and
|
||||||
|
# store the ordering index vector.
|
||||||
|
|
||||||
|
xx <- sort(x)
|
||||||
|
ordxx <- order(x)
|
||||||
|
#ordxx <- sort.int(x, index.return=TRUE)
|
||||||
|
|
||||||
|
# symmetry
|
||||||
|
|
||||||
|
if (sym)
|
||||||
|
{
|
||||||
|
xxr <- rev(xx) #reordered values
|
||||||
|
xx.sym <- mean(xx) + 0.5*(xx - xxr) #symmetrized order stats
|
||||||
|
xx <- xx.sym #replace order stats by symmetrized ones
|
||||||
|
}
|
||||||
|
|
||||||
|
# Compute intermediate points on the sorted series.
|
||||||
|
|
||||||
|
z <- rowMeans(embed(xx, 2))
|
||||||
|
|
||||||
|
# Compute lower limit for left tail ('xmin') and
|
||||||
|
# upper limit for right tail ('xmax').
|
||||||
|
# This is done by computing the 'trim' (e.g. 10%) trimmed mean
|
||||||
|
# of deviations among all consecutive observations ('dv').
|
||||||
|
# Thus the tails are uniform distributed.
|
||||||
|
|
||||||
|
dv <- abs(diff(as.numeric(x)))
|
||||||
|
dvtrim <- mean(dv, trim=trimval)
|
||||||
|
|
||||||
|
if (is.list(trim))
|
||||||
|
{
|
||||||
|
if (is.null(trim$xmin))
|
||||||
|
{
|
||||||
|
xmin <- xx[1] - dvtrim
|
||||||
|
} else
|
||||||
|
xmin <- trim$xmin
|
||||||
|
|
||||||
|
if (is.null(trim$xmax))
|
||||||
|
{
|
||||||
|
xmax <- xx[n] + dvtrim
|
||||||
|
} else
|
||||||
|
xmax <- trim$xmax
|
||||||
|
|
||||||
|
if (!is.null(trim$xmin) || !is.null(trim$xmax))
|
||||||
|
{
|
||||||
|
if (isTRUE(force.clt))
|
||||||
|
{
|
||||||
|
expand.sd <- FALSE
|
||||||
|
force.clt <- FALSE
|
||||||
|
warning("expand.sd and force.clt were set to FALSE in order to ",
|
||||||
|
"enforce the limits xmin/xmax.")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
xmin <- xx[1] - dvtrim
|
||||||
|
xmax <- xx[n] + dvtrim
|
||||||
|
}
|
||||||
|
|
||||||
|
# do this here so that this warnings are printed after
|
||||||
|
# the above warnings (if necessary)
|
||||||
|
|
||||||
|
if (is.list(trim))
|
||||||
|
{
|
||||||
|
if (!is.null(trim$xmin) && trim$xmin > min(x))
|
||||||
|
warning("the lower limit trim$xmin may not be satisfied in the replicates ",
|
||||||
|
"since it is higher than the minimum value observed ",
|
||||||
|
"in the input series x")
|
||||||
|
if (!is.null(trim$xmax) && trim$xmax < max(x))
|
||||||
|
warning("the upper limit trim$xmax may not be satisfied in the replicates ",
|
||||||
|
"since it is lower than the maximum value observed ",
|
||||||
|
"in the input series x")
|
||||||
|
}
|
||||||
|
|
||||||
|
# Compute the mean of the maximum entropy density within each
|
||||||
|
# interval in such a way that the 'mean preserving constraint'
|
||||||
|
# is satisfied. (Denoted as m_t in the reference paper.)
|
||||||
|
# The first and last interval means have distinct formulas.
|
||||||
|
# See Theil and Laitinen (1980) for details.
|
||||||
|
|
||||||
|
aux <- colSums( t(embed(xx, 3))*c(0.25,0.5,0.25) )
|
||||||
|
desintxb <- c(0.75*xx[1]+0.25*xx[2], aux, 0.25*xx[n-1]+0.75*xx[n])
|
||||||
|
|
||||||
|
# Generate random numbers from the [0,1] uniform interval and
|
||||||
|
# compute sample quantiles at those points.
|
||||||
|
|
||||||
|
# Generate random numbers from the [0,1] uniform interval.
|
||||||
|
|
||||||
|
ensemble <- matrix(x, nrow=n, ncol=reps)
|
||||||
|
ensemble <- apply(ensemble, 2, meboot.part,
|
||||||
|
n, z, xmin, xmax, desintxb, reachbnd)
|
||||||
|
|
||||||
|
# So far the object 'ensemble' contains the quantiles.
|
||||||
|
# Now give them time series dependence and heterogeneity.
|
||||||
|
|
||||||
|
qseq <- apply(ensemble, 2, sort)
|
||||||
|
|
||||||
|
# 'qseq' has monotonic series, the correct series is obtained
|
||||||
|
# after applying the order according to 'ordxx' defined above.
|
||||||
|
|
||||||
|
ensemble[ordxx,] <- qseq
|
||||||
|
#ensemble[ordxx$ix,] <- qseq
|
||||||
|
|
||||||
|
if(expand.sd)
|
||||||
|
ensemble <- expand.sd(x=x, ensemble=ensemble, ...)
|
||||||
|
if(force.clt)
|
||||||
|
ensemble <- force.clt(x=x, ensemble=ensemble)
|
||||||
|
|
||||||
|
# scale adjustment
|
||||||
|
|
||||||
|
if (scl.adjustment)
|
||||||
|
{
|
||||||
|
zz <- c(xmin,z,xmax) #extended list of z values
|
||||||
|
#v <- rep(NA, n) #storing within variances
|
||||||
|
#for (i in 2:(n+1)) {
|
||||||
|
# v[i-1] <- ((zz[i] - zz[i-1])^2) / 12
|
||||||
|
#}
|
||||||
|
v <- diff(zz^2) / 12
|
||||||
|
xb <- mean(x)
|
||||||
|
s1 <- sum((desintxb - xb)^2)
|
||||||
|
uv <- (s1 + sum(v)) / n
|
||||||
|
desired.sd <- sd(x)
|
||||||
|
actualME.sd <- sqrt(uv)
|
||||||
|
if (actualME.sd <= 0)
|
||||||
|
stop("actualME.sd<=0 Error")
|
||||||
|
out <- desired.sd / actualME.sd
|
||||||
|
kappa <- out - 1
|
||||||
|
|
||||||
|
ensemble <- ensemble + kappa * (ensemble - xb)
|
||||||
|
} else
|
||||||
|
kappa <- NULL
|
||||||
|
|
||||||
|
#ensemble <- cbind(x, ensemble)
|
||||||
|
if(is.ts(x)){
|
||||||
|
ensemble <- ts(ensemble, frequency=frequency(x), start=start(x))
|
||||||
|
dimnames(ensemble)[[2]] <- paste("Series", 1:reps)
|
||||||
|
#dimnames(ensemble)[[2]] <- c("original", paste("Series", 1:reps))
|
||||||
|
}
|
||||||
|
|
||||||
|
# Computation time
|
||||||
|
ptm2 <- proc.time(); elapsr <- elapsedtime(ptm1, ptm2)
|
||||||
|
if(elaps)
|
||||||
|
cat("\n Elapsed time:", elapsr$elaps,
|
||||||
|
paste(elapsr$units, ".", sep=""), "\n")
|
||||||
|
|
||||||
|
list(x=x, ensemble=ensemble, xx=xx, z=z, dv=dv, dvtrim=dvtrim, xmin=xmin,
|
||||||
|
xmax=xmax, desintxb=desintxb, ordxx=ordxx, kappa = kappa, elaps=elapsr)
|
||||||
|
}
|
||||||
|
|
||||||
|
meboot.part <- function(x, n, z, xmin, xmax, desintxb, reachbnd)
|
||||||
|
{
|
||||||
|
# Generate random numbers from the [0,1] uniform interval
|
||||||
|
|
||||||
|
p <- runif(n, min=0, max=1)
|
||||||
|
|
||||||
|
# Compute sample quantiles by linear interpolation at
|
||||||
|
# those 'p'-s (if any) ...
|
||||||
|
|
||||||
|
# ... 'p'-s within the (i1/n, (i1+1)/n)] interval (i1=1,...,n-2).
|
||||||
|
|
||||||
|
q <- .C("mrapprox", p=as.double(p), n=as.integer(n), z=as.double(z),
|
||||||
|
desintxb=as.double(desintxb[-1]), ref23=double(n), qq=double(1),
|
||||||
|
q=double(n), PACKAGE="meboot")$q
|
||||||
|
|
||||||
|
# ... 'p'-s within the [0, (1/n)] interval. (Left tail.)
|
||||||
|
|
||||||
|
ref1 <- which(p <= (1/n))
|
||||||
|
if(length(ref1) > 0){
|
||||||
|
qq <- approx(c(0,1/n), c(xmin,z[1]), p[ref1])$y
|
||||||
|
q[ref1] <- qq
|
||||||
|
if(!reachbnd) q[ref1] <- qq + desintxb[1]-0.5*(z[1]+xmin)
|
||||||
|
}
|
||||||
|
|
||||||
|
# ... 'p'-s equal to (n-1)/n.
|
||||||
|
|
||||||
|
ref4 <- which(p == ((n-1)/n))
|
||||||
|
if(length(ref4) > 0)
|
||||||
|
q[ref4] <- z[n-1]
|
||||||
|
|
||||||
|
# ... 'p'-s greater than (n-1)/n. (Right tail.)
|
||||||
|
|
||||||
|
ref5 <- which(p > ((n-1)/n))
|
||||||
|
if(length(ref5) > 0){
|
||||||
|
# Right tail proportion p[i]
|
||||||
|
qq <- approx(c((n-1)/n,1), c(z[n-1],xmax), p[ref5])$y
|
||||||
|
q[ref5] <- qq # this implicitly shifts xmax for algorithm
|
||||||
|
if(!reachbnd) q[ref5] <- qq + desintxb[n]-0.5*(z[n-1]+xmax)
|
||||||
|
# such that the algorithm gives xmax when p[i]=1
|
||||||
|
# this is the meaning of reaching the bounds xmax and xmin
|
||||||
|
}
|
||||||
|
|
||||||
|
q
|
||||||
|
}
|
||||||
|
|
||||||
|
elapsedtime <- function(ptm1, ptm2)
|
||||||
|
{
|
||||||
|
elaps <- (ptm2 - ptm1)[3]
|
||||||
|
|
||||||
|
if(elaps < 60)
|
||||||
|
units <- "seconds"
|
||||||
|
else if(elaps < 3600){
|
||||||
|
elaps <- elaps/60
|
||||||
|
units <- "minutes" }
|
||||||
|
else if(elaps < 86400){
|
||||||
|
elaps <- elaps/3600
|
||||||
|
units <- "hours" }
|
||||||
|
else { elaps <- elaps/86400
|
||||||
|
units <- "days" }
|
||||||
|
|
||||||
|
list(elaps=as.numeric(elaps), units=units)
|
||||||
|
}
|
|
@ -0,0 +1,40 @@
|
||||||
|
|
||||||
|
// q <- .C("mrapprox", p=as.double(p), n=as.integer(n), z=as.double(z),
|
||||||
|
// desintxb=as.double(desintxb[-1]), ref23=double(n), qq=double(1),
|
||||||
|
// q=double(n), PACKAGE="meboot")$q
|
||||||
|
|
||||||
|
void mrapprox(double *p, int *n, double *z, double *desintxb, double *ref23,
|
||||||
|
double *qq, double *q)
|
||||||
|
{
|
||||||
|
int i, j, ii1, k;
|
||||||
|
double i1, nn;
|
||||||
|
|
||||||
|
nn = *n;
|
||||||
|
for(i=0; i < *n; i=i+1){
|
||||||
|
q[i] = -99999;
|
||||||
|
ref23[i] = -99999;
|
||||||
|
}
|
||||||
|
|
||||||
|
j = 0;
|
||||||
|
i1 = 1.0;
|
||||||
|
for(ii1=0; ii1 < *n-2; ii1=ii1+1){
|
||||||
|
|
||||||
|
j = 0;
|
||||||
|
for(i=0; i < *n; i=i+1){
|
||||||
|
|
||||||
|
if( p[i] > i1/nn && p[i] <= (i1+1)/nn ){
|
||||||
|
ref23[j] = i;
|
||||||
|
j = j+1;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
for(i=0; i < j; i=i+1){
|
||||||
|
|
||||||
|
k = ref23[i];
|
||||||
|
qq[0] = z[ii1] + ( (z[ii1+1]- z[ii1]) / ((i1+1)/nn - i1/nn) ) * (p[k] - i1/nn);
|
||||||
|
q[k] = qq[0] + desintxb[ii1] - 0.5*(z[ii1] + z[ii1+1]);
|
||||||
|
}
|
||||||
|
i1 = i1+1;
|
||||||
|
}
|
||||||
|
}
|
|
@ -61,97 +61,101 @@ def scale_data(X, param=()):
|
||||||
return Xs, param
|
return Xs, param
|
||||||
|
|
||||||
|
|
||||||
def value2diff(X, mode=None):
|
def value2diff(X, percent=True):
|
||||||
"""
|
"""
|
||||||
from value to difference in abs or %
|
from value to difference in abs or %
|
||||||
diff in value first element is zero
|
dx is reduced by 1 row
|
||||||
diff in % first element is one
|
|
||||||
"""
|
"""
|
||||||
|
|
||||||
# Difference in value
|
|
||||||
if (mode == 'V'):
|
|
||||||
dX = np.zeros_like(X)
|
|
||||||
dX[1:, :] = X[1:, :] - X[:-1, :]
|
|
||||||
|
|
||||||
# Difference in percent
|
# Difference in percent
|
||||||
|
if (percent):
|
||||||
|
dX = X[1:, :] / X[:-1, :] - 1.0
|
||||||
|
|
||||||
|
# Difference in value
|
||||||
else:
|
else:
|
||||||
dX = np.ones_like(X)
|
dX = X[1:, :] - X[:-1, :]
|
||||||
dX[1:, :] = X[1:, :] / X[:-1, :] - 1.0
|
|
||||||
|
|
||||||
return dX
|
return dX
|
||||||
|
|
||||||
|
|
||||||
def diff2value(dX, mode=None):
|
def diff2value(dX, percent=True):
|
||||||
"""
|
"""
|
||||||
from difference in abs or % to value (first row should be all zeros but
|
from difference in abs or % to value
|
||||||
will be over-written
|
X is increased by one row
|
||||||
|
|
||||||
Reference X[0,:] is assumed to be zero. If X0[0,:] is the desired
|
Value from percent: first row set to one. If X0 defines the starting
|
||||||
reference, the actual vector X can be determined as X0+X
|
values, then X0*X would be the ???
|
||||||
|
|
||||||
Reference X[0,:] is assumed to be one. If X0[0,:] is the desired
|
Value from difference: first row set to zero. If X0 defines the starting
|
||||||
reference, the actual vector X can be determined as X0*X
|
values, then X0+X would be the ???
|
||||||
"""
|
"""
|
||||||
# Value from the difference (first row equal to zero)
|
n_rows, n_cols = dX.shape
|
||||||
# X[0, :] = 0
|
X = np.zeros((n_rows+1, n_cols))
|
||||||
# X[1, :] = X[0, :] + dX[1, :] = dX[1, :]
|
|
||||||
# X[2, :] = X[0, :] + dX[1, :] + dX[2, :] = dX[1, :] + dX[2, :]
|
# Value from percent
|
||||||
# ....
|
|
||||||
if (mode == 'V'):
|
|
||||||
X = np.zeros_like(dX)
|
|
||||||
X[1:, :] = np.cumsum(dX[1:, :], axis=0)
|
|
||||||
|
|
||||||
# Value from percent (first row equal to 1)
|
|
||||||
# X[0, :] = 1
|
# X[0, :] = 1
|
||||||
# X[1, :] = X[0, :] * (1 + dX[1, :]) = (1 + dX[1, :])
|
# X[1, :] = X[0, :] * (1 + dX[1, :]) = (1 + dX[1, :])
|
||||||
# X[2, :] = X[1, :] * (1 + dX[2, :])
|
# X[2, :] = X[1, :] * (1 + dX[2, :])
|
||||||
# = X[0, :] * (1 + dX[1, :]) * (1 + dX[2, :])
|
# = X[0, :] * (1 + dX[1, :]) * (1 + dX[2, :])
|
||||||
# = (1 + dX[1, :]) * (1 + dX[2, :])
|
# = (1 + dX[1, :]) * (1 + dX[2, :])
|
||||||
# ....
|
# ....
|
||||||
else:
|
if (percent):
|
||||||
X = np.ones_like(dX)
|
X[0, :] = 1.0
|
||||||
X[1:, :] = np.cumprod((1.0 + dX), axis=0)
|
X[1:, :] = np.cumprod((1.0 + dX), axis=0)
|
||||||
|
|
||||||
|
# Value from difference
|
||||||
|
# X[0, :] = 0
|
||||||
|
# X[1, :] = X[0, :] + dX[1, :] = dX[1, :]
|
||||||
|
# X[2, :] = X[0, :] + dX[1, :] + dX[2, :] = dX[1, :] + dX[2, :]
|
||||||
|
# ....
|
||||||
|
else:
|
||||||
|
# First row already set to zero
|
||||||
|
X[1:, :] = np.cumsum(dX, axis=0)
|
||||||
|
|
||||||
return X
|
return X
|
||||||
|
|
||||||
|
|
||||||
def synthetic_wave(per, amp=None, pha=None, num=1000):
|
def synthetic_wave(P, A=None, phi=None, num=1000):
|
||||||
"""
|
"""
|
||||||
Generates a multi-sinewave.
|
Generates a multi-sinewave.
|
||||||
P = [ P1 P2 ... Pn ] Periods
|
P = [P_1, P_2, ... P_n] Periods
|
||||||
A = [ A1 A2 ... An ] Amplitudes
|
A = [A_1, A_2, ... A_n] Amplitudes
|
||||||
PH = [PH1 PH2 ... PHn] Phases (rad)
|
phi = [phi_1, phi_2, ... phi_n] Phases (rad)
|
||||||
|
|
||||||
Default amplitudes are ones
|
Default amplitudes are ones
|
||||||
Default phases are zeros
|
Default phases are zeros
|
||||||
Time is from 0 to largest period (default 1000 steps)
|
Time is from 0 to largest period (default 1000 steps)
|
||||||
"""
|
"""
|
||||||
n_waves = len(per)
|
n_waves = len(P)
|
||||||
per = np.asarray(per)
|
P = np.asarray(P)
|
||||||
|
|
||||||
# Define amplitudes and phases
|
# Define amplitudes
|
||||||
if (amp is None):
|
if (A is None):
|
||||||
amp = np.ones(n_waves)
|
A = np.ones(n_waves)
|
||||||
else:
|
else:
|
||||||
amp = np.asarray(amp)
|
A = np.asarray(A)
|
||||||
if (pha is None):
|
|
||||||
pha = np.zeros(n_waves)
|
# Define phases
|
||||||
|
if (phi is None):
|
||||||
|
phi = np.zeros(n_waves)
|
||||||
else:
|
else:
|
||||||
pha = np.asarray(pha)
|
phi = np.asarray(phi)
|
||||||
|
|
||||||
# Add all the waves
|
# Add all the waves
|
||||||
t = np.linspace(0.0, np.amax(per), num=num)
|
t = np.linspace(0.0, np.amax(P), num=num)
|
||||||
f = np.zeros(len(t))
|
f = np.zeros(len(t))
|
||||||
for i in range(n_waves):
|
for i in range(n_waves):
|
||||||
f = f + amp[i] * np.sin(2.0 * np.pi * t / per[i] + pha[i])
|
f = f + A[i] * np.sin(2.0 * np.pi * t / P[i] + phi[i])
|
||||||
|
|
||||||
return t, f
|
return t, f
|
||||||
|
|
||||||
|
|
||||||
def synthetic_series(X, multiv=False):
|
def synthetic_FFT(X, multiv=False):
|
||||||
"""
|
"""
|
||||||
|
- univariate and single time-series
|
||||||
|
- univariate and multi-time series (can be used to generate multi from same)
|
||||||
|
- multi-variate multi-time series
|
||||||
"""
|
"""
|
||||||
n_samples, n_series = data.shape
|
n_samples, n_series = X.shape
|
||||||
|
|
||||||
# The number of samples must be odd (if the number is even drop the last value)
|
# The number of samples must be odd (if the number is even drop the last value)
|
||||||
if ((n_samples % 2) == 0):
|
if ((n_samples % 2) == 0):
|
||||||
|
@ -188,3 +192,69 @@ def synthetic_series(X, multiv=False):
|
||||||
X_synt = np.real(np.fft.ifft(synt_fft, axis=0))
|
X_synt = np.real(np.fft.ifft(synt_fft, axis=0))
|
||||||
|
|
||||||
return X_synt
|
return X_synt
|
||||||
|
|
||||||
|
|
||||||
|
def synthetic_sampling(X, replace=True):
|
||||||
|
"""
|
||||||
|
generate more than n_samples?
|
||||||
|
"""
|
||||||
|
n_samples, n_series = X.shape
|
||||||
|
X_synt = np.zeros_like(X)
|
||||||
|
|
||||||
|
# Sampling with replacement
|
||||||
|
if (replace):
|
||||||
|
idx = np.random.randint(0, n_samples, size=(n_samples, n_series))
|
||||||
|
i = np.arange(n_series)
|
||||||
|
X_synt[:, i] = X[idx[:, i], i]
|
||||||
|
|
||||||
|
# Sampling without replacement
|
||||||
|
else:
|
||||||
|
idx = np.zeros_like(X)
|
||||||
|
for j in range(n_series):
|
||||||
|
idx[:, j] = np.random.permutation(n_samples)
|
||||||
|
i = np.arange(n_series)
|
||||||
|
X_synt[:, i] = X[idx[:, i], i]
|
||||||
|
|
||||||
|
return X_synt
|
||||||
|
|
||||||
|
|
||||||
|
def synthetic_MEboot(X, alpha=0.1):
|
||||||
|
"""
|
||||||
|
"""
|
||||||
|
n_samples, n_series = X.shape
|
||||||
|
X_synt = np.zeros_like(X)
|
||||||
|
|
||||||
|
# Loop over time-series
|
||||||
|
n = n_samples
|
||||||
|
for ts in range(n_series):
|
||||||
|
|
||||||
|
# Sort the time series keeping track of the original position
|
||||||
|
idx = np.argsort(X[:, ts])
|
||||||
|
Y = X[idx, ts]
|
||||||
|
print(idx, idx.shape)
|
||||||
|
print(Y, Y.shape)
|
||||||
|
|
||||||
|
# Compute the trimmed mean
|
||||||
|
g = int(np.floor(n * alpha))
|
||||||
|
r = n * alpha - g
|
||||||
|
print(n, g, r)
|
||||||
|
m_trm = ((1.0 - r) * (Y[g] + Y[n-g-1]) + Y[g+1:n-g-1].sum()) \
|
||||||
|
/ (n * (1.0 - 2.0 * alpha))
|
||||||
|
print(m_trm)
|
||||||
|
|
||||||
|
# Compute the intermediate points
|
||||||
|
Z = np.zeros(n+1)
|
||||||
|
Z[1:-1] = (Y[0:-1] + Y[1:]) / 2.0
|
||||||
|
Z[0] = Y[0] - m_trm
|
||||||
|
Z[n] = Y[n-1] + m_trm
|
||||||
|
print(Z, Z.shape)
|
||||||
|
|
||||||
|
# Compute the interval means
|
||||||
|
mt = np.zeros(n)
|
||||||
|
mt[0] = 0.75 * Y[0] + 0.25 * Y[1]
|
||||||
|
mt[1:n-1] = 0.25 * Y[0:n-2] + 0.5 * Y[1:n-1] + 0.25 * Y[2:n]
|
||||||
|
mt[n-1] = 0.25 * Y[n-2] + 0.75 * Y[n-1]
|
||||||
|
print(mt)
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -15,8 +15,6 @@ ToDo:
|
||||||
- example using noisy multi-sine-waves
|
- example using noisy multi-sine-waves
|
||||||
- synt: boot, paper Vinod (as a class?)
|
- synt: boot, paper Vinod (as a class?)
|
||||||
- vectors must be ( .., 1)
|
- vectors must be ( .., 1)
|
||||||
- reduce the vector diff by one and pass initial value
|
|
||||||
(with zero/one as default)
|
|
||||||
"""
|
"""
|
||||||
|
|
||||||
import sys
|
import sys
|
||||||
|
@ -56,30 +54,48 @@ np.random.seed(1294404794)
|
||||||
# signals = (spx.data[:, 0], Yc[:, 0], Yp[:, 0])
|
# signals = (spx.data[:, 0], Yc[:, 0], Yp[:, 0])
|
||||||
# utl.plot_signals(signals, 0, 50)
|
# utl.plot_signals(signals, 0, 50)
|
||||||
|
|
||||||
# t, f = utl.synthetic_wave([1., 2., 3.], A=None, PH=None, num=30)
|
# t, f = syn.synthetic_wave([1., 2., 3.], A=None, phi=None, num=100)
|
||||||
# plt.plot(t,f)
|
# plt.plot(t,f)
|
||||||
# plt.show()
|
# plt.show()
|
||||||
aa = np.array([
|
# aa = np.array([
|
||||||
[ 0.8252, 0.2820],
|
# [ 0.8252, 0.2820],
|
||||||
[ 1.3790, 0.0335],
|
# [ 1.3790, 0.0335],
|
||||||
[-1.0582, -1.3337],
|
# [-1.0582, -1.3337],
|
||||||
[-0.4686, 1.1275],
|
# [-0.4686, 1.1275],
|
||||||
[-0.2725, 0.3502],
|
# [-0.2725, 0.3502],
|
||||||
[ 1.0984, -0.2991],
|
# [ 1.0984, -0.2991],
|
||||||
[-0.2779, 0.0229],
|
# [-0.2779, 0.0229],
|
||||||
[ 0.7015, -0.2620],
|
# [ 0.7015, -0.2620],
|
||||||
[-2.0518, -1.7502],
|
# [-2.0518, -1.7502],
|
||||||
[-0.3538, -0.2857],
|
# [-0.3538, -0.2857],
|
||||||
[-0.8236, -0.8314],
|
# [-0.8236, -0.8314],
|
||||||
[-1.5771, -0.9792],
|
# [-1.5771, -0.9792],
|
||||||
[ 0.5080, -1.1564]])
|
# [ 0.5080, -1.1564]])
|
||||||
# synt_aa = utl.synthetic_series(data, False)
|
# synt_data1 = syn.synthetic_FFT(data, False)
|
||||||
# plt.plot(synt_aa)
|
# synt_data2 = syn.synthetic_FFT(data, False)
|
||||||
|
# plt.plot(synt_data1)
|
||||||
|
# plt.plot(synt_data2)
|
||||||
# plt.plot(data)
|
# plt.plot(data)
|
||||||
|
# names = ['syn1', 'syn2', 'spx']
|
||||||
|
# plt.legend(names)
|
||||||
# plt.show()
|
# plt.show()
|
||||||
print(data[0:10, :])
|
# percent = False
|
||||||
bb = syn.value2diff(data, mode='V')
|
# print(data[0:10, :])
|
||||||
print(bb[0:10, :])
|
# bb = syn.value2diff(data, percent)
|
||||||
bb[0, 0] = 1399.48
|
# print(bb[0:10, :])
|
||||||
cc = syn.diff2value(bb, mode='V')
|
# cc = syn.diff2value(bb, percent)
|
||||||
print(cc[0:10, :])
|
# print(cc[0:10, :]+1399.48)
|
||||||
|
# aa = np.arange(10,28).reshape(6,3)
|
||||||
|
# print(aa)
|
||||||
|
# idx = np.zeros_like(aa)
|
||||||
|
# bb = np.zeros_like(aa)
|
||||||
|
# for i in range(aa.shape[1]):
|
||||||
|
# idx[:, i] = np.random.permutation(aa.shape[0])
|
||||||
|
# print(idx)
|
||||||
|
# i = np.arange(aa.shape[1])
|
||||||
|
# bb[:, i] = aa[idx[:, i], i]
|
||||||
|
# bb = syn.synthetic_boot(aa, replace=False)
|
||||||
|
# print(bb)
|
||||||
|
aa = np.array([4, 12, 36, 20, 8]).reshape(5, 1)
|
||||||
|
# print(aa)
|
||||||
|
syn.synthetic_MEboot(aa)
|
||||||
|
|
|
@ -8,6 +8,8 @@
|
||||||
|
|
||||||
- D. Prichard, and J. Theiler, "[Generating surrogate data for time series with several simultaneously measured variables](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.73.951)."
|
- D. Prichard, and J. Theiler, "[Generating surrogate data for time series with several simultaneously measured variables](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.73.951)."
|
||||||
|
|
||||||
|
- H. Vinod, and J. Lopez-de-Lacalle, "[Maximum entropy bootstrap for time series: the meboot R package](https://www.jstatsoft.org/article/view/v029i05)."
|
||||||
|
|
||||||
## Characteristics
|
## Characteristics
|
||||||
|
|
||||||
## Parameters
|
## Parameters
|
||||||
|
|
Ładowanie…
Reference in New Issue