modelflowib 2.76__tar.gz → 2.78__tar.gz

{modelflowib-2.76 → modelflowib-2.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelflowib
-Version: 2.76
+Version: 2.78
 Summary: A tool to solve and manage dynamic economic and financial models
 Author-email: Ib Hansen <Ib.Hansen.Iv@gmail.com>
 License-Expression: MIT

{modelflowib-2.76 → modelflowib-2.78}/modelclass.py

@@ -3188,7 +3188,7 @@ class Modify_Mixin():
         newnormalisation = [l.split() for l in lines]
         vars_before_normalization = {beforeendo.upper() for  beforeendo,afterendo in newnormalisation  }
         frml_normalize_strip = {(beforeendo.upper(),afterendo.upper()) : self.allvar[beforeendo]['frml'].replace('$','').split(' ',2)   for beforeendo,afterendo in newnormalisation }
-        frml_normalize_gross = {(beforeendo,afterendo) : (fname ,normal(expression,the_endo = afterendo,endo_lhs=False,add_factor=False))  for (beforeendo,afterendo),(frml,fname,expression)  in frml_normalize_strip.items() }
+        frml_normalize_gross = {(beforeendo,afterendo) : (fname ,normal(expression,the_endo = afterendo,endo_lhs=False,add_add_factor=False))  for (beforeendo,afterendo),(frml,fname,expression)  in frml_normalize_strip.items() }
         frmldict_normalized = {afterendo : f'FRML {fname} {nexpression.normalized}$'
                                for (beforeendo,afterendo),(fname,nexpression)  in frml_normalize_gross.items() }
 #        breakpoint() 
@@ -3282,8 +3282,10 @@ class Modify_Mixin():
 
         Parameters
         ----------
-        updateeq : TYPE
-            new equations seperated by newline . 
+        updateeq : str or Makemodel
+            new equations seperated by newline, or a Makemodel instance whose
+            normalized equations (including per-equation add factors and
+            fitted equations, when present) are used as the update.
         newfunks : TYPE, optional
             Additional userspecified functions. The default is [].
         calc_add : bool, optional
@@ -3297,32 +3299,50 @@ class Modify_Mixin():
             a dataframe with calculated add factors. Origin is the original models lastdf.
 
         '''
-        
-            
-        updatefunks=list(set(self.funks+newfunks) ) # 
-        
-        newmodelname = newname if newname else self.name+' Updated'      
-    
-        dfvars = set(self.lastdf.columns)    
-    
-        updatemodel = mp.tofrml(updateeq)   # create the moedl with the usual processing of frml's 
-        while '  ' in updatemodel:
-            updatemodel = updatemodel.replace('  ', ' ')
-        frml2   = updatemodel.split('$') 
-        frml2_strip = [mp.split_frml(f+'$') for f in frml2 if len(f)>2]
-        frml2_normal = [[frml,fname, 
-                         normal(expression[:-1],do_preprocess=do_preprocess,add_add_factor=add_add_factor,
-                                make_fixable = pt.kw_frml_name(fname.upper(),'FIXABLE'))]
-                           for allfrml,frml,fname,expression in frml2_strip] 
-        frmldict_update = {nexpression.endo_var: f'{frml} {fname} {nexpression.normalized}$' for 
-                           frml,fname,nexpression in frml2_normal} 
-        
-        
-        if add_add_factor:
-            frmldict_calc_add = {nexpression.endo_var: f'{frml} {fname} {nexpression.calc_add_factor}$' for 
-                    frml,fname,nexpression in frml2_normal if nexpression.endo_var in self.endogene|self.exogene|dfvars } 
-        else: 
-            frmldict_calc_add={}
+        from modelconstruct_estimation import Makemodel   # local to avoid circular import
+
+        updatefunks=list(set(self.funks+newfunks) ) #
+
+        newmodelname = newname if newname else self.name+' Updated'
+
+        dfvars = set(self.lastdf.columns)
+        new_var_description = self.var_description
+
+        if isinstance(updateeq, Makemodel):
+            # the Makemodel has already expanded, optionally estimated and normalized the
+            # equations, and decided add factor/fixable/fitted per equation from its flags
+            updatefunks = list(set(updatefunks + updateeq.funks))
+            new_var_description = {**self.var_description, **updateeq.var_description}
+            frml2_normal = [['FRML', fname, nexpression]
+                            for fname, (parts, nexpression)
+                            in zip(updateeq.normal_output_frmlnames, updateeq.normal)]
+            frmldict_update = {nexpression.endo_var: f'{frml} {fname} {nexpression.normalized}$' for
+                               frml,fname,nexpression in frml2_normal}
+            frmldict_update = {**frmldict_update,
+                               **{f'{nexpression.endo_var}_FITTED': f'FRML <FIT> {nexpression.fitted}$'
+                                  for frml,fname,nexpression in frml2_normal if len(nexpression.fitted)}}
+            frmldict_calc_add = {nexpression.endo_var: f'{frml} <CALC_ADD_FACTOR> {nexpression.calc_add_factor}$' for
+                    frml,fname,nexpression in frml2_normal
+                    if len(nexpression.calc_add_factor) and nexpression.endo_var in self.endogene|self.exogene|dfvars }
+        else:
+            updatemodel = mp.tofrml(updateeq)   # create the moedl with the usual processing of frml's
+            while '  ' in updatemodel:
+                updatemodel = updatemodel.replace('  ', ' ')
+            frml2   = updatemodel.split('$')
+            frml2_strip = [mp.split_frml(f+'$') for f in frml2 if len(f)>2]
+            frml2_normal = [[frml,fname,
+                             normal(expression[:-1],do_preprocess=do_preprocess,add_add_factor=add_add_factor,
+                                    make_fixable = pt.kw_frml_name(fname.upper(),'FIXABLE'))]
+                               for allfrml,frml,fname,expression in frml2_strip]
+            frmldict_update = {nexpression.endo_var: f'{frml} {fname} {nexpression.normalized}$' for
+                               frml,fname,nexpression in frml2_normal}
+
+
+            if add_add_factor:
+                frmldict_calc_add = {nexpression.endo_var: f'{frml} {fname} {nexpression.calc_add_factor}$' for
+                        frml,fname,nexpression in frml2_normal if nexpression.endo_var in self.endogene|self.exogene|dfvars }
+            else:
+                frmldict_calc_add={}
         # breakpoint()
             
         frmldict    = {k: v['frml'] for (k,v) in self.allvar.items() if k in self.endogene } # frml's in the existing model 
@@ -3331,8 +3351,8 @@ class Modify_Mixin():
         newfrml     = '\n'.join([f for f in newfrmldict.values()])
         newmodel    =  self.__class__(newfrml,modelname = f'updated {self.name}',
                                       funks=updatefunks,
-                                 var_description=self.var_description, 
-                                 model_description = self.model_description, 
+                                 var_description=new_var_description,
+                                 model_description = self.model_description,
                                  var_groups = self.var_groups , 
                                  reports = self.reports , 
                                  substitution = self.substitution, 

{modelflowib-2.76 → modelflowib-2.78}/modelconstruct_estimation.py

@@ -982,6 +982,16 @@ from IPython.display import display, Markdown, Math
 import re
 from IPython.display import display, Markdown, Math
 
+class Markdown(Markdown):
+    """IPython Markdown, but with the markdown source as the text/plain fallback.
+
+    The stock class reprs as '<IPython.core.display.Markdown object>', and that
+    string is what latex/pdf exporters show, as they can not render the
+    text/markdown mime type and fall back to text/plain. With the source as
+    repr, exported documents show the model text instead."""
+    def __repr__(self):
+        return str(self.data)
+
 def display_model(cell: str, spec: str = "markdown"):
     """
     Display a model specification.
@@ -1771,15 +1781,34 @@ def _estimation_record_to_markdown(record: dict) -> str:
 
     coefs = _estimator_coefficients_for_markdown(est)
     if coefs:
-        lines.extend([
-            "",
-            "| Parameter | Estimate |",
-            "|:--|--:|",
-        ])
+        try:
+            tvals = est.tvalues.to_dict()
+        except Exception:
+            tvals = {}
+        # NaN != NaN — only add the column when at least one t-stat exists.
+        has_t = any(v == v for v in tvals.values())
+        if has_t:
+            lines.extend([
+                "",
+                "| Parameter | Estimate | t-stat |",
+                "|:--|--:|--:|",
+            ])
+        else:
+            lines.extend([
+                "",
+                "| Parameter | Estimate |",
+                "|:--|--:|",
+            ])
         for key in sorted(coefs, key=lambda x: (str(x).split("__")[0], int(str(x).split("__")[-1]) if str(x).split("__")[-1].lstrip("-").isdigit() else str(x))):
-            lines.append(
-                f"| {_markdown_escape_cell(key)} | {_markdown_escape_cell(_markdown_format_number(coefs[key]))} |"
+            row = (
+                f"| {_markdown_escape_cell(key)} "
+                f"| {_markdown_escape_cell(_markdown_format_number(coefs[key]))} |"
             )
+            if has_t:
+                t = tvals.get(key)
+                t_cell = f"{t:.3f}" if t is not None and t == t else ""
+                row += f" {_markdown_escape_cell(t_cell)} |"
+            lines.append(row)
 
     return "\n".join(lines) + "\n"
 
@@ -2419,6 +2448,31 @@ class Makemodel(BaseExplode):
         """
         return MakeModelReport(self, title=title, plot_format=plot_format, report_all=report_all)
 
+    @property
+    def tvalues(self):
+        """t-statistics for all estimated equations as a DataFrame.
+
+        Rows are parameter tokens (``C__1``, ``C__2``, ...), one column per
+        estimated equation named by its endogenous variable. NaN where a
+        parameter is not in that equation or the backend provides no
+        t-statistic (fixed/derived parameters, failed covariance, EViews
+        ``NA`` rows).
+
+        Per-equation access: ``rec['estimator_object'].tvalues`` on the
+        entries of :attr:`estimation_records`.
+        """
+        import pandas as pd
+        cols = {}
+        for rec in self.estimation_records:
+            est = rec.get('estimator_object')
+            try:
+                ser = est.tvalues
+            except Exception:
+                continue
+            name = getattr(est, 'endo_var', '') or rec.get('frmlname', '')
+            cols[name] = ser
+        return pd.DataFrame(cols)
+
     @property
     def markdown_with_estimation(self) -> str:
         """Original Markdown input with compact estimation tables inserted.
@@ -2806,6 +2860,19 @@ class Listmodels(BaseExplode):
         """
         return MakeModelReport(self, title=title, plot_format=plot_format, report_all=report_all)
 
+    @property
+    def tvalues(self):
+        """t-statistics of all member Makemodels, combined column-wise.
+
+        See :attr:`Makemodel.tvalues` for the layout.
+        """
+        import pandas as pd
+        frames = [mex.tvalues for mex in self.makemodels]
+        frames = [f for f in frames if not f.empty]
+        if not frames:
+            return pd.DataFrame()
+        return pd.concat(frames, axis=1)
+
     @property
     def markdown_with_estimation(self) -> str:
         """Concatenate member Makemodel markdown-with-estimation strings."""

{modelflowib-2.76 → modelflowib-2.78}/modelestimator_new.py

@@ -99,6 +99,7 @@ from lmfit import Parameters, minimize
 from matplotlib.gridspec import GridSpec
 
 from modelclass import model
+from modelmanipulation import check_syntax
 import modelnormalize as nz
 
 
@@ -904,6 +905,13 @@ class Eq_parent:
         raw = self.org_eq.upper()
         eq_body, constraint_text = _split_st_clause(raw)
 
+        # 2a) Syntax-check the equation text BEFORE parameter-token
+        #     normalization. Typos like ``C(1)2020`` (missing ``*D``) or a
+        #     missing ``+`` between terms are clean SyntaxErrors here, but
+        #     after normalization they can merge into single valid
+        #     identifiers and slip through to give degenerate fits.
+        self._check_eq_syntax(eq_body)
+
         # 2) Normalize parameter tokens in both equation body AND constraints
         #    so names align downstream (e.g. ``C(1)`` -> ``C__1``).
         eq = _normalize_param_tokens(eq_body, self.est_param, self.param_names)
@@ -946,6 +954,7 @@ class Eq_parent:
         #    Subclasses that need a custom dataframe layout (e.g. mfcalc-built
         #    regressors for OLS) handle that themselves.
         if self.input_df is not None:
+            self._check_unknown_variables()
             self.eq_var_df = (
                 self.mdummy.insertModelVar(self.input_df)
                 .loc[:, self.varname_all]
@@ -953,7 +962,49 @@ class Eq_parent:
             )
             self.estimation_df = self.eq_var_df
 
-    # -- variable discovery (cached, derived from mdummy) ---------------------
+    @staticmethod
+    def _check_eq_syntax(eq_body: str) -> None:
+        """Raise ``SyntaxError`` (with a pinpointed location) if the equation
+        text does not parse as Python expressions.
+
+        Each side of the first ``=`` is checked separately — the full
+        statement would be an invalid Python assignment whenever the LHS is
+        a transformation like ``DLOG(...)``. Whitespace is preserved, which
+        is what makes missing-operator typos detectable.
+        """
+        checkable = eq_body.replace("@ABS(", "ABS(")
+        sides = [side.strip() for side in checkable.split("=", 1)]
+        check_syntax([side for side in sides if side])
+
+    def _check_unknown_variables(self) -> None:
+        """Print a diagnosis and raise for variables with no data column.
+
+        Every variable in the equation that is not a parameter placeholder
+        (active prefix or ``param_names``) or a helper slot must exist in
+        ``input_df``. Anything else would be inserted as an all-NaN column
+        by ``insertModelVar`` and silently degrade or break the fit —
+        typically a misspelled variable name or a forgotten ``param_names``
+        entry (``ALFA(1)`` with ``'alfa'`` not declared reads as a lead of
+        an unknown variable ALFA).
+        """
+        helpers = {"ACTUAL", "FITTED", "RESIDUALS"}
+        known = set(self.input_df.columns) | set(self.c_params) | helpers
+        unknown = sorted(set(self.varname_all) - known)
+        if unknown:
+            # Print the diagnosis, then raise a bare SyntaxError — same
+            # style as check_syntax. IPython renders SyntaxError without
+            # the frame stack, so the notebook shows the message above
+            # instead of a long construction call stack.
+            print(
+                f"{type(self).__name__}({self.endo_var}): the equation "
+                f"references variables with no column in input_df:\n"
+                f"    {unknown}\n"
+                f"Equation: {self.org_eq_clean}\n"
+                "Check for misspelled variable names or missing param_names "
+                "entries — such variables would otherwise enter the "
+                "estimation as all-NaN columns."
+            )
+            raise SyntaxError("Unknown variables in equation - see above") from None
 
     @property
     def mdummy(self):
@@ -1079,6 +1130,10 @@ class EstimatorBackend(Eq_parent, ABC):
         Default is a no-op. Override to reject equation forms the backend
         cannot handle.
 
+    :meth:`_tvalues_dict`
+        Default returns ``{}`` (no t-statistics). Override to return
+        ``{<prefix>__n: t}`` so the :attr:`tvalues` Series is populated.
+
     Standard attributes set during ``__post_init__``
     ------------------------------------------------
     regression_model : Any
@@ -1230,6 +1285,29 @@ class EstimatorBackend(Eq_parent, ABC):
                     break
         return mapped
 
+    # ---- t-statistics ------------------------------------------------------
+
+    def _tvalues_dict(self) -> Dict[str, float]:
+        """Backend-specific t-statistics keyed by ``{est_param}__n`` token.
+
+        Default: no t-statistics available. Backends override where the
+        fitted result exposes (or allows computing) them.
+        """
+        return {}
+
+    @cached_property
+    def tvalues(self) -> pd.Series:
+        """t-statistics as a Series keyed like :attr:`coef_ser`.
+
+        Parameters without an available t-statistic (fixed, derived, or the
+        backend could not provide one) are NaN.
+        """
+        tvals = self._tvalues_dict()
+        return pd.Series(
+            {p: tvals.get(p, float("nan")) for p in self.c_params},
+            name=self.caption, dtype=float,
+        )
+
     # ---- A/F and residuals (computed once, cached) -------------------------
 
     @cached_property
@@ -1486,6 +1564,13 @@ class Estimate_ols(EstimatorBackend):
             "<caption><h3>OLS Regression Results</h3></caption>",
         )
 
+    def _tvalues_dict(self) -> Dict[str, float]:
+        """statsmodels exposes t-statistics directly, keyed by regressor
+        column name — map those back to the canonical parameter tokens."""
+        return self._map_statsmodels_params(
+            self.regression_model.tvalues.to_dict()
+        )
+
     # ---- override estimation_smpl: OLS reports its EFFECTIVE sample --------
 
     @cached_property
@@ -1610,6 +1695,33 @@ class Estimate_nls_lmfit(EstimatorBackend):
             "<h2>Fit Result</h2>", "<h3>NLS Regression Results</h3>"
         )
 
+    def _tvalues_dict(self) -> Dict[str, float]:
+        """lmfit provides standard errors (from the covariance matrix when
+        ``calc_covar=True``); t = value / stderr. Fixed parameters, derived
+        (``expr``) parameters without propagated errors, and fits where the
+        covariance could not be estimated have ``stderr`` None (or NaN) and
+        are omitted (→ NaN in :attr:`tvalues`)."""
+        res = self.regression_model
+        out: Dict[str, float] = {}
+        for name, p in res.params.items():
+            # stderr is None when lmfit produced no uncertainties, and can
+            # be NaN when the covariance matrix is ill-conditioned.
+            if p.stderr and p.stderr == p.stderr:
+                out[name] = p.value / p.stderr
+        if not out and any(p.vary for p in res.params.values()):
+            print(
+                f"[{type(self).__name__}({self.endo_var})] WARNING: lmfit "
+                f"produced no parameter uncertainties "
+                f"(errorbars={getattr(res, 'errorbars', None)}), so no "
+                "t-values are available. Common causes: singular or "
+                "ill-conditioned Jacobian (collinear or huge-scale "
+                "regressors), parameters stuck at a bound, or a fit that "
+                "did not converge. Inspect "
+                "est.regression_model.params.pretty_print() and "
+                "est.regression_model.message."
+            )
+        return out
+
 
 # =============================================================================
 # Estimate_nls_eviews — nonlinear least squares via EViews (py2eviews)
@@ -1702,6 +1814,26 @@ class Estimate_nls_eviews(EstimatorBackend):
     def _render_summary_html(self) -> str:
         return eviews_output_to_html(self.regression_model)
 
+    def _tvalues_dict(self) -> Dict[str, float]:
+        """Parse the t-Statistic column from the EViews spool text.
+
+        Only the coefficient vector is read back from EViews numerically;
+        the coefficient table (Coefficient, Std. Error, t-Statistic, Prob.)
+        exists only as text in the spool. Rows where EViews prints ``NA``
+        simply do not match and stay NaN in :attr:`tvalues`.
+        """
+        if not isinstance(self.regression_model, str):
+            return {}
+        num = r"(-?[\d.]+(?:[eE][+-]?\d+)?)"
+        out: Dict[str, float] = {}
+        for m in re.finditer(
+            rf"^\s*C\((\d+)\)\s+{num}\s+{num}\s+{num}",
+            self.regression_model,
+            flags=re.MULTILINE,
+        ):
+            out[f"{self.est_param}__{m.group(1)}"] = float(m.group(4))
+        return out
+
 
 # =============================================================================
 # Estimate_nls — factory class dispatching on solver

{modelflowib-2.76 → modelflowib-2.78}/modelflowib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelflowib
-Version: 2.76
+Version: 2.78
 Summary: A tool to solve and manage dynamic economic and financial models
 Author-email: Ib Hansen <Ib.Hansen.Iv@gmail.com>
 License-Expression: MIT

{modelflowib-2.76 → modelflowib-2.78}/modelhtml.py

@@ -118,6 +118,7 @@ def _mmr_md_to_html(
 
     in_p = in_ul = in_ol = in_bll = in_fence = in_table = False
     tbl_hdr_done = False
+    pending_est = False
 
     def ep():
         nonlocal in_p
@@ -148,9 +149,24 @@ def _mmr_md_to_html(
     def end_all():
         ep(); eul(); eol(); ebll(); etbl()
 
+    def flush_est():
+        # Emit the panel for the last estimated equation once all of its
+        # '>>' continuation lines have been rendered, so the equation is not
+        # split around its estimation output.
+        nonlocal pending_est, rec_i, panel_i
+        if pending_est:
+            pending_est = False
+            if rec_i < len(est_records):
+                ebll()
+                out.append(_mmr_est_panel(est_records[rec_i], panel_i, plot_format))
+                panel_i += 1; rec_i += 1
+
     for raw in lines:
         s = raw.strip()
 
+        if pending_est and not s.startswith('>>'):
+            flush_est()
+
         # code fence (```)
         if s.startswith('```'):
             if in_fence:
@@ -192,20 +208,20 @@ def _mmr_md_to_html(
                 end_all()
                 out.append('<pre class="mmr-bll"><code>'); in_bll = True
             out.append(_mmr_annotate_bll(content, var_desc))
+            # The estimator tag may sit on a continuation line.
+            if _mmr_has_estimator_tag(raw):
+                pending_est = True
             continue
 
         # BLL equation >
         if s.startswith('>'):
             content = s[1:].strip()
-            has_est = _mmr_has_estimator_tag(raw)
             if not in_bll:
                 end_all()
                 out.append('<pre class="mmr-bll"><code>'); in_bll = True
             out.append(_mmr_annotate_bll(content, var_desc))
-            if has_est and rec_i < len(est_records):
-                ebll()
-                out.append(_mmr_est_panel(est_records[rec_i], panel_i, plot_format))
-                panel_i += 1; rec_i += 1
+            if _mmr_has_estimator_tag(raw):
+                pending_est = True
             continue
 
         # markdown table row
@@ -262,6 +278,7 @@ def _mmr_md_to_html(
 
     if in_fence:
         out.append('</code></pre>')
+    flush_est()
     end_all()
 
     # leftover estimation records not matched to any source line

{modelflowib-2.76 → modelflowib-2.78}/modeljupytermagic.py

@@ -27,6 +27,10 @@ from modelclass import model
 from modelmanipulation import explode
 from model_latex_class import a_latex_model
 from modelconstruct_estimation import Makemodel, display_model
+# Markdown subclass whose text/plain fallback is the markdown source itself,
+# so latex/pdf exports show the model text instead of
+# '<IPython.core.display.Markdown object>'. Shadows the IPython import above.
+from modelconstruct_estimation import Markdown
 from modelhelp import debug_var
 from modelreport import LatexRepo
 
@@ -589,7 +593,7 @@ try:
             if dict_name in user_ns:
                 segs = list(user_ns[dict_name].keys())
                 print(f"Model `{name}` built from segments: {', '.join(segs)}")
-            print(f"✅ Created Mexplode model: {name}")
+            print(f"✅ Created Makemodel: {name}")
             print(emodel)
 
         return emodel

{modelflowib-2.76 → modelflowib-2.78}/modelnormalize.py

@@ -129,8 +129,19 @@ def funk_find_arg(funk_match, streng):
             return streng[:start], match[1:index], match[index + 1:]
     assert 1==2,f'Parantese mismatch in {streng}'
 
+def funk_check_arg(funk,arg,udtryk,udtryk_up):
+    '''Guards against variables named like a function.
+
+    A lagged variable with a function name, fx DIFF(-1), matches DIFF( and would
+    silently be swallowed as a function call. If the argument is a pure signed
+    integer it must be such a lag, so raise an informative error instead.'''
+    if re.fullmatch(r'[+-]?\d+',arg.replace(' ','')):
+        raise Exception(f"A variable can not be named {funk}, as {funk}( is a function in the business language.\n"
+                        f"{funk}({arg}) looks like a lagged variable {funk}. Rename the variable.\n"
+                        f"Original expression: {udtryk}\n"
+                        f"Processed so far   : {udtryk_up}")
+
 
- 
 def preprocess(udtryk,funks=[]):
     '''
     test processing expanding dlog,diff,movavg,pct,logit functions 
@@ -146,16 +157,21 @@ def preprocess(udtryk,funks=[]):
 
     '''
     udtryk_up = udtryk.upper().replace(' ','')
+    udtryk_up = funk_replace('PCT','PCT_GROWTH',udtryk_up)
+
     while  dlog_match := funk_in('DLOG',udtryk_up):
          fordlog,dlogudtryk_up,efterdlog=funk_find_arg(dlog_match,udtryk_up)
-         udtryk_up=fordlog+'DIFF(LOG('+dlogudtryk_up+'))'+efterdlog 
-          
+         funk_check_arg('DLOG',dlogudtryk_up,udtryk,udtryk_up)
+         udtryk_up=fordlog+'DIFF(LOG('+dlogudtryk_up+'))'+efterdlog
+
     while  logit_match := funk_in('LOGIT',udtryk_up):
          forlogit,logitudtryk_up,efterlogit=funk_find_arg(logit_match,udtryk_up)
-         udtryk_up=forlogit+'(LOG('+logitudtryk_up+'/(1.0 -'+logitudtryk_up+')))'+efterlogit 
-         
+         funk_check_arg('LOGIT',logitudtryk_up,udtryk,udtryk_up)
+         udtryk_up=forlogit+'(LOG('+logitudtryk_up+'/(1.0 -'+logitudtryk_up+')))'+efterlogit
+
     while  movavg_match := funk_in('MOVAVG', udtryk_up):
          forkaede,kaedeudtryk,efterkaede=funk_find_arg(movavg_match,udtryk_up)
+         funk_check_arg('MOVAVG',kaedeudtryk,udtryk,udtryk_up)
          arg=kaedeudtryk.split(',',1)
          avg='(('
          term=arg[0]
@@ -168,19 +184,23 @@ def preprocess(udtryk,funks=[]):
      
     while  pct_match := funk_in('PCT_GROWTH',udtryk_up):
         forpc,pcudtryk,efterpc=funk_find_arg(pct_match,udtryk_up)
-        udtryk_up=f'{forpc} (100 * ( ({pcudtryk}) / ({lagone(pcudtryk,funks=funks)}) -1)) {efterpc}'           
+        funk_check_arg('PCT_GROWTH',pcudtryk,udtryk,udtryk_up)
+        udtryk_up=f'{forpc} (100 * ( ({pcudtryk}) / ({lagone(pcudtryk,funks=funks)}) -1)) {efterpc}'
 
     while  pct_match := funk_in('PCY',udtryk_up):
         forpc,pcudtryk,efterpc=funk_find_arg(pct_match,udtryk_up)
-        udtryk_up=f'{forpc} (100 * ( ({pcudtryk}) / ({lagone(pcudtryk,funks=funks,laglead=-4)}) -1)) {efterpc}'           
-         
+        funk_check_arg('PCY',pcudtryk,udtryk,udtryk_up)
+        udtryk_up=f'{forpc} (100 * ( ({pcudtryk}) / ({lagone(pcudtryk,funks=funks,laglead=-4)}) -1)) {efterpc}'
+
     while  diff_match := funk_in('DIFF' , udtryk_up):
         fordif,difudtryk_up,efterdif=funk_find_arg(diff_match,udtryk_up)
-        udtryk_up=fordif+'(('+difudtryk_up+')-('+lagone(difudtryk_up+'',funks=funks)+'))'+efterdif  
-         
+        funk_check_arg('DIFF',difudtryk_up,udtryk,udtryk_up)
+        udtryk_up=fordif+'(('+difudtryk_up+')-('+lagone(difudtryk_up+'',funks=funks)+'))'+efterdif
+
     while  diff_match := funk_in('D' , udtryk_up):
         # print(f'{udtryk_up} on D')
         fordif,difudtryk_up,efterdif=funk_find_arg(diff_match,udtryk_up)
+        funk_check_arg('D',difudtryk_up,udtryk,udtryk_up)
         difudtryk_up = difudtryk_up.replace(' ','').replace(',0,1','') if difudtryk_up.endswith(',0,1')  else difudtryk_up
         udtryk_up=fordif+'(('+difudtryk_up+')-('+lagone(difudtryk_up+'',funks=funks)+'))'+efterdif  
          
@@ -407,7 +427,7 @@ if __name__ == '__main__':
     normal('a+b = c',add_add_factor=1,make_fitted=1).fprint
     normal('PCT_growth(a) = n(-1)',add_add_factor=0).fprint
     normal('a = movavg(pct(b),2)',add_add_factor=0).fprint
-    normal('pct_growth(c) = pct_growth(d)',add_add_factor=0).fprint
+    normal('pct_growth(c) = pct_growth(dd)',add_add_factor=0).fprint
     normal('pct_growth(c) = z+pct(b) + pct(e)').fprint
     normal('pct_growth(c) = z+pct(b) + pct(e)').fprint
     normal('a = pct_growth(b)',add_add_factor=0).fprint