mog_generic.h

Go to the documentation of this file.

#ifndef MOG_GENERIC_H
#define MOG_GENERIC_H

#include <itpp/base/vec.h>
#include <itpp/base/mat.h>
#include <itpp/base/array.h>


namespace itpp
{

class MOG_generic
{

public:

  MOG_generic() { init(); }

  MOG_generic(const std::string &name_in) { load(name_in); }

  MOG_generic(const int &K_in, const int &D_in, bool full_in = false) { init(K_in, D_in, full_in); }

  MOG_generic(Array<vec> &means_in, bool full_in = false) { init(means_in, full_in); }

  MOG_generic(Array<vec> &means_in, Array<vec> &diag_covs_in, vec &weights_in) { init(means_in, diag_covs_in, weights_in); }

  MOG_generic(Array<vec> &means_in, Array<mat> &full_covs_in, vec &weights_in) { init(means_in, full_covs_in, weights_in); }

  virtual ~MOG_generic() { cleanup(); }

  void init();

  void init(const int &K_in, const int &D_in, bool full_in = false);

  void init(Array<vec> &means_in, bool full_in = false);

  void init(Array<vec> &means_in, Array<vec> &diag_covs_in, vec &weights_in);

  void init(Array<vec> &means_in, Array<mat> &full_covs_in, vec &weights_in);

  virtual void cleanup();

  bool is_valid() const { return valid; }

  bool is_full() const { return full; }

  int get_K() const { if (valid) return(K); else return(0); }

  int get_D() const { if (valid) return(D); else return(0); }

  vec get_weights() const { vec tmp;  if (valid) { tmp = weights; } return tmp; }

  Array<vec> get_means() const { Array<vec> tmp; if (valid) { tmp = means; } return tmp; }

  Array<vec> get_diag_covs() const { Array<vec> tmp; if (valid && !full) { tmp = diag_covs; } return tmp; }

  Array<mat> get_full_covs() const { Array<mat> tmp; if (valid && full) { tmp = full_covs; } return tmp; }

  void set_means(Array<vec> &means_in);

  void set_diag_covs(Array<vec> &diag_covs_in);

  void set_full_covs(Array<mat> &full_covs_in);

  void set_weights(vec &weights_in);

  void set_means_zero();

  void set_diag_covs_unity();

  void set_full_covs_unity();

  void set_weights_uniform();

  void set_checks(bool do_checks_in) { do_checks = do_checks_in; }

  void set_paranoid(bool paranoid_in) { paranoid = paranoid_in; }

  virtual void load(const std::string &name_in);

  virtual void save(const std::string &name_in) const;

  virtual void join(const MOG_generic &B_in);

  virtual void convert_to_diag();

  virtual void convert_to_full();

  virtual double log_lhood_single_gaus(const vec &x_in, const int k);

  virtual double log_lhood(const vec &x_in);

  virtual double lhood(const vec &x_in);

  virtual double avg_log_lhood(const Array<vec> &X_in);

protected:

  bool do_checks;

  bool valid;

  bool full;

  bool paranoid;

  int K;

  int D;

  Array<vec> means;

  Array<vec> diag_covs;

  Array<mat> full_covs;

  vec weights;

  double log_max_K;

  vec log_det_etc;

  vec log_weights;

  Array<mat> full_covs_inv;

  Array<vec> diag_covs_inv_etc;

  bool check_size(const vec &x_in) const;

  bool check_size(const Array<vec> &X_in) const;

  bool check_array_uniformity(const Array<vec> & A) const;

  void set_means_internal(Array<vec> &means_in);
  void set_diag_covs_internal(Array<vec> &diag_covs_in);
  void set_full_covs_internal(Array<mat> &full_covs_in);
  void set_weights_internal(vec &_weigths);

  void set_means_zero_internal();
  void set_diag_covs_unity_internal();
  void set_full_covs_unity_internal();
  void set_weights_uniform_internal();

  void convert_to_diag_internal();
  void convert_to_full_internal();

  virtual void setup_means();

  virtual void setup_covs();

  virtual void setup_weights();

  virtual void setup_misc();

  virtual double log_lhood_single_gaus_internal(const vec &x_in, const int k);
  virtual double log_lhood_internal(const vec &x_in);
  virtual double lhood_internal(const vec &x_in);

private:
  vec tmpvecD;
  vec tmpvecK;

};

} // namespace itpp

#endif // #ifndef MOG_GENERIC_H

---