R/rgarch-cwrappers.R

In rgarch: Flexible GARCH modelling in R

#################################################################################
##
##   R package rgarch by Alexios Ghalanos Copyright (C) 2008, 2009, 2010, 2011
##   This file is part of the R package rgarch.
##
##   The R package rgarch is free software: you can redistribute it and/or modify
##   it under the terms of the GNU General Public License as published by
##   the Free Software Foundation, either version 3 of the License, or
##   (at your option) any later version.
##
##   The R package rgarch is distributed in the hope that it will be useful,
##   but WITHOUT ANY WARRANTY; without even the implied warranty of
##   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
##   GNU General Public License for more details.
##
#################################################################################
.getresiduals<-function(data, include.mean, mu, armaOrder, ar, ma, include.inmean, 
		inmean, darfima, mexdata, mxreg, h)
{
	# Case 1 garchInMean yes:
	armap = armaOrder[1]
	armaq = armaOrder[2]
	im = armaOrder[3]
	arfima = armaOrder[4]
	include.mex = armaOrder[5]
	zrf = 0
	if(include.mex!=0){
		mexdata = mexdata
		mxn = dim(as.matrix(mexdata))[2]
		mxreg = mxreg
		xm = as.numeric(mexdata%*%matrix(mxreg,nrow=mxn))
	} else{
		xm = 0
	}
	if(include.inmean){
		ixm = inmean*(h^im)
	} else{
		ixm =0 
	}
	if(armap!=0) ar=ar else ar=0
	if(armaq!=0) ma=ma else ma=0
	if(include.mean) mu=mu else mu=0
	if(armap!=0 && armaq!=0) myfix=c(ar,ma)
	if(armap!=0 && armaq==0) myfix=ar
	if(armap==0 && armaq!=0) myfix=ma
	
	if((armap+armaq)>0){
		xm  = data - mu - xm - ixm
		res = arima(x = xm, order = c(armap, 0, armaq), include.mean = FALSE,
				fixed = myfix, transform.pars = FALSE, optim.control = list(maxit = 0))$residuals
		if(arfima)
		{
			zrf = .fracdiff(c(1,rep(0,length(data)-1)), darfima=darfima)
			#2 stage arfima (arma>arfima...maybe we can use the fracdiff package
			# but it does not yet return residuals/ fArma has an implementation...
			res = .fracdiff(res, darfima=darfima)
		}
		if(any(is.na(res))) res[which(is.na(res))]=0
	} else{
		res = data - mu - xm - ixm
		if(arfima)
		{
			zrf = .fracdiff(c(1,rep(0,length(data)-1)), darfima = darfima)
			
			#2 stage arfima (arma>arfima...maybe we can use the fracdiff package
			# but it does not yet return residuals/ fArma has an implementation...
			res = .fracdiff(res, darfima=darfima)
		}
	}
	ans = list(res=res, zrf=zrf)
	return(ans)
}

# fractional difference series C wrapper
.arfimaxfilter = function(armaOrder, mu, ar, ma, inmean, darfima, mxreg, mexdata,
		h, data, N, garchenv)
{
	m = as.integer(N[1])
	T = as.integer(N[2])
	armap = as.integer(armaOrder[1])
	armaq = as.integer(armaOrder[2])
	im = as.double(armaOrder[3])
	arfima = as.integer(armaOrder[4])
	incmex = as.integer(armaOrder[5])
	
	mu = as.double(mu)
	ar = as.double(ar)
	ma = as.double(ma)
	inmean = as.double(inmean)
	mxreg = as.double(mxreg)
	
	if(length(h) <= 1) {
		h = double(length = T)
	} else{
		h = as.double(h)
	}
	data = as.double(data)
	# flatten exogenous matrix	
	if(armaOrder[5]>0){
		incmex = dim(as.matrix(mexdata))[2]
		imx = as.double(mexdata%*%as.matrix(mxreg, nrow = incmex))
		mexdata = as.double(as.vector(mexdata))
	} else{
		mexdata = as.double(0)
		incmex = 0
		imx = as.double(0)
	}
	res = double(length = T)
	# this routine is used for the mean residuals to initiate the recursion
	# so we ignore arfima before
	zrf = double(length = T)
	constm = double(length = T)
	condm = double(length = T)
	if(armap>0 | armaq>0){
		ans = try(.C("arfimaxfilterC", armap = armap, armaq = armaq, arfima = integer(length=1), 
						im = im, incmex = incmex, mu = mu, ar = ar, ma = ma, 
						inmean = inmean, mxreg = mxreg, x = data, res = res, mexdata = mexdata, 
						zrf = zrf, constm = constm, condm = condm, h = h, m = m, T = T,  
						PACKAGE = "rgarch"), silent = TRUE)
		if(inherits(ans, "try-error")){
			assign(".csol", 1, envir = garchenv)
			assign(".filtermessage", ans, envir = garchenv)
			res = data - mu
			ans$res = res
			if(arfima)
			{
				ans$zrf = .fracdiff(c(1,rep(0,length(data)-1)), darfima = darfima)
				ans$res = .fracdiff(ans$res, darfima = darfima)
			}
			if(any(is.na(res))) res[which(is.na(res))]=0
			return(ans)
		} else{
			assign(".csol", 0, envir = garchenv)
			if(arfima)
			{
				ans$zrf = .fracdiff(c(1,rep(0,length(data)-1)), darfima=darfima)
				ans$res = .fracdiff(ans$res, darfima = darfima)
			}
			if(any(is.na(ans$res))) res[which(is.na(ans$res))]=0
			return(ans)
		}
	} else{
		ans = list()
		ans$res = data - mu - imx - inmean*(h^im)
		ans$zrf = zrf
		if(arfima)
		{
			ans$zrf = .fracdiff(c(1,rep(0,length(data)-1)), darfima=darfima)
			ans$res = .fracdiff(ans$res, darfima = darfima)
		}
		if(any(is.na(ans$res))) res[which(is.na(ans$res))]=0
		return(ans)
	}
	
}


