ac1.

smooth(m) ac1m
ac1.smooth(a) ac1a
genr se_ac1m=(ac1-ac1m)*(ac1-ac1m)
genr rmse_ac1m=@sqrt(@mean(se_ac1m))
genr se_ac1a=(ac1-ac1a)*(ac1-ac1a)
genr rmse_ac1a=@sqrt(@mean(se_ac1a))

ac2.smooth(m) ac2m
ac2.smooth(a) ac2a
genr se_ac2m=(ac2-ac2m)*(ac2-ac2m)
genr rmse_ac2m=@sqrt(@mean(se_ac2m))
genr se_ac2a=(ac2-ac2a)*(ac2-ac2a)
genr rmse_ac2a=@sqrt(@mean(se_ac2a))

ac3.smooth(m) ac3m
ac3.smooth(a) ac3a
genr se_ac3m=(ac3-ac3m)*(ac3-ac3m)
genr rmse_ac3m=@sqrt(@mean(se_ac3m))
genr se_ac3a=(ac3-ac3a)*(ac3-ac3a)
genr rmse_ac3a=@sqrt(@mean(se_ac3a))

bdo.smooth(m) bdom
bdo.smooth(a) bdoa
genr se_bdom=(bdo-bdom)*(bdo-bdom)
genr rmse_bdom=@sqrt(@mean(se_bdom))
genr se_bdoa=(bdo-bdoa)*(bdo-bdoa)
genr rmse_bdoa=@sqrt(@mean(se_bdoa))

bpi.smooth(m) bpim
bpi.smooth(a) bpia
genr se_bpim=(bpi-bpim)*(bpi-bpim)
genr rmse_bpim=@sqrt(@mean(se_bpim))
genr se_bpia=(bpi-bpia)*(bpi-bpia)
genr rmse_bpia=@sqrt(@mean(se_bpia))

chib.smooth(m) chibm
chib.smooth(a) chiba
genr se_chibm=(chib-chibm)*(chib-chibm)
genr rmse_chibm=@sqrt(@mean(se_chibm))
genr se_chiba=(chib-chiba)*(chib-chiba)
genr rmse_chiba=@sqrt(@mean(se_chiba))

mbt.smooth(m) mbtm
mbt.smooth(a) mbta
genr se_mbtm=(mbt-mbtm)*(mbt-mbtm)
genr rmse_mbtm=@sqrt(@mean(se_mbtm))
genr se_mbta=(mbt-mbta)*(mbt-mbta)
genr rmse_mbta=@sqrt(@mean(se_mbta))
pbc.smooth(m) pbcm
pbc.smooth(a) pbca
genr se_pbcm=(pbc-pbcm)*(pbc-pbcm)
genr rmse_pbcm=@sqrt(@mean(se_pbcm))
genr se_pbca=(pbc-pbca)*(pbc-pbca)
genr rmse_pbca=@sqrt(@mean(se_pbca))

pnb.smooth(m) pnbm
pnb.smooth(a) pnba
genr se_pnbm=(pnb-pnbm)*(pnb-pnbm)
genr rmse_pnbm=@sqrt(@mean(se_pnbm))
genr se_pnba=(pnb-pnba)*(pnb-pnba)
genr rmse_pnba=@sqrt(@mean(se_pnba))

psb.smooth(m) psbm
psb.smooth(a) psba
genr se_psbm=(psb-psbm)*(psb-psbm)
genr rmse_psbm=@sqrt(@mean(se_psbm))
genr se_psba=(psb-psba)*(psb-psba)
genr rmse_psba=@sqrt(@mean(se_psba))

rcb.smooth(m) rcbm
rcb.smooth(a) rcba
genr se_rcbm=(rcb-rcbm)*(rcb-rcbm)
genr rmse_rcbm=@sqrt(@mean(se_rcbm))
genr se_rcba=(rcb-rcba)*(rcb-rcba)
genr rmse_rcba=@sqrt(@mean(se_rcba))

secb.smooth(m) secbm
secb.smooth(a) secba
genr se_secbm=(secb-secbm)*(secb-secbm)
genr rmse_secbm=@sqrt(@mean(se_secbm))
genr se_secba=(secb-secba)*(secb-secba)
genr rmse_secba=@sqrt(@mean(se_secba))

ubp.smooth(m) ubpm
ubp.smooth(a) ubpa
genr se_ubpm=(ubp-ubpm)*(ubp-ubpm)
genr rmse_ubpm=@sqrt(@mean(se_ubpm))
genr se_ubpa=(ubp-ubpa)*(ubp-ubpa)
genr rmse_ubpa=@sqrt(@mean(se_ubpa))