/*
Copyright (C) 1994-1998 Evgenii Rudnyi, http://Evgenii.Rudnyi.Ru/

Implementation of the algorithm described in  
E.B. Rudnyi. Statistical model of systematic errors: linear error model. Chemometrics and Intelligent Laboratory Systems. 1996, V. 34, N 1, p. 41-54. 

This software is a copyrighted work licensed under the terms, described
in the file "FREE_LICENSE". 
*/

#ifndef _SUMSQR_H
#define _SUMSQR_H

#include <list.h>
#include <set.h>
#include <fstream.h>
#include <math.h>
#include "data.h"

#define NO_SUBSTR_FOUND string::npos

typedef bool boolean;

class cString : public string
{
public:
  cString() {}
  explicit cString(size_t) {}
  cString(const char *s) : string(s) {}
  cString(const string &t) : string(t) {}

  size_t stringlen() const
    {return length();}
  size_t pos(cString t) const
    {return find(t);}
  const char* getstr() const
    {return c_str();}
  string operator%(string t) const
    {return substr(0, find_last_of(t) + 1);}
};

void init_res();
void init_par();
void init_est();
void post_analysis();
extern char* EQ;
extern char* LICENSE;
const int prcsn = 4;
const int wdth = 12;

class param
{
public:
  double x;
  double sx;
  boolean atr;
  boolean use;
  cString name;
  param() : name(10) {x = 0; sx = 0; atr = false; use = false;}
  param(double x, char* name, boolean atr = true) :
    x(x), atr(atr), name(name) {use = false;}
  friend ostream& operator<<(ostream& out, param& old);
};

typedef double (*RES)(double *reg);

extern param par[];
extern int nparam;

class residual : public cString
{
  RES  r;
  unsigned int np;
  unsigned long mask;

public:
  residual() : cString(10) {r = NULL; np = 0; mask = 0l;}
  residual(char* name, RES r, int np, long mask) :
                          cString(name), r(r), np(np), mask(mask) {}
  residual(const residual& old): cString(old), r(old.r), np(old.np),
                                 mask(old.mask) {}
  residual& operator=(const residual& old)
    {*(cString*)this = old; r = old.r; np = old.np;
     mask = old.mask; return *this;}
  RES getr() const {return r;}
  int getnp() const {return np;}
  long getmask() const {return mask;}
};

inline ostream& operator<<(ostream& out, residual& old)
{
  return out << *(cString*)&old;
}

const int nvar = 20;
extern double sr2t[nvar];
extern int Nst[nvar];
extern double gat[nvar];
extern int Ngat[nvar];
extern double gbt[nvar];
extern int Ngbt[nvar];

class series : public data
{
public:
  enum var_des {fixed, same, own};

  cString ID;
  cString eq;
  RES f;
  unsigned long mask;
  boolean hide;

  double sumi;
  double suma;
  double sumb;

  double sr2, sr2old;
  double adjust;
  int fl_sr2;
  int isr2;
  double ga, gaold;
  int fl_ga;
  int igat;
  double gb, gbold;
  int fl_gb;
  int igbt;

  double SS;

  series() : ID(10), eq(10)
    {init();}
//  STANDARDS(series)
//  series(size_t N, size_t nreg);

  void init();
  int operator==(const series& second) const
    {return ID == second.ID;}
  int operator<(const series& second)
    {return ID < second.ID;}
//  void clear();
//  void copy(const series &old);
//  void anal(char *in);

//  operator int() const;
//  friend ostream& operator<<(ostream &out, series &old);
//  friend istream& operator>>(istream &in, series &to);

//  void setsum();
//  void setres(double* res);
};


extern set<residual, less<residual> > res;
extern set<residual, less<residual> >::iterator ires;
extern list<series> ser;
extern list<series>::iterator iser;

enum fl_print {results, big_iter, all_iter};
enum fl_show {used, free_par, all_par};
enum fl_series {no_series, used_series, all_series};
enum fl_start {variances, parameters};
extern fl_print print;
extern fl_show show;
extern fl_series print_series;
extern fl_start start;
extern ofstream of;
extern int iss;
extern cString file_name;

istream& operator>>(istream& in, cString& old);
void print_par(param& t, double s = HUGE_VAL);
void print_ss_par_1();
void print_zxssq_1(int infer, int ier, double* work);
void print_all_points();

void anal_series();
void set_sums_1(series& t);
void set_sums(series& t, double* f, int& i);
extern "C" {
void ss(double* x, int *m, int *n, double* f);
double gat_solve(double *x);
double gbt_solve(double *x);
}
void eval_L(double& L, double& SS);
void eval_var_comp();

boolean open_streams(int agrc, char* argv[], ifstream& df, ifstream& sf);
void read_series(ifstream& df);
char read_var(ifstream& sf, int& fl, double& var, double* same_var, int& i);
void read_setfile(ifstream& sf);

#endif