# fractional difference series C wrapper
.fracdiff = function(x, darfima)
{
	n = length(as.vector(x))
	p = c(-darfima, rep(0,n-1))
	
	res = .C("fracdiff",n = as.integer(n), d = as.double(darfima), p = as.double(p),
			x = as.double(x), ydiff = as.double(x), PACKAGE = "rgarch")
	return(res$ydiff)
}

.arfimaxfilterx = function(armaOrder, mu, ar, ma, darfima, mxreg, mexdata, data, N, garchenv)
{
	m = as.integer(N[1])
	T = as.integer(N[2])
	armap = as.integer(armaOrder[1])
	armaq = as.integer(armaOrder[2])
	arfima = as.integer(armaOrder[4])
	incmex = as.integer(armaOrder[5])
	
	mu = as.double(mu)
	ar = as.double(ar)
	ma = as.double(ma)
	mxreg = as.double(mxreg)

	data = as.double(data)
	# flatten exogenous matrix	
	if(armaOrder[5]>0){
		incmex = dim(as.matrix(mexdata))[2]
		imx = as.double(mexdata%*%as.matrix(mxreg, nrow = incmex))
		mexdata = as.double(as.vector(mexdata))
	} else{
		mexdata = as.double(0)
		incmex = 0
		imx = as.double(0)
	}
	res = double(length = T)
	# this routine is used for the mean residuals to initiate the recursion
	# so we ignore arfima before
	zrf = double(length = T)
	constm = double(length = T)
	condm = double(length = T)
	if(armap>0 | armaq>0){
		ans = try(.C("arfimaxfilterC", armap = armap, armaq = armaq, arfima = integer(length = 1), 
						im = 0, incmex = incmex, mu = mu, ar = ar, ma = ma, 
						inmean = 0, mxreg = mxreg, x = data, res = res, mexdata = mexdata, 
						zrf = zrf, constm = constm, condm = condm, h = 0, m = m, T = T,  
						PACKAGE = "rgarch"), silent = TRUE)
		if(inherits(ans, "try-error")){
			assign(".csol", 1, envir = garchenv)
			assign(".filtermessage", ans, envir = garchenv)
			res = data - mu
			ans$res = res
			if(arfima)
			{
				ans$zrf = .fracdiff(c(1,rep(0,length(data)-1)), darfima = darfima)
				ans$res = .fracdiff(ans$res, darfima = darfima)
			}
			if(any(is.na(res))) res[which(is.na(res))]=0
			return(ans)
		} else{
			assign(".csol", 0, envir = garchenv)
			if(arfima)
			{
				ans$zrf = .fracdiff(c(1,rep(0,length(data)-1)), darfima=darfima)
				ans$res = .fracdiff(ans$res, darfima = darfima)
			}
			if(any(is.na(ans$res))) res[which(is.na(ans$res))]=0
			return(ans)
		}
	} else{
		ans = list()
		ans$res = data - mu - imx
		ans$zrf = zrf
		if(arfima)
		{
			ans$zrf = .fracdiff(c(1,rep(0,length(data)-1)), darfima=darfima)
			ans$res = .fracdiff(ans$res, darfima = darfima)
		}
		if(any(is.na(ans$res))) res[which(is.na(ans$res))]=0
		return(ans)
	}
}

