adjust <- function(x, sp = uncor.spec(x), h = 1., s = 20., start.p = 5., start.g = 30., criterion = "comfortable.fit", g.update.step = 
1., attit = "adventurous", pars.updated.at.once = 2., max.no.of.descents = 1., max.p = 10., limits.g = c(10., 100.), kernel = "normal")
{
	g <- rep(0., s + 1.)
	p <- rep(0., s + 1.)
	xhat <- rep(0., s)
	sqdist <- rep(0., s)
	sig <- rep(0., s)
	fits.in <- rep(0., s)
	g[1.] <- start.g
	p[1.] <- max(start.p, h)
	len <- length(x)
	for(i in s:1.) {
		print(i)
		x.temp <- x[1.:(len - i - h + 1.)]
		sp.temp <- clip.spec(sp, 1., len - i - h + 1.)
		pr <- pred(x.temp, sp.temp, h, p[s - i + 1.], kernel, g[s - i + 1.])
		xhat[s - i + 1.] <- pr$mean
		sig[s - i + 1.] <- pr$std.err
		sqdist[s - i + 1.] <- (x[len - i + 1.] - xhat[s - i + 1.])^2.
		fits.in[s - i + 1.] <- (sqrt(sqdist[s - i + 1.]) <= 1.96 * sig[s - i + 1.])
		if(attit == "conservative" & fits.in[s - i + 1.]) {
			g[s - i + 2.] <- g[s - i + 1.]
			p[s - i + 2.] <- p[s - i + 1.]
		}
		else {
			current.g <- g[s - i + 1.]
			current.p <- p[s - i + 1.]
			cont <- T
			j <- 1.
			while(cont) {
				A <- matrix(Inf, 3., 3.)
				B <- matrix(0., 3., 3.)
				for(k in 1.:3.)
					for(l in 1.:3.)
						if(current.p + (l - 2.) >= h & current.p + (l - 2.) <= max.p & current.g + (k - 2.) * 
							g.update.step <= limits.g[2.] & current.g + (k - 2.) * g.update.step >= limits.g[1.]) if(pars.updated.at.once == 2. | k == 2. | l == 2.) {
								pr <- pred(x.temp, sp.temp, h, current.p + (l - 2.), kernel, current.g + (k - 2.) * g.update.step)
								A[k, l] <- abs(x[len - i + 1.] - pr$mean)
								B[k, l] <- 1.96 * pr$std.err
							}
				if(criterion == "comfortable.fit")
					index <- which(A/B == min(A/B))
				else if(criterion == "min.distance") {
					index <- which(A == min(A[A <= B]))
					if(length(index) > 1.)
						index <- which(B == min(B[which(A == min(A[A <= B]))]))
					else if(length(index) == 0.)
						index <- which(A/B == min(A/B))
				}
				current.p <- current.p + (((index - 1.) %/% 3.) - 1.)
				current.g <- current.g + (((index - 1.) %% 3.) - 1.) * g.update.step
				cont <- (A[index] > B[index] & j < max.no.of.descents & (((index - 1.) %/% 3.) - 1. != 0. | ((index - 1.) %% 3.) - 1. != 0.))
				j <- j + 1.
			}
			p[s - i + 2.] <- current.p
			g[s - i + 2.] <- current.g
		}
	}
	actual <- x[(len - s + 1.):len]
	percent.fits.in <- sum(fits.in)/length(fits.in)
	return(xhat, sig, actual, sqdist, p, g, fits.in, percent.fits.in)
}

pred <- function(x, sp = uncor.spec(x), h = 1., p = 5., kernel = "normal", g = 30.)
{
	len <- length(x)
	pr <- predeq.est(sp, h, p, kernel = kernel, g = g)
	b <- solve(pr$B, pr$RHS)
	mean <- sum(x[(len - p + 1.):len] * b)
	std.err <- sqrt(max(sig.sq(pr, b), 0.))
	return(p, mean, std.err)
}

