(*		GNU General Public Licence		 *)

MODULE UpdaterMessages;

	

	IMPORT
		BugsMsg;

	VAR
		version-: INTEGER;
		maintainer-: ARRAY 40 OF CHAR;

	Map: PROCEDURE (IN key, mes: ARRAY OF CHAR);

	PROCEDURE Load*;
	BEGIN
		Map("UpdaterError11", "can not sample node ");
		Map("UpdaterError20", "too many iteraitions ");
		Map("UpdaterError1", "argument one ");
		Map("UpdaterError2", "argument two ");
		Map("UpdaterError26", "has too small a value ");

		Map("UpdaterForward.UpdaterUV", "univariate forward");
		Map("UpdaterForward.UpdaterMV", "multivariate forward");
		Map("UpdaterForward.Factory", "univariate forward");
		Map("UpdaterForward.FactoryMV", "multivariate forward");

		Map("UpdaterBeta.Updater", "conjugate beta");
		Map("UpdaterBeta.Factory", "conjugate beta");

		Map("UpdaterCatagorical.Updater", "catagorical");
		Map("UpdaterCatagorical.Factory", "catagorical");

		Map("UpdaterDFreeARS.StdUpdater", "adaptive rejection");
		Map("UpdaterDFreeARS.Left", "adaptive rejection");
		Map("UpdaterDFreeARS.Right", "adaptive rejection");
		Map("UpdaterDFreeARS.Interval", "adaptive rejection");
		Map("UpdaterDFreeARS.Factory", "adaptive rejection");

		Map("UpdaterDescreteSlice.StdUpdater", "descrete slice");
		Map("UpdaterDescreteSlice.Interval", "descrete slice");
		Map("UpdaterDescreteSlice.Factory", "descrete slice");

		Map("UpdaterEmpty.Upadter", "dummy");
		Map("UpdaterEmpty.Factory", "dummy");

		Map("UpdaterGriddy.Upadter", "griddy gibbs");
		Map("UpdaterGriddy.Factory", "griddy gibbs");

		Map("UpdaterGamma.Updater", "conjugate gamma");
		Map("UpdaterGamma.Factory", "conjugate gamma");

		Map("UpdaterMetover.Updater", "over-relaxed metropolis");
		Map("UpdaterMetover.Factory", "over-relaxed metropolis");

		Map("UpdaterDFreeHybrid1D.Updater", "hybrid metropolis 1D");
		Map("UpdaterDFreeHybrid1D.Factory", "hybrid metropolis 1D");

		Map("UpdaterMetbinomial.Updater", "descrete metropolis");
		Map("UpdaterMetbinomial.Factory", "descrete metropolis");

		Map("UpdaterMetnormal.UpdaterStd", "random walk metropolis");
		Map("UpdaterMetnormal.UpdaterDelayed", "random walk (delayed) metropolis");
		Map("UpdaterMetnormal.FactoryStd", "random walk metropolis");
		Map("UpdaterMetnormal.FactoryDelayed", "random walk (delayed) metropolis");

		Map("UpdaterNormal.StdUpdater", "conjugate normal");
		Map("UpdaterNormal.Left", "conjugate normal");
		Map("UpdaterNormal.Right", "conjugate normal");
		Map("UpdaterNormal.Interval", "conjugate normal");
		Map("UpdaterNormal.Factory", "conjugate normal");

		Map("UpdaterPareto.Updater", "conjugate pareto");
		Map("UpdaterPareto.Factory", "conjugate pareto");

		Map("UpdaterPoisson.Updater", "conjugate poisson");
		Map("UpdaterPoisson.Factory", "conjugate poisson");

		Map("UpdaterRejection.Logit", "logit rejection");
		Map("UpdaterRejection.Updater", "log-linear rejection");
		Map("UpdaterRejection.Factory", "logit/log-linear rejection");

		Map("UpdaterSCAAR.Updater", "adaptive acceptance rate");
		Map("UpdaterSCAAR.Factory", "adaptive acceptance rate");

		Map("UpdaterSDScale.Updater", "state dependent scale");
		Map("UpdaterSDScale.Factory", "state dependent scale");

		Map("UpdaterSCAM.Updater", "adaptive metropolis 1D");
		Map("UpdaterSCAM.UpdaterDelayed", "adaptive (delayed) metropolis 1D");
		Map("UpdaterSCAM.FactoryStd", "adaptive metropolis 1D");
		Map("UpdaterSCAM.FactoryDelayed", "adaptive (delayed) metropolis 1D");

		Map("UpdaterSCDE.Updater", "differential evolution 1D");
		Map("UpdaterSCDE.Factory", "differential evolution 1D");

		Map("UpdaterSlice.StdUpdater", "slice");
		Map("UpdaterSlice.Left", "slice");
		Map("UpdaterSlice.Right", "slice");
		Map("UpdaterSlice.Interval", "slice");
		Map("UpdaterSlice.Factory", "slice");

		Map("UpdaterNaivemet.Updater", "naive random walk");
		Map("UpdaterNaivemet.Factory", "naive random walk");

		Map("UpdaterAMblock.UpdaterHetro", "adaptive metropolis (mixed) block");
		Map("UpdaterAMblock.UpdaterHomo", "adaptive metropolis block");
		Map("UpdaterAMblock.UpdaterGLM", "adaptive metropolis (glm) block");
		Map("UpdaterAMblock.FactoryHetro", "adaptive metropolis (mixed) block");
		Map("UpdaterAMblock.FactoryHomo", "adaptive metropolis block");
		Map("UpdaterAMblock.FactoryGLM", "adaptive metropolis (glm) block");

		Map("UpdaterAMNLLS.UpdaterConditional", "adaptive metropolis NLLS");
		Map("UpdaterAMNLLS.UpdaterMarginal", "adaptive metropolis (marginal) NLLS");
		Map("UpdaterAMNLLS.FactoryConditional", "adaptive metropolis NLLS");
		Map("UpdaterAMNLLS.FactoryMarginal", "adaptive metropolis (marginal) NLLS");

		Map("UpdaterChain.Updater", "wrapper for chain graph");
		Map("UpdaterChain.Factory", "wrapper for chain graph");
		
		Map("UpdaterDEblock.UpdaterHetro", "differential evolution (mixed) block");
		Map("UpdaterDEblock.UpdaterHomo", "differential evolution block");
		Map("UpdaterDEblock.UpdaterGLM", "differential evolution (glm) block");
		Map("UpdaterDEblock.FactoryHetro", "differential evolution (mixed) block");
		Map("UpdaterDEblock.FactoryHomo", "differential evolution block");
		Map("UpdaterDEblock.FactoryGLM", "differential evolution (glm) block");

		Map("UpdaterDirichlet.Updater", "conjugate dirichlet");
		Map("UpdaterDirichlet.Factory", "conjugate dirichlet");

		Map("UpdaterDirichletprior.Updater", "non conjugate dirichlet");
		Map("UpdaterDirichletprior.Factory", "non conjugate dirichlet");

		Map("UpdaterDFreeHybrid.Updater", "block hybrid");
		Map("UpdaterDFreeHybrid.Factory", "block hybrid");

		Map("UpdaterGLM.UpdaterLogit", "logit block glm");
		Map("UpdaterGLM.UpdaterLoglin", "log-linear block glm");
		Map("UpdaterGLM.UpdaterNormal", "normal block glm");
		Map("UpdaterGLM.FactoryGLM", "logit/log-linear block glm ");
		Map("UpdaterGLM.FactoryNormal", "normal block glm");

		Map("UpdaterGMRF.UpdaterGeneral", "general GMRF");
		Map("UpdaterGMRF.UpdaterNormal", "normal GMRF");
		Map("UpdaterGMRF.FactoryGeneral", "general GMRF ");
		Map("UpdaterGMRF.FactoryNormal", "normal GMRF");

		Map("UpdaterHybridnormal.Updater", "normal block hybrid");
		Map("UpdaterHybridnormal.Factory", "normal block hybrid");

		Map("UpdaterHybridglm.UpdaterLogit", "logit block hybrid");
		Map("UpdaterHybridglm.UpdaterLoglin", "log-linear block hybrid");
		Map("UpdaterHybrid.UpdaterNormal", "normal block hybrid");
		Map("UpdaterHybridglm.FactoryGLM", "logit/log-linear block hybrid");
		Map("UpdaterHybridglm.FactoryNormal", "normal block hybrid");
		Map("UpdaterHybridglm.FactoryChain", "chain graph block hybrid");

		Map("UpdaterMultinomial.Updater", "multinomial prior");
		Map("UpdaterMultinomial.Factory", "multinomial prior");

		Map("UpdaterMVNormal.Updater", "conjugate mv normal (identity link)");
		Map("UpdaterMVNormal.Factory", "conjugate mv normal (identity link)");

		Map("UpdaterMVNLinear.StdUpdater", "conjugate mv normal");
		Map("UpdaterMVNLinear.Factory", "conjugate mv normal");

		Map("UpdaterWishart.Updater", "conjugate wishart");
		Map("UpdaterWishart.Factory", "conjugate wishart");
	
	END Load;

	PROCEDURE Maintainer;
	BEGIN
		version := 200;
		maintainer := "A.Thomas"
	END Maintainer;

	PROCEDURE Init;
	BEGIN
		Maintainer;
		Map := BugsMsg.Map
	END Init;

BEGIN
	Init
END UpdaterMessages.