@pikaa-ai/pikaa 0.3.0 → 0.3.4

package/skills/rdkit/scripts/substructure_filter.py

@@ -1,386 +0,0 @@
-#!/usr/bin/env python3
-"""
-Substructure Filter
-
-Filter molecules based on substructure patterns using SMARTS.
-Supports inclusion and exclusion filters, and custom pattern libraries.
-
-Usage:
-    python substructure_filter.py molecules.smi --pattern "c1ccccc1" --output filtered.smi
-    python substructure_filter.py database.sdf --exclude "C(=O)Cl" --filter-type functional-groups
-"""
-
-import argparse
-import sys
-from pathlib import Path
-
-try:
-    from rdkit import Chem
-except ImportError:
-    print("Error: RDKit not installed. Install with: uv pip install rdkit")
-    sys.exit(1)
-
-
-# Common SMARTS pattern libraries
-PATTERN_LIBRARIES = {
-    'functional-groups': {
-        'alcohol': '[OH][C]',
-        'aldehyde': '[CH1](=O)',
-        'ketone': '[C](=O)[C]',
-        'carboxylic_acid': 'C(=O)[OH]',
-        'ester': 'C(=O)O[C]',
-        'amide': 'C(=O)N',
-        'amine': '[NX3]',
-        'ether': '[C][O][C]',
-        'nitrile': 'C#N',
-        'nitro': '[N+](=O)[O-]',
-        'halide': '[C][F,Cl,Br,I]',
-        'thiol': '[C][SH]',
-        'sulfide': '[C][S][C]',
-    },
-    'rings': {
-        'benzene': 'c1ccccc1',
-        'pyridine': 'n1ccccc1',
-        'pyrrole': 'n1cccc1',
-        'furan': 'o1cccc1',
-        'thiophene': 's1cccc1',
-        'imidazole': 'n1cncc1',
-        'indole': 'c1ccc2[nH]ccc2c1',
-        'naphthalene': 'c1ccc2ccccc2c1',
-    },
-    'pains': {
-        'rhodanine': 'S1C(=O)NC(=S)C1',
-        'catechol': 'c1ccc(O)c(O)c1',
-        'quinone': 'O=C1C=CC(=O)C=C1',
-        'michael_acceptor': 'C=CC(=O)',
-        'alkyl_halide': '[C][I,Br]',
-    },
-    'privileged': {
-        'biphenyl': 'c1ccccc1-c2ccccc2',
-        'piperazine': 'N1CCNCC1',
-        'piperidine': 'N1CCCCC1',
-        'morpholine': 'N1CCOCC1',
-    }
-}
-
-
-def load_molecules(file_path, keep_props=True):
-    """Load molecules from file."""
-    path = Path(file_path)
-
-    if not path.exists():
-        print(f"Error: File not found: {file_path}")
-        return []
-
-    molecules = []
-
-    if path.suffix.lower() in ['.sdf', '.mol']:
-        suppl = Chem.SDMolSupplier(str(path))
-    elif path.suffix.lower() in ['.smi', '.smiles', '.txt']:
-        suppl = Chem.SmilesMolSupplier(str(path), titleLine=False)
-    else:
-        print(f"Error: Unsupported file format: {path.suffix}")
-        return []
-
-    for idx, mol in enumerate(suppl):
-        if mol is None:
-            print(f"Warning: Failed to parse molecule {idx+1}")
-            continue
-
-        molecules.append(mol)
-
-    return molecules
-
-
-def create_pattern_query(pattern_string):
-    """Create SMARTS query from string or SMILES."""
-    # Try as SMARTS first
-    query = Chem.MolFromSmarts(pattern_string)
-    if query is not None:
-        return query
-
-    # Try as SMILES
-    query = Chem.MolFromSmiles(pattern_string)
-    if query is not None:
-        return query
-
-    print(f"Error: Invalid pattern: {pattern_string}")
-    return None
-
-
-def filter_molecules(molecules, include_patterns=None, exclude_patterns=None,
-                    match_all_include=False):
-    """
-    Filter molecules based on substructure patterns.
-
-    Args:
-        molecules: List of RDKit Mol objects
-        include_patterns: List of (name, pattern) tuples to include
-        exclude_patterns: List of (name, pattern) tuples to exclude
-        match_all_include: If True, molecule must match ALL include patterns
-
-    Returns:
-        Tuple of (filtered_molecules, match_info)
-    """
-    filtered = []
-    match_info = []
-
-    for idx, mol in enumerate(molecules):
-        if mol is None:
-            continue
-
-        # Check exclusion patterns first
-        excluded = False
-        exclude_matches = []
-        if exclude_patterns:
-            for name, pattern in exclude_patterns:
-                if mol.HasSubstructMatch(pattern):
-                    excluded = True
-                    exclude_matches.append(name)
-
-        if excluded:
-            match_info.append({
-                'index': idx + 1,
-                'smiles': Chem.MolToSmiles(mol),
-                'status': 'excluded',
-                'matches': exclude_matches
-            })
-            continue
-
-        # Check inclusion patterns
-        if include_patterns:
-            include_matches = []
-            for name, pattern in include_patterns:
-                if mol.HasSubstructMatch(pattern):
-                    include_matches.append(name)
-
-            # Decide if molecule passes inclusion filter
-            if match_all_include:
-                passed = len(include_matches) == len(include_patterns)
-            else:
-                passed = len(include_matches) > 0
-
-            if passed:
-                filtered.append(mol)
-                match_info.append({
-                    'index': idx + 1,
-                    'smiles': Chem.MolToSmiles(mol),
-                    'status': 'included',
-                    'matches': include_matches
-                })
-            else:
-                match_info.append({
-                    'index': idx + 1,
-                    'smiles': Chem.MolToSmiles(mol),
-                    'status': 'no_match',
-                    'matches': []
-                })
-        else:
-            # No inclusion patterns, keep all non-excluded
-            filtered.append(mol)
-            match_info.append({
-                'index': idx + 1,
-                'smiles': Chem.MolToSmiles(mol),
-                'status': 'included',
-                'matches': []
-            })
-
-    return filtered, match_info
-
-
-def write_molecules(molecules, output_file):
-    """Write molecules to file."""
-    output_path = Path(output_file)
-
-    if output_path.suffix.lower() in ['.sdf']:
-        writer = Chem.SDWriter(str(output_path))
-        for mol in molecules:
-            writer.write(mol)
-        writer.close()
-    elif output_path.suffix.lower() in ['.smi', '.smiles', '.txt']:
-        with open(output_path, 'w') as f:
-            for mol in molecules:
-                smiles = Chem.MolToSmiles(mol)
-                name = mol.GetProp('_Name') if mol.HasProp('_Name') else ''
-                f.write(f"{smiles} {name}\n")
-    else:
-        print(f"Error: Unsupported output format: {output_path.suffix}")
-        return
-
-    print(f"Wrote {len(molecules)} molecules to {output_file}")
-
-
-def write_report(match_info, output_file):
-    """Write detailed match report."""
-    import csv
-
-    with open(output_file, 'w', newline='') as f:
-        fieldnames = ['Index', 'SMILES', 'Status', 'Matches']
-        writer = csv.DictWriter(f, fieldnames=fieldnames)
-        writer.writeheader()
-
-        for info in match_info:
-            writer.writerow({
-                'Index': info['index'],
-                'SMILES': info['smiles'],
-                'Status': info['status'],
-                'Matches': ', '.join(info['matches'])
-            })
-
-
-def print_summary(total, filtered, match_info):
-    """Print filtering summary."""
-    print("\n" + "="*60)
-    print("Filtering Summary")
-    print("="*60)
-    print(f"Total molecules:     {total}")
-    print(f"Passed filter:       {len(filtered)}")
-    print(f"Filtered out:        {total - len(filtered)}")
-    print(f"Pass rate:           {len(filtered)/total*100:.1f}%")
-
-    # Count by status
-    status_counts = {}
-    for info in match_info:
-        status = info['status']
-        status_counts[status] = status_counts.get(status, 0) + 1
-
-    print("\nBreakdown:")
-    for status, count in status_counts.items():
-        print(f"  {status:15s}: {count}")
-
-    print("="*60)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='Filter molecules by substructure patterns',
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=f"""
-Pattern libraries:
-  --filter-type functional-groups    Common functional groups
-  --filter-type rings               Ring systems
-  --filter-type pains               PAINS (Pan-Assay Interference)
-  --filter-type privileged          Privileged structures
-
-Examples:
-  # Include molecules with benzene ring
-  python substructure_filter.py molecules.smi --pattern "c1ccccc1" -o filtered.smi
-
-  # Exclude reactive groups
-  python substructure_filter.py database.sdf --exclude "C(=O)Cl" -o clean.sdf
-
-  # Filter by functional groups
-  python substructure_filter.py molecules.smi --filter-type functional-groups -o fg.smi
-
-  # Remove PAINS
-  python substructure_filter.py compounds.smi --filter-type pains --exclude-mode -o clean.smi
-
-  # Multiple patterns
-  python substructure_filter.py mol.smi --pattern "c1ccccc1" --pattern "N" -o aromatic_amines.smi
-        """
-    )
-
-    parser.add_argument('input', help='Input file (SDF or SMILES)')
-    parser.add_argument('--pattern', '-p', action='append',
-                       help='SMARTS/SMILES pattern to include (can specify multiple)')
-    parser.add_argument('--exclude', '-e', action='append',
-                       help='SMARTS/SMILES pattern to exclude (can specify multiple)')
-    parser.add_argument('--filter-type', choices=PATTERN_LIBRARIES.keys(),
-                       help='Use predefined pattern library')
-    parser.add_argument('--exclude-mode', action='store_true',
-                       help='Use filter-type patterns for exclusion instead of inclusion')
-    parser.add_argument('--match-all', action='store_true',
-                       help='Molecule must match ALL include patterns')
-    parser.add_argument('--output', '-o', help='Output file')
-    parser.add_argument('--report', '-r', help='Write detailed report to CSV')
-    parser.add_argument('--list-patterns', action='store_true',
-                       help='List available pattern libraries and exit')
-
-    args = parser.parse_args()
-
-    # List patterns mode
-    if args.list_patterns:
-        print("\nAvailable Pattern Libraries:")
-        print("="*60)
-        for lib_name, patterns in PATTERN_LIBRARIES.items():
-            print(f"\n{lib_name}:")
-            for name, pattern in patterns.items():
-                print(f"  {name:25s}: {pattern}")
-        sys.exit(0)
-
-    # Load molecules
-    print(f"Loading molecules from: {args.input}")
-    molecules = load_molecules(args.input)
-    if not molecules:
-        print("Error: No valid molecules loaded")
-        sys.exit(1)
-
-    print(f"Loaded {len(molecules)} molecules")
-
-    # Prepare patterns
-    include_patterns = []
-    exclude_patterns = []
-
-    # Add custom include patterns
-    if args.pattern:
-        for pattern_str in args.pattern:
-            query = create_pattern_query(pattern_str)
-            if query:
-                include_patterns.append(('custom', query))
-
-    # Add custom exclude patterns
-    if args.exclude:
-        for pattern_str in args.exclude:
-            query = create_pattern_query(pattern_str)
-            if query:
-                exclude_patterns.append(('custom', query))
-
-    # Add library patterns
-    if args.filter_type:
-        lib_patterns = PATTERN_LIBRARIES[args.filter_type]
-        for name, pattern_str in lib_patterns.items():
-            query = create_pattern_query(pattern_str)
-            if query:
-                if args.exclude_mode:
-                    exclude_patterns.append((name, query))
-                else:
-                    include_patterns.append((name, query))
-
-    if not include_patterns and not exclude_patterns:
-        print("Error: No patterns specified")
-        sys.exit(1)
-
-    # Print filter configuration
-    print(f"\nFilter configuration:")
-    if include_patterns:
-        print(f"  Include patterns: {len(include_patterns)}")
-        if args.match_all:
-            print("  Mode: Match ALL")
-        else:
-            print("  Mode: Match ANY")
-    if exclude_patterns:
-        print(f"  Exclude patterns: {len(exclude_patterns)}")
-
-    # Perform filtering
-    print("\nFiltering...")
-    filtered, match_info = filter_molecules(
-        molecules,
-        include_patterns=include_patterns if include_patterns else None,
-        exclude_patterns=exclude_patterns if exclude_patterns else None,
-        match_all_include=args.match_all
-    )
-
-    # Print summary
-    print_summary(len(molecules), filtered, match_info)
-
-    # Write output
-    if args.output:
-        write_molecules(filtered, args.output)
-
-    if args.report:
-        write_report(match_info, args.report)
-        print(f"Detailed report written to: {args.report}")
-
-
-if __name__ == '__main__':
-    main()

