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);
 
    const PhaseWeight& operator += (const PhaseWeight& weight);
 
    const PhaseWeight& operator *= (const PhaseWeight& weight);
 
    float& operator [] (unsigned i) { built = false; return weight[i]; }
 
    const float& operator [] (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