# sGARCH fit C wrapper
# future specification
.sgarchfitC2 = function(armaOrder, garchOrder, mu, ar, ma, inmean, mxreg, mexdata,
		omega, hEst, alpha, beta, vxreg, vexdata, skew, shape, dist, data, zrf, N, 
		res, garchenv)
{

	# flatten exogenous matrix	
	if(armaOrder[5]>0){
		incmex = dim(as.matrix(mexdata))[2]
		mexdata = as.double(as.vector(mexdata))
	} else{
		mexdata = 0
		incmex = 0
	}
	
	if(garchOrder[3]>0){
		incvex = dim(as.matrix(vexdata))[2]
		vexdata = as.double(as.vector(vexdata))
	} else{
		vexdata = 0
		incvex = 0
	}
	
	ivector = vector(mode = "integer", length = 10)
	ivector = c(armaOrder[1], armaOrder[2], armaOrder[4], inmean, armaOrder[5],
			garchOrder[1], garchOrder[2], garchOrder[3], N[1], N[2], dist)
	
	mvector = vector(mode = "double")
	mvector = c(mu, ar, ma, armaOrder[3], mxreg)
	gamma1 = gamma2 = delta = lambda = 0
	vvector = vector(mode = "double")
	vvector = c(hEst, alpha, beta, gamma1, gamma2, delta, lambda, vxreg)
	
	dvector = vector(mode = "double")
	# future expansion in dpar
	dpar3 = dpar4 = dpar5 = dpar6 = 0
	dvector = c(skew, shape, dpar3, dpar4, dpar5, dpar6)
	
	zrf = as.double(zrf)
	data = as.double(data)
	
	h = as.vector(rep(0, T), mode="numeric")
	z = as.vector(rep(0, T), mode="numeric")
	res = as.double(res)
	nres = as.double(0)
	e = as.double(as.vector(rep(0, T)))
	constm = as.double(as.vector(rep(0, T)))
	condm = as.double(as.vector(rep(0, T)))
	llh = as.double(rep(0, 1))
	LHT = as.vector(rep(0, T), mode="numeric")
	
	ans = try(.C("sgarchfilterC2", ivector = ivector, mvector = mvector, vvector = vvector, 
					dvector = dvector, x = data, res = res, e = res^2, nres = nres, mexdata = mexdata, 
					vexdata = vexdata, zrf = zrf, constm = constm, condm = condm, h = h, 
					z = z, LHT = LHT, PACKAGE = "rgarch"), silent = TRUE)
	if(inherits(ans, "try-error")){
		assign(".csol", 1, envir = garchenv)
		assign(".filtermessage", ans, envir = garchenv)
		return(0)
	} else{
		assign(".csol", 0, envir = garchenv)
		return(ans)
	}
}

.arfimafitC = function(armaOrder, mu, ar, ma, mxreg, mexdata, sigma, dlambda, skew, shape, dist, data, 
		zrf, N, res, garchenv)
{
	m = as.integer(N[1])
	T = as.integer(N[2])
	armap = as.integer(armaOrder[1])
	armaq = as.integer(armaOrder[2])
	arfima = as.integer(armaOrder[4])
	incmex = as.integer(armaOrder[5])
	
	mu = as.double(mu)
	ar = as.double(ar)
	ma = as.double(ma)
	mxreg = as.double(mxreg)
	
	sigma = as.double(sigma)
	skew = as.double(skew)
	shape = as.double(shape)
	dist = as.integer(dist)
	zrf = as.double(zrf)
	data = as.double(data)
	
	# flatten exogenous matrix	
	if(armaOrder[5]>0){
		incmex = dim(as.matrix(mexdata))[2]
		mexdata = as.double(as.vector(mexdata))
	} else{
		mexdata = 0
		incmex = 0
	}
	
	z = as.vector(rep(0, T), mode="numeric")
	h = as.vector(rep(0, T), mode="numeric")
	res = as.double(res)
	constm = as.double(as.vector(rep(0, T)))
	condm = as.double(as.vector(rep(0, T)))
	llh = as.double(rep(0, 1))
	LHT = as.vector(rep(0, T), mode="numeric")
	
	ans = try(.C("arfimafitC", armap = armap, armaq = armaq, arfima = arfima, 
					incmex = incmex, mu = mu, ar = ar, ma = ma, mxreg = mxreg, sigma = sigma, 
					dlambda = as.double(dlambda), skew = skew, shape = shape, dist = dist, 
					x = data, res = res, mexdata = mexdata, zrf = zrf, constm = constm, 
					condm = condm, m = m, T = T, h = h, z = z, llh = llh, LHT = LHT, 
					PACKAGE = "rgarch"), silent = TRUE)
	if(inherits(ans, "try-error")){
		assign(".csol", 1, envir = garchenv)
		assign(".filtermessage", ans, envir = garchenv)
		return(0)
	} else{
		assign(".csol", 0, envir = garchenv)
		return(ans)
	}
}