loc.cov.unc <- function(uncspec, lag, req.length = uncspec$TT - lag, smooth = T, kernel = "normal", g = 50., extrap.lag = 1.)
{
	TT <- uncspec$TT
	J <- floor(logb(TT, 2.))
	Ainv <- solve(A.haar(J))
	indices.S <- max(lag + 1., TT - req.length - 3. * g + 1.):TT
	indices <- indices.S - lag/2.
	loccov <- rep(0., length(indices))
	weights <- Ainv %*% haar.acf((-1.):( - J), lag)
	for(j in 1.:J)
		loccov <- loccov + weights[j] * uncspec$S[(j - 1.) * TT + indices.S]
	if(smooth) {
		x.p <- c(indices, indices[length(indices)] + extrap.lag)
		loccov <- ksmooth(indices, loccov, kernel = kernel, bandwidth = g, x.points = x.p)$y
		lcov <- loccov[(length(loccov) - req.length):(length(loccov) - 1.)]
		extrapolated <- loccov[length(loccov)]
	}
	else {
		lcov <- loccov[(length(loccov) - req.length + 1.):(length(loccov))]
		extrapolated <- loccov[length(loccov)]
	}
	return(lcov, extrapolated)
}

predeq.est <- function(uncspec, h = 1., p = uncspec$TT, smooth = T, kernel = "normal", g = 30., max.lag = p - 1.)
{
	B <- matrix(0., p, p)
	RHS <- rep(0., p)
	if(max.lag > 0.)
		for(lag in 1.:max.lag) {
			indices <- seq(from = lag * p + 1., by = p + 1., to = p^2. - lag)
			v <- loc.cov.unc(uncspec, lag, p - lag, smooth, kernel, g, h)
			B[indices] <- v$lcov
			if(h <= lag)
				RHS[p + h - lag] <- v$extrapolated
		}
	B <- t(B) + B
	v <- loc.cov.unc(uncspec, 0., p, smooth, kernel, g, h)
	diag(B) <- v$lcov
	extra.var <- v$extrapolated
	return(B, RHS, extra.var)
}

A.haar <- function(J)
{
	A <- matrix(0., J, J)
	if(J == 1.)
		A[1., 1.] <- 1.5
	else {
		for(j in 1.:(J - 1.))
			for(l in (j + 1.):J)
				A[j, l] <- 2.^( - l) * (2.^(2. * j - 1.) + 1.)
		A <- A + t(A)
		for(j in 1.:J)
			A[j, j] <- (2.^(2. * j) + 5.)/(3. * 2.^j)
		return(A)
	}
}

clip.spec <- function(uncspec, beg, endd)
{
	TT <- uncspec$TT
	S <- numeric()
	J <- floor(logb(TT, 2.))
	for(j in 1.:J)
		S <- c(S, uncspec$S[(j - 1.) * TT + (beg:endd)])
	TT <- endd - beg + 1.
	return(TT, S)
}

sig.sq <- function(predeq, minimiser = solve(predeq$B, predeq$RHS))
{
	s <- length(predeq$RHS)
	B <- matrix(0., s + 1., s + 1.)
	B[1.:s, 1.:s] <- predeq$B
	B[1.:s, s + 1.] <- predeq$RHS
	B[s + 1., 1.:s] <- predeq$RHS
	B[s + 1., s + 1.] <- predeq$extra.var
	b <- c(minimiser, -1.)
	sqerr <- sum(b * (B %*% b))
	return(sqerr)
}

haar.acf <- function(j, tau)
{
	cc <- 2.^( - j - 1.)
	res <- (2. * pmax(cc - abs(tau), 0.) - pmax(pmin(cc + tau,
		2. * cc) - pmax(cc, tau), 0.) - pmax(pmin(2. * cc +
		tau, cc) - pmax(cc + tau, 0.), 0.))/(2. * cc)
	return(res)
}

uncor.spec <- function(x)
{
	TT <- length(x)
	J <- floor(logb(TT, 2.))
	d <- rep(0., J * TT)
	temp <- x
	for(j in (-1.):( - J)) {
		gap <- 2.^( - j - 1.)
		for(k in TT:(2. * gap)) {
			d[( - j - 1.) * TT + k] <- (temp[k] - temp[k - gap])/sqrt(2.)
			temp[k] <- (temp[k] + temp[k - gap])/sqrt(2.)
		}
		for(k in (2. * gap - 1.):1.)
			d[( - j - 1.) * TT + k] <- d[( - j - 1.) * TT + 2. * gap]
	}
	S <- d^2.
	return(TT, S)
}