package/skills/relsa-severity-assessment/assets/example_cohort.csv

@@ -1,55 +0,0 @@
-id,treatment,condition,day,temp,weight,score,il6
-M01,treated,endpoint,-1,37.15,25.17,0,35.1
-M01,treated,endpoint,0,37.26,25.25,0,39.5
-M01,treated,endpoint,1,35.83,23.12,4,162.0
-M01,treated,endpoint,2,35.29,21.82,5,218.8
-M01,treated,endpoint,3,35.12,21.44,7,252.8
-M01,treated,endpoint,4,35.22,20.92,7,266.9
-M01,treated,endpoint,5,34.47,20.74,7,280.0
-M01,treated,endpoint,6,,,,
-M01,treated,endpoint,7,,,,
-M02,treated,endpoint,-1,37.37,21.87,0,48.5
-M02,treated,endpoint,0,37.32,21.94,0,51.4
-M02,treated,endpoint,1,36.13,20.15,3,194.1
-M02,treated,endpoint,2,35.72,19.31,5,280.2
-M02,treated,endpoint,3,35.39,18.82,6,317.3
-M02,treated,endpoint,4,34.86,18.49,7,343.6
-M02,treated,endpoint,5,35.01,18.29,7,368.0
-M02,treated,endpoint,6,35.2,18.11,7,372.2
-M02,treated,endpoint,7,,,,
-M03,treated,survivor,-1,37.29,24.65,0,39.1
-M03,treated,survivor,0,37.28,24.74,0,32.9
-M03,treated,survivor,1,36.61,23.2,2,117.3
-M03,treated,survivor,2,36.17,22.61,3,165.0
-M03,treated,survivor,3,36.11,22.22,4,187.0
-M03,treated,survivor,4,36.54,22.45,3,162.8
-M03,treated,survivor,5,36.6,23.12,3,126.1
-M03,treated,survivor,6,36.49,23.46,2,104.0
-M03,treated,survivor,7,37.13,24.11,1,70.4
-M04,treated,survivor,-1,37.09,24.99,0,36.1
-M04,treated,survivor,0,36.88,24.98,0,37.1
-M04,treated,survivor,1,36.57,23.95,1,93.4
-M04,treated,survivor,2,36.6,23.55,2,118.1
-M04,treated,survivor,3,36.27,23.08,3,138.1
-M04,treated,survivor,4,36.09,23.38,3,151.1
-M04,treated,survivor,5,36.46,23.51,2,100.4
-M04,treated,survivor,6,36.52,24.11,2,86.4
-M04,treated,survivor,7,36.94,24.76,1,58.1
-S01,sham,sham,-1,37.49,25.34,0,49.6
-S01,sham,sham,0,37.67,25.39,0,58.1
-S01,sham,sham,1,37.1,25.39,1,74.9
-S01,sham,sham,2,37.27,24.88,0,75.6
-S01,sham,sham,3,37.02,24.89,0,72.0
-S01,sham,sham,4,37.17,25.23,1,78.6
-S01,sham,sham,5,37.51,25.12,1,88.2
-S01,sham,sham,6,37.53,25.03,0,75.9
-S01,sham,sham,7,37.47,25.21,0,44.4
-S02,sham,sham,-1,37.18,24.96,0,36.6
-S02,sham,sham,0,37.19,25.0,0,51.9
-S02,sham,sham,1,36.68,24.88,0,51.8
-S02,sham,sham,2,36.99,24.77,1,44.5
-S02,sham,sham,3,36.7,24.65,1,66.5
-S02,sham,sham,4,37.19,24.75,0,60.5
-S02,sham,sham,5,37.07,24.98,1,50.0
-S02,sham,sham,6,36.83,24.95,0,50.5
-S02,sham,sham,7,37.26,24.67,0,38.2