.sgarchfitC = function(armaOrder, garchOrder, mu, ar, ma, inmean, mxreg, mexdata,
		omega, hEst, alpha, beta, vxreg, vexdata, dlambda, skew, shape, dist, data, zrf, N, 
		res, garchenv)
{
	
	m = as.integer(N[1])
	T = as.integer(N[2])
	armap = as.integer(armaOrder[1])
	armaq = as.integer(armaOrder[2])
	im = as.double(armaOrder[3])
	arfima = as.integer(armaOrder[4])
	incmex = as.integer(armaOrder[5])
	
	garchp = as.integer(garchOrder[1])
	garchq = as.integer(garchOrder[2])
	incvex = as.integer(garchOrder[3])
	
	mu = as.double(mu)
	ar = as.double(ar)
	ma = as.double(ma)
	inmean = as.double(inmean)
	mxreg = as.double(mxreg)
	
	omega = as.double(omega)
	hEst = as.double(hEst)
	alpha = as.double(alpha)
	beta = as.double(beta)
	vxreg = as.double(vxreg)
	
	skew = as.double(skew)
	shape = as.double(shape)
	dist = as.integer(dist)
	zrf = as.double(zrf)
	data = as.double(data)
	
	# flatten exogenous matrix	
	if(armaOrder[5]>0){
		incmex = dim(as.matrix(mexdata))[2]
		mexdata = as.double(as.vector(mexdata))
	} else{
		mexdata = 0
		incmex = 0
	}
	
	if(garchOrder[3]>0){
		incvex = dim(as.matrix(vexdata))[2]
		vexdata = as.double(as.vector(vexdata))
	} else{
		vexdata = 0
		incvex = 0
	}
	
	h = as.vector(rep(0, T), mode="numeric")
	z = as.vector(rep(0, T), mode="numeric")
	res = as.double(res)
	e = as.double(as.vector(rep(0, T)))
	constm = as.double(as.vector(rep(0, T)))
	condm = as.double(as.vector(rep(0, T)))
	llh = as.double(rep(0, 1))
	LHT = as.vector(rep(0, T), mode="numeric")
	
	ans = try(.C("sgarchfilterC", armap = armap, armaq = armaq, arfima = arfima, 
					im = im, incmex = incmex, garchp = garchp, garchq = garchq, 
					incvex = incvex, mu = mu, ar = ar, ma = ma, inmean = inmean, 
					mxreg = mxreg, omega = omega, hEst = hEst, alpha = alpha, 
					beta = beta, vxreg = vxreg, dlambda = as.double(dlambda), skew = skew, 
					shape = shape, dist = dist, x = data, res = res, e = res^2, 
					mexdata = mexdata, vexdata = vexdata, zrf = zrf, constm = constm, 
					condm = condm, m = m, T = T, h = h, z = z, llh = llh, LHT = LHT, 
					PACKAGE = "rgarch"), silent = TRUE)
	if(inherits(ans, "try-error")){
		assign(".csol", 1, envir = garchenv)
		assign(".filtermessage", ans, envir = garchenv)
		return(0)
	} else{
		assign(".csol", 0, envir = garchenv)
		return(ans)
	}
}

# sGARCH simulation C wrapper
.sgarchsimC = function(garchp, garchq, incvex, omega, alpha, beta, vxreg, h, z, res, vexdata, T, m)
{
	garchp = as.integer(garchp)
	garchq = as.integer(garchq)
	incvex = as.integer(incvex)
	omega = as.double(omega)
	alpha = as.double(alpha)
	beta = as.double(beta)
	vxreg = as.double(vxreg)
	h = as.double(h)
	z = as.double(z)
	res = as.double(res)
	e = as.double(res*res)
	vexdata = as.double(as.vector(vexdata))
	T = as.integer(T)
	m = as.integer(m)
		
	ans = try(.C("sgarchsimC", garchp = garchp, garchq = garchq, incvex = incvex, 
					omega = omega, alpha = alpha, beta = beta, vxreg = vxreg, 
					h = h, z = z, res = res, e = e, vexdata = vexdata, T = T, m = m, 
					PACKAGE = "rgarch"), silent = TRUE)
	if(inherits(ans, "try-error")){
		return(0)
	} else{
		return(ans)
	}
}

.armaxsim = function(armap, armaq, constm, ar, ma, x, res, T, m)
{
	armap = as.integer(armap)
	armaq = as.integer(armaq)
	ar = as.double(ar)
	ma = as.double(ma)
	x = as.double(x)
	res = as.double(res)
	T = as.integer(T)
	m = as.integer(m)
	constm = as.double(constm)
	ans = try(.C("armaxsim", armap = armap, armaq = armaq, constm = constm, ar = ar, 
					ma = ma, x = x, res = res, m = m, T = T, PACKAGE = "rgarch"), silent = TRUE)
	if(inherits(ans, "try-error")){
		return(0)
	} else{
		return(ans)
	}
}

