PhaseWeight.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/General/Pulsar/PhaseWeight.h
 
#ifndef __Pulsar_PhaseWeight_h
#define __Pulsar_PhaseWeight_h
 
#include "Reference.h"
#include "Estimate.h"
 
namespace Pulsar {
 
  class Profile;


  class PhaseWeight : public Reference::Able {
 
  public:

    PhaseWeight ();

    PhaseWeight (const Profile*);
 
    PhaseWeight (unsigned nbin);
    PhaseWeight (unsigned nbin, float set_all);

    PhaseWeight (const PhaseWeight& weight);

    PhaseWeight (const std::vector<float>& weight);

    ~PhaseWeight ();
    
    const PhaseWeight& operator = (const PhaseWeight& weight);
    void copy (const PhaseWeight& weight);
    void copy (const PhaseWeight* weight) { copy(*weight); }

    const PhaseWeight& operator += (const PhaseWeight& weight);
    void elementwise_sum (const PhaseWeight& weight);
    void elementwise_sume (const PhaseWeight* weight) { elementwise_sum(*weight); }

    const PhaseWeight& operator *= (const PhaseWeight& weight);
    void elementwise_product (const PhaseWeight& weight);
    void elementwise_product (const PhaseWeight* weight) { elementwise_product(*weight); }

    float& operator [] (unsigned i) { built = false; return weight[i]; }

    const float& operator [] (unsigned i) const { return weight[i]; }

    float& at (unsigned i) { built = false; return weight[i]; }

    const float& at (unsigned i) const { return weight[i]; }

    void resize (unsigned nbin) { weight.resize(nbin); }

    unsigned get_nbin () const { return weight.size(); }

    double get_frequency () const { return reference_frequency; }

    void set_frequency (double f) { reference_frequency = f; }

    void set_all (float weight);

    void negate ();
  
    double get_weight_sum () const;

    unsigned get_nonzero_weight_count () const;

    std::string get_start_index () const;

    std::string get_end_index () const;

    double get_weight_max () const;

    void get_weights (std::vector<float>& weights) const;

    void weight_Profile (Profile* profile) const;

    void set_Profile (const Profile* profile) const;

    double get_weighted_sum () const;

    float get_avg () const;

    float get_rms () const;

    float get_min () const;

    float get_max () const;

    float get_median () const;

    float get_median_difference () const;

    Estimate<double> get_mean () const;

    Estimate<double> get_variance () const;

    void stats (const Profile* profile,
                double* mean, double* variance=0, 
                double* varmean=0, double* varvar=0) const;

    float* get_weights () { return &(weight[0]); }

    const float* get_weights() const { return &(weight[0]); }

    void get_filtered (std::vector<float>& amps, 
                       bool equal = false, float wt = 0) const;

    class Interface;
 
  protected:

    double reference_frequency;

    std::vector<float> weight;

    mutable Reference::To<const Profile, false> profile;

    mutable bool built;

    mutable Estimate<double> mean;

    mutable Estimate<double> variance;

    mutable float median;
    mutable bool median_computed;

    mutable float median_diff;
    mutable bool median_diff_computed;

    mutable std::vector<float> non_zero;

    void fill_non_zero (const char* method) const;

    void build () const;

    void init ();

    void check_Profile (const char* method) const;

    void check_weight (unsigned nbin, const char* method) const;
 
  };
 
}
 
 
#endif // !defined __Pulsar_PhaseWeight_h