package/skills/relsa-severity-assessment/references/forecasting.md

@@ -1,155 +0,0 @@
-# foRcast: ARIMA forecasting of RELSA trajectories
-
-`scripts/forecast_relsa.py` ports the foRcast tool of Lutscher et al. (2026),
-*Front. Physiol.* 17:1869563 — an ARIMA model fitted per animal to its own RELSA trajectory,
-forecasting the score at the next time point (or at the humane endpoint) with a 95%
-prediction interval.
-
-The purpose is **triage, not automation**: identify the individuals at risk of reaching a
-humane endpoint so handling personnel give them attention, while avoiding euthanising animals
-that would have recovered. It is a proof of concept on 13 animals across seven models, not a
-validated clinical tool.
-
-## Why ARIMA
-
-ARIMA(p, d, q) combines an autoregressive part (p lags of the series), differencing (d, to
-remove trend and reach stationarity), and a moving-average part (q lags of the forecast
-errors). It needs nothing but the animal's own history, which suits single-animal severity
-assessment where each individual is its own control.
-
-Model selection follows Hyndman & Khandakar (2008), i.e. `forecast::auto.arima`:
-
-1. Choose `d` by successive KPSS tests (null = stationary; difference while it is rejected).
-2. Fit four seed models — (2,d,2), (0,d,0), (1,d,0), (0,d,1) — with and without a
-   constant/drift term.
-3. Hill-climb from the best of those over neighbouring `(p, q)` and the drift term until AICc
-   stops improving.
-
-`auto_arima(..., stepwise=False)` searches the full `p × q` grid instead. Both are bounded by
-`max_p`, `max_q`, `max_d`; the paper notes that the globally best model could lie outside that
-range, which is a limitation of the approach rather than of one implementation.
-
-## Interpolation: the necessary distortion
-
-Animal experiments typically produce **one measurement per animal per day**. ARIMA is
-conventionally said to want ~50 observations (Box et al., 2016), a number recently challenged
-(Hassouna & Al-Sahili, 2020) but still far above what a 7-day study yields. The paper's
-workaround is to interpolate linearly between observed values at 0.1-day increments and fit
-the model to that denser series, and it is explicit that this is an alteration of the method,
-not a free improvement:
-
-- It **raises autocorrelation and partial autocorrelation**, which is what lets automatic
-  order selection work at all on such short series.
-- It **narrows the prediction interval**, improving coverage (PICP) at the cost of honestly
-  representing uncertainty. The paper identifies interpolation as necessary "to minimize
-  errors while maximizing prediction interval coverage with narrower boundaries".
-- It adds no information. Interpolated points are a smoothness assumption, and a trajectory
-  that actually moved non-linearly between measurements is misrepresented.
-
-`interpolate_step=None` / `--interpolate-step 0` fits the observed series directly. Prefer it
-whenever measurement frequency allows — with automated home-cage or telemetry monitoring the
-interpolation step becomes unnecessary, which is the paper's own outlook.
-
-## Forecast directly, not variable-by-variable
-
-Two routes to a predicted RELSA score:
-
-- **Direct** — forecast the RELSA series itself. `forecast_animal()`, `predict_endpoint()`.
-- **Indirect** — forecast each outcome measure, then compute RELSA from the forecasts.
-  `forecast_indirect()`.
-
-The paper compared them in the sepsis model and direct won clearly: median deviation from the
-actual score −0.002 (direct) versus −0.240 (indirect), a large effect
-(d = 1.42, 95% CI [1.03, 1.81]). The reason is error propagation — each variable's forecast
-error accumulates through the score, whereas the direct forecast carries only its own error.
-
-Use direct. `forecast_indirect()` exists to reproduce the comparison and to inspect which
-variable is driving a forecast.
-
-## Metrics
-
-Reported together, because each hides a failure the others catch
-(`_common.forecast_metrics`):
-
-| Metric | Meaning | Failure mode it exposes |
-| --- | --- | --- |
-| **RMSE** | root mean square deviation of predictions from actual RELSA scores | point-forecast accuracy |
-| **PICP** | % of actual values falling inside the prediction interval | interval calibration |
-| **MPIW** | mean prediction interval width, in RELSA units | a model that buys 100% PICP by making the interval useless |
-
-MPIW is read against the RELSA scale, which normally spans about 0–1: the paper's overall
-MPIW of 1.69 means the average interval covered 169% of the RELSA range, and the pancreatic
-cancer model's 7.35 means 735% — a technically perfect PICP with almost no information in it.
-Always report MPIW next to PICP.
-
-## Published performance (Table 1)
-
-Predicting the RELSA score at the (pre-)humane endpoint from all measurements up to the time
-point immediately before it:
-
-| Model / intervention | Animals | RMSE | PICP [%] | MPIW |
-| --- | --- | --- | --- | --- |
-| Sepsis | 2 | 0.009 | 100 | 0.30 |
-| 1.5% DSS + restraint stress | 2 | 0.007 | 100 | 0.66 |
-| 1% DSS + blood sampling | 4 | 0.046 | 75 | 0.53 |
-| 1.5% DSS + blood sampling | 2 | 0.065 | 100 | 0.84 |
-| 1.5% DSS | 1 | 0.095 | 100 | 1.64 |
-| Pancreatic cancer | 1 | 0.177 | 100 | 7.35 |
-| Neurosurgery | 1 | 0.082 | 100 | 0.54 |
-| **Overall** | **13** | **0.069** | **96** | **1.69** |
-
-Five of the seven rows rest on one or two animals. The overall PICP of 96% comes from 13
-endpoint predictions.
-
-## What this port reproduces
-
-Using the public sepsis data (`tm_sepsis.txt`, 7 mice) with the paper's four telemetry
-variables, no turned variables, and the CLP animals as reference set:
-
-- Mouse ID_801 (the paper's Figure 1A): predicted RELSA 0.94 at the endpoint hour against an
-  actual 0.93, RMSE 0.010, actual value inside the 95% interval. The published sepsis row is
-  RMSE 0.009 over two animals.
-- PICP 100% for both endpoint animals, matching the published row.
-- MPIW 0.42–0.46 against a published 0.30 — this port's intervals are wider. The exact width
-  depends on the interpolation step, the fitted variance, and the state-space implementation
-  (statsmodels SARIMAX versus R's `arima`), so treat MPIW comparisons across
-  implementations as approximate.
-
-The paper's exact reference set and baseline window per model are in its Supplementary Table
-S2, which is not bundled here; small differences in those choices shift every score slightly.
-
-## Limits that matter more than the metrics
-
-- **ARIMA cannot predict a cliff.** The model assumes stationarity and linearity. An abrupt
-  collapse in the last hours before an endpoint is not forecastable from a smooth prior
-  trajectory — this is the paper's own failure case (Figure 1C, the DSS blood-sampling mouse
-  whose pre-endpoint score rose sharply and fell outside the 95% bounds). For sudden change,
-  the paper points to Bayesian online changepoint detection (Adams & MacKay, 2007) or
-  Markov switching models (Hamilton, 2020) as alternatives.
-- **An underestimated score is the dangerous error.** An overestimate merely prompts extra
-  attention; an underestimate discourages personnel from giving an animal the attention it
-  needs and can delay a euthanasia decision. Asymmetric consequences deserve asymmetric
-  handling: act on the *upper* bound of the interval.
-- **RELSA is a severity-assessment aid, not a decision rule.** An animal with a low RELSA
-  score that shows other signs of distress must still be handled accordingly. The paper is
-  explicit that RELSA is "intended as an aid to severity assessment rather than a decisive
-  parameter", and the RELSA package's own documentation states it is not a predictor of death.
-- **Two prior measurements are not enough.** The paper's largest direct-prediction errors
-  (Δ = 0.76 and 0.74) came from forecasts made at the earliest possible time point with only
-  two prior observations. `forecast_animal()` records a warning below four observed points.
-- **Parameter volatility hurts.** Activity forecast worst of the sepsis variables, being both
-  intrinsically volatile and measured at low frequency. Including a noisy variable in the
-  multivariate RELSA score mitigates its noise — one argument for the composite over
-  single-parameter forecasting.
-
-## Key references
-
-- Hyndman, R. J. & Khandakar, Y. (2008). Automatic time series forecasting: the forecast
-  package for R. *J. Stat. Softw.* 27, 1–22.
-- Hyndman, R. J. & Athanasopoulos, G. (2021). *Forecasting: Principles and Practice*, 3rd ed.
-- Khosravi, A. et al. (2011). Comprehensive review of neural network-based prediction
-  intervals. *IEEE Trans. Neural Netw.* 22, 1341. (PICP/MPIW)
-- Pang, J. et al. (2018). Optimize the coverage probability of prediction interval for anomaly
-  detection of sensor-based monitoring series. *Sensors* 18, 967.
-- Petrică, A. et al. (2016). Limitation of ARIMA models in financial and monetary economics.
-  *Theor. Appl. Econ.* 23, 19–42.