.arfimaxsim = function(armap, armaq, constm, ar, ma, darfima, x, res, T)
{
	darfima = as.double(darfima)
	armap = as.integer(armap)
	armaq = as.integer(armaq)
	ar = as.double(ar)
	ma = as.double(ma)
	x = as.double(x)
	res = as.double(res)
	T = as.integer(T)
	constm = as.double(constm)
	flmin = as.double(.Machine$double.xmin)
	flmax = as.double(.Machine$double.xmax)
	epmin = as.double(.Machine$double.neg.eps)
	epmax = as.double(.Machine$double.eps)
	s = double(length(res))
	ans = try(.Fortran("fdsim", n = T, ip = armap, iq = armaq, ar = ar, ma = ma, d = darfima,
					rmu = constm, y = res, s = s, flmin = flmin, flmax = flmax,
					epmin = epmin, epmax = epmax, 
			PACKAGE = "rgarch"), silent = TRUE)
	if(inherits(ans, "try-error")){
		return(0)
	} else{
		return(ans)
	}
}


# fGARCH fit C wrapper
.fgarchfitC = function(armaOrder, garchOrder, mu, ar, ma, inmean, mxreg, mexdata,
		omega, hEst, alpha, beta, lambda, delta, gamma1, gamma2, fk, vxreg, vexdata, 
		dlambda, skew, shape, dist, data, zrf, N, res, garchenv)
{
	m = as.integer(N[1])
	T = as.integer(N[2])
	armap = as.integer(armaOrder[1])
	armaq = as.integer(armaOrder[2])
	im = as.double(armaOrder[3])
	arfima = as.integer(armaOrder[4])
	incmex = as.integer(armaOrder[5])
	
	garchp = as.integer(garchOrder[1])
	garchq = as.integer(garchOrder[2])
	incvex = as.integer(garchOrder[3])
	
	mu = as.double(mu)
	ar = as.double(ar)
	ma = as.double(ma)
	inmean = as.double(inmean)
	mxreg = as.double(mxreg)
	
	omega = as.double(omega)
	hEst = as.double(hEst)
	alpha = as.double(alpha)
	beta = as.double(beta)
	lambda = as.double(lambda)
	delta = as.double(delta)
	gamma1 = as.double(gamma1)
	gamma2 = as.double(gamma2)
	fk = as.integer(fk)
	kdelta = as.double(delta + fk*lambda)
	vxreg = as.double(vxreg)
	skew = as.double(skew)
	shape = as.double(shape)
	dist = as.integer(dist)
	zrf = as.double(zrf)
	data = as.double(data)
	
	# flatten exogenous matrix	
	if(armaOrder[5]>0){
		incmex = dim(as.matrix(mexdata))[2]
		mexdata = as.double(as.vector(mexdata))
	} else{
		mexdata = 0
		incmex = 0
	}
	
	if(garchOrder[3]>0){
		incvex = dim(as.matrix(vexdata))[2]
		vexdata = as.double(as.vector(vexdata))
	} else{
		vexdata = 0
		incvex = 0
	}
	
	h = as.double(rep(0, T))
	res = as.double(res)
	z = as.double(rep(0, T))
	constm = as.double(rep(0, T))
	condm = as.double(rep(0, T))
	llh = as.double(rep(0, 1))
	LHT = as.vector(rep(0, T), mode="numeric")

	ans = try(.C("fgarchfilterC", armap = armap, armaq = armaq, arfima = arfima, 
					im = im, incmex = incmex, garchp = garchp, garchq = garchq, 
					incvex = incvex, mu = mu, ar = ar, ma = ma, inmean = inmean, 
					mxreg = mxreg, omega = omega, hEst = hEst, alpha = alpha, 
					beta = beta, lambda = lambda, kdelta = kdelta, gamma1 = gamma1, gamma2 = gamma2, 
					vxreg = vxreg, dlambda = as.double(dlambda), skew = skew, shape = shape, dist = dist, x = data, 
					res = res, e = res^2, mexdata = mexdata, vexdata = vexdata, zrf = zrf, 
					constm = constm, condm = condm, m = m, T = T, h = h, z = z, llh = llh, 
					LHT = LHT, PACKAGE = "rgarch"), silent = TRUE)
	if(inherits(ans, "try-error")){
		assign(".csol", 1, envir = garchenv)
		assign(".filtermessage", ans, envir = garchenv)
		return(0)
	} else{
		assign(".csol", 0, envir = garchenv)
		return(ans)
	}
}

# fGARCH simulation C wrapper
.fgarchsimC = function(garchp, garchq, incvex, omega, alpha, beta, lambda, delta, gamma1, gamma2, fk, 
		vxreg, h, z, res, vexdata, T, m)
{
	garchp = as.integer(garchp)
	garchq = as.integer(garchq)
	incvex = as.integer(incvex)
	omega = as.double(omega)
	alpha = as.double(alpha)
	beta = as.double(beta)
	lambda = as.double(lambda)
	delta = as.double(delta)
	gamma1 = as.double(gamma1)
	gamma2 = as.double(gamma2)
	fk = as.integer(fk)
	kdelta = as.double(delta + fk*lambda)
	vxreg = as.double(vxreg)
	h = as.double(h)
	z = as.double(z)
	res = as.double(res)
	vexdata = as.double(as.vector(vexdata))
	T = as.integer(T)
	m = as.integer(m)
	
	ans = try(.C("fgarchsimC", garchp = garchp, garchq = garchq, incvex = incvex, 
					omega = omega, alpha = alpha, beta = beta, lambda = lambda, 
					kdelta = kdelta, gamma1 = gamma1, gamma2 = gamma2, vxreg = vxreg, h = h, 
					z = z, res = res, vexdata = vexdata, T = T,
					m = m, PACKAGE = "rgarch"), silent = TRUE)
	if(inherits(ans, "try-error")){
		return(0)
	} else{
		return(ans)
	}
}

.egarchfitC = function(armaOrder, garchOrder, mu, ar, ma, inmean, mxreg, mexdata,
		omega, hEst, alpha, beta, gm, kappa, vxreg, vexdata, dlambda, skew, shape, dist, 
		data, zrf, N, res, garchenv)
{
	m = as.integer(N[1])
	T = as.integer(N[2])
	armap = as.integer(armaOrder[1])
	armaq = as.integer(armaOrder[2])
	im = as.double(armaOrder[3])
	arfima = as.integer(armaOrder[4])
	incmex = as.integer(armaOrder[5])
	
	garchp = as.integer(garchOrder[1])
	garchq = as.integer(garchOrder[2])
	incvex = as.integer(garchOrder[3])
	
	mu = as.double(mu)
	ar = as.double(ar)
	ma = as.double(ma)
	inmean = as.double(inmean)
	mxreg = as.double(mxreg)
	
	omega = as.double(omega)
	hEst = as.double(hEst)
	alpha = as.double(alpha)
	beta = as.double(beta)
	gm = as.double(gm)
	meanz = as.double(kappa)
	
	vxreg = as.double(vxreg)
	
	skew = as.double(skew)
	shape = as.double(shape)
	dist = as.integer(dist)
	zrf = as.double(zrf)
	data = as.double(data)
	
	# flatten exogenous matrix	
	if(armaOrder[5]>0){
		incmex = dim(as.matrix(mexdata))[2]
		mexdata = as.double(as.vector(mexdata))
	} else{
		mexdata = 0
		incmex = 0
	}
	
	if(garchOrder[3]>0){
		incvex = dim(as.matrix(vexdata))[2]
		vexdata = as.double(as.vector(vexdata))
	} else{
		vexdata = 0
		incvex = 0
	}
	
	h = as.vector(rep(0, T), mode="numeric")
	z = as.vector(rep(0, T), mode="numeric")
	res = as.double(res)
	e = as.double(res^2)
	constm = as.double(as.vector(rep(0, T)))
	condm = as.double(as.vector(rep(0, T)))
	llh = as.double(rep(0, 1))
	LHT = as.vector(rep(0, T), mode="numeric")
	
	ans = try(.C("egarchfilterC", armap = armap, armaq = armaq, arfima = arfima, 
					im = im, incmex = incmex, garchp = garchp, garchq = garchq, 
					incvex = incvex, mu = mu, ar = ar, ma = ma, inmean = inmean, 
					mxreg = mxreg, omega = omega, hEst = hEst, alpha = alpha, 
					beta = beta, gm = gm, meanz = meanz, vxreg = vxreg, 
					dlambda = as.double(dlambda), skew = skew, shape = shape, dist = dist, 
					x = data, res = res, e = e, mexdata = mexdata, vexdata = vexdata, 
					zrf = zrf, constm = constm, condm = condm, m = m, T = T, h = h, z = z, 
					llh = llh, LHT = LHT, PACKAGE = "rgarch"), silent = TRUE)
	if(inherits(ans, "try-error")){
		assign(".csol", 1, envir = garchenv)
		assign(".filtermessage", ans, envir = garchenv)
		return(0)
	} else{
		assign(".csol", 0, envir = garchenv)
		return(ans)
	}
}

# eGARCH simulation C wrapper
.egarchsimC = function(garchp, garchq, incvex, omega, alpha, beta, gm, kappa, vxreg, h, z, res, 
		vexdata, T, m)
{
	garchp = as.integer(garchp)
	garchq = as.integer(garchq)
	incvex = as.integer(incvex)
	omega = as.double(omega)
	alpha = as.double(alpha)
	beta = as.double(beta)
	gm = as.double(gm)
	meanz = as.double(kappa)
	vxreg = as.double(vxreg)
	h = as.double(h)
	z = as.double(z)
	res = as.double(res)
	vexdata = as.double(as.vector(vexdata))
	T = as.integer(T)
	m = as.integer(m)
	
	ans = try(.C("egarchsimC", garchp = garchp, garchq = garchq, incvex = incvex, 
					omega = omega, alpha = alpha, beta = beta, gm = gm, 
					meanz = meanz, vxreg = vxreg, h = h, z = z, res = res, 
					vexdata = vexdata, T = T, m = m, PACKAGE = "rgarch"), silent = TRUE)
	if(inherits(ans, "try-error")){
		return(0)
	} else{
		return(ans)
	}
}

.gjrgarchfitC = function(armaOrder, garchOrder, mu, ar, ma, inmean, mxreg, mexdata,
		omega, hEst, alpha, beta, gm, vxreg, vexdata, dlambda, skew, shape, dist, data, zrf, 
		N, res, garchenv)
{
	m = as.integer(N[1])
	T = as.integer(N[2])
	armap = as.integer(armaOrder[1])
	armaq = as.integer(armaOrder[2])
	im = as.double(armaOrder[3])
	arfima = as.integer(armaOrder[4])
	incmex = as.integer(armaOrder[5])
	
	garchp = as.integer(garchOrder[1])
	garchq = as.integer(garchOrder[2])
	incvex = as.integer(garchOrder[3])
	
	mu = as.double(mu)
	ar = as.double(ar)
	ma = as.double(ma)
	inmean = as.double(inmean)
	mxreg = as.double(mxreg)
	
	omega = as.double(omega)
	hEst = as.double(hEst)
	alpha = as.double(alpha)
	beta = as.double(beta)
	gm = as.double(gm)
	vxreg = as.double(vxreg)
	
	skew = as.double(skew)
	shape = as.double(shape)
	dist = as.integer(dist)
	zrf = as.double(zrf)
	data = as.double(data)
	
	# flatten exogenous matrix	
	if(armaOrder[5]>0){
		incmex = dim(as.matrix(mexdata))[2]
		mexdata = as.double(as.vector(mexdata))
	} else{
		mexdata = 0
		incmex = 0
	}
	
	if(garchOrder[3]>0){
		incvex = dim(as.matrix(vexdata))[2]
		vexdata = as.double(as.vector(vexdata))
	} else{
		vexdata = 0
		incvex = 0
	}
	
	h = as.vector(rep(0, T), mode="numeric")
	z = as.vector(rep(0, T), mode="numeric")
	res = as.double(res)
	nres = as.vector(rep(0, T), mode="numeric")
	e = as.double(as.vector(rep(0, T)))
	constm = as.double(as.vector(rep(0, T)))
	condm = as.double(as.vector(rep(0, T)))
	llh = as.double(rep(0, 1))
	LHT = as.vector(rep(0, T), mode="numeric")
	
	ans = try(.C("gjrgarchfilterC", armap = armap, armaq = armaq, arfima = arfima, 
					im = im, incmex = incmex, garchp = garchp, garchq = garchq, 
					incvex = incvex, mu = mu, ar = ar, ma = ma, inmean = inmean, 
					mxreg = mxreg, omega = omega, hEst = hEst, alpha = alpha, 
					beta = beta, gm = gm, vxreg = vxreg, dlambda = as.double(dlambda), 
					skew = skew, shape = shape, dist = dist, x = data, res = res, nres = nres, 
					e = res^2, mexdata = mexdata, vexdata = vexdata, zrf = zrf, constm = constm, 
					condm = condm, m = m, T = T, h = h, z = z, llh = llh, LHT = LHT, 
					PACKAGE = "rgarch"), silent = TRUE)
	if(inherits(ans, "try-error")){
		assign(".csol", 1, envir = garchenv)
		assign(".filtermessage", ans, envir = garchenv)
		return(0)
	} else{
		assign(".csol", 0, envir = garchenv)
		return(ans)
	}
}

# gjrGARCH simulation C wrapper
.gjrgarchsimC = function(garchp, garchq, incvex, omega, alpha, beta, gm, vxreg, h, 
		z, res, nres, vexdata, T, m)
{
	garchp = as.integer(garchp)
	garchq = as.integer(garchq)
	incvex = as.integer(incvex)
	omega = as.double(omega)
	alpha = as.double(alpha)
	beta = as.double(beta)
	gm = as.double(gm)
	vxreg = as.double(vxreg)
	h = as.double(h)
	z = as.double(z)
	res = as.double(res)
	e = as.double(res*res)
	nres = as.double(nres)
	vexdata = as.double(as.vector(vexdata))
	T = as.integer(T)
	m = as.integer(m)
	
	ans = try(.C("gjrgarchsimC", garchp = garchp, garchq = garchq, incvex = incvex, 
					omega = omega, alpha = alpha, beta = beta, gm = gm, 
					vxreg = vxreg, h = h, z = z, res = res, e = e, nres = nres, 
					vexdata = vexdata, T = T, m = m, PACKAGE = "rgarch"), silent = TRUE)
	if(inherits(ans, "try-error")){
		return(0)
	} else{
		return(ans)
	}
}

.aparchfitC = function(armaOrder, garchOrder, mu, ar, ma, inmean, mxreg, mexdata,
		omega, hEst, alpha, beta, gm, delta, vxreg, vexdata, dlambda, skew, shape, dist, data, 
		zrf, N, res, garchenv)
{
	m = as.integer(N[1])
	T = as.integer(N[2])
	armap = as.integer(armaOrder[1])
	armaq = as.integer(armaOrder[2])
	im = as.double(armaOrder[3])
	arfima = as.integer(armaOrder[4])
	incmex = as.integer(armaOrder[5])
	
	garchp = as.integer(garchOrder[1])
	garchq = as.integer(garchOrder[2])
	incvex = as.integer(garchOrder[3])
	
	mu = as.double(mu)
	ar = as.double(ar)
	ma = as.double(ma)
	inmean = as.double(inmean)
	mxreg = as.double(mxreg)
	
	omega = as.double(omega)
	hEst = as.double(hEst)
	alpha = as.double(alpha)
	beta = as.double(beta)
	gm = as.double(gm)
	delta = as.double(delta)
	vxreg = as.double(vxreg)
	skew = as.double(skew)
	shape = as.double(shape)
	dist = as.integer(dist)
	zrf = as.double(zrf)
	data = as.double(data)
	
	# flatten exogenous matrix	
	if(armaOrder[5]>0){
		incmex = dim(as.matrix(mexdata))[2]
		mexdata = as.double(as.vector(mexdata))
	} else{
		mexdata = 0
		incmex = 0
	}
	
	if(garchOrder[3]>0){
		incvex = dim(as.matrix(vexdata))[2]
		vexdata = as.double(as.vector(vexdata))
	} else{
		vexdata = 0
		incvex = 0
	}
	
	h = as.double(rep(0, T))
	res = as.double(res)
	e = as.double(res*res)
	z = as.double(rep(0, T))
	constm = as.double(rep(0, T))
	condm = as.double(rep(0, T))
	llh = as.double(rep(0, 1))
	LHT = as.vector(rep(0, T), mode="numeric")
	
	ans = try(.C("aparchfilterC", armap = armap, armaq = armaq, arfima = arfima, 
					im = im, incmex = incmex, garchp = garchp, garchq = garchq, 
					incvex = incvex, mu = mu, ar = ar, ma = ma, inmean = inmean, 
					mxreg = mxreg, omega = omega, hEst = hEst, alpha = alpha, 
					beta = beta, gm = gm, delta = delta, vxreg = vxreg, 
					dlambda = as.double(dlambda), skew = skew, 
					shape = shape, dist = dist, x = data, res = res, e = e, 
					mexdata = mexdata, vexdata = vexdata, zrf = zrf, constm = constm, 
					condm = condm, m = m, T = T, h = h, z = z, llh = llh, LHT = LHT, 
					PACKAGE = "rgarch"),silent = TRUE)
	if(inherits(ans, "try-error")){
		assign(".csol", 1, envir = garchenv)
		assign(".filtermessage", ans, envir = garchenv)
		return(0)
	} else{
		assign(".csol", 0, envir = garchenv)
		return(ans)
	}
}

# apARCH simulation C wrapper
.aparchsimC = function(garchp, garchq, incvex, omega, alpha, beta, gm, delta, 
		vxreg, h, z, res, vexdata, T, m)
{
	garchp = as.integer(garchp)
	garchq = as.integer(garchq)
	incvex = as.integer(incvex)
	omega = as.double(omega)
	alpha = as.double(alpha)
	beta = as.double(beta)
	gm = as.double(gm)
	delta = as.double(delta)
	vxreg = as.double(vxreg)
	h = as.double(h)
	z = as.double(z)
	res = as.double(res)
	vexdata = as.double(as.vector(vexdata))
	T = as.integer(T)
	m = as.integer(m)
	
	ans  =  try(.C("aparchsimC", garchp = garchp, garchq = garchq, incvex = incvex, 
					omega = omega, alpha = alpha, beta = beta, gm = gm, delta = delta, 
					vxreg = vxreg, h = h, z = z, res = res, vexdata = vexdata, 
					T = T, m = m, PACKAGE = "rgarch"), 
			silent = TRUE)
	if(inherits(ans, "try-error")){
		return(0)
	} else{
		return(ans)
	}
}