Changeset 996

Timestamp:

04/06/06 13:45:58 (19 years ago)

Author:

mar637

Message:

more fixes after compiling with -Wall.

Location:

trunk/src

Files:

• MathUtils.cpp (modified) (2 diffs)
• STAsciiWriter.cpp (modified) (2 diffs)
• STAsciiWriter.h (modified) (1 diff)
• STAttr.h (modified) (3 diffs)
• STFiller.h (modified) (1 diff)
• STLineFinder.cpp (modified) (28 diffs)
• STMath.cpp (modified) (7 diffs)
• STMathWrapper.h (modified) (3 diffs)
• STWriter.cpp (modified) (5 diffs)
• Scantable.cpp (modified) (6 diffs)

trunk/src/MathUtils.cpp

@@ -42 +42 @@
 
 float mathutil::statistics(const String& which,
-                           const MaskedArray<Float>& data)
+                           const MaskedArray<Float>& data)
 {
    String str(which);
@@ -68 +68 @@
       return median(data);
    }
+   return 0.0;
 }
 

trunk/src/STAsciiWriter.cpp

@@ -123 +123 @@
 
     of << std::left << setw(16) << "x";
-    for ( int i=0; i<t.nrow(); ++i ) {
+    for ( unsigned int i=0; i<t.nrow(); ++i ) {
       ostringstream os,os1;
       os << "y" << i;
@@ -136 +136 @@
     Matrix<Float> specs = specCol.getColumn();
     Matrix<uChar> flags = flagCol.getColumn();
-    for ( int i=0; i<specs.nrow(); ++i ) {
+    for ( unsigned int i=0; i<specs.nrow(); ++i ) {
       of << setw(16) << setprecision(8) << abc[i] ;
-      for ( int j=0; j<specs.ncolumn(); ++j ) {
+      for ( unsigned int j=0; j<specs.ncolumn(); ++j ) {
         of << setw(16) << setprecision(8) << specs(i,j) ;
         of << setw(7) << Int(flags(i,j));

trunk/src/STAsciiWriter.h

@@ -50 +50 @@
 
 // Destructor
-  ~STAsciiWriter();
+  virtual ~STAsciiWriter();
 
 // Write out ascii table

trunk/src/STAttr.h

@@ -52 +52 @@
 
   // Destructor
-  ~STAttr();
+  virtual ~STAttr();
 
   // Copy Constructor (copy semantics)
@@ -66 +66 @@
   casa::Vector<casa::Float>
   beamEfficiency(Instrument instr, const casa::MEpoch& dateObs,
-                 const casa::Vector<casa::Float>& freqs) const;
+                 const casa::Vector<casa::Float>& freqs) const;
 
   // Aperture efficiency. Frequency in Hz.  Returns 1 if unknown.
   casa::Vector<casa::Float>
   apertureEfficiency(Instrument instr,
-                     const casa::MEpoch& dateObs,
-                     const casa::Vector<casa::Float>& freqs) const;
+                     const casa::MEpoch& dateObs,
+                     const casa::Vector<casa::Float>& freqs) const;
 
   // Find factor to convert Jy -> K for this telescope, date of
   // observation and frequency (Hz)
   casa::Vector<casa::Float> JyPerK(Instrument instr,
-                                   const casa::MEpoch& dateObs,
-                                   const casa::Vector<casa::Float>& freqs)
+                                   const casa::MEpoch& dateObs,
+                                   const casa::Vector<casa::Float>& freqs)
     const;
 
@@ -117 +117 @@
   // Linear interpolation
   casa::Vector<casa::Float> interp(const casa::Vector<casa::Float>& xOut,
-                                   const casa::Vector<casa::Float>& xIn,
-                                   const casa::Vector<casa::Float>& yIn) const;
+                                   const casa::Vector<casa::Float>& xIn,
+                                   const casa::Vector<casa::Float>& yIn) const;
 
 

trunk/src/STFiller.h

@@ -66 +66 @@
    * Destructor
    */
-  ~STFiller();
+  virtual ~STFiller();
 
   /**

trunk/src/STLineFinder.cpp

@@ -81 +81 @@
    int start_advance;     // number of channel from which the box can
                           // be moved (the middle of the box, if there is no
-                          // masking)
+                          // masking)
 public:
    // set up the object with the references to actual data
@@ -87 +87 @@
    RunningBox(const casa::Vector<casa::Float>  &in_spectrum,
                  const casa::Vector<casa::Bool>   &in_mask,
-                 const std::pair<int,int>         &in_edge,
-                 int in_max_box_nchan) throw(AipsError);
+                 const std::pair<int,int>         &in_edge,
+                 int in_max_box_nchan) throw(AipsError);
 
    // access to the statistics
@@ -139 +139 @@
    int  min_nchan;                         // A minimum number of consequtive
                                            // channels, which should satisfy
-                                           // the detection criterion, to be
-                                           // a detection
+                                           // the detection criterion, to be
+                                           // a detection
    casa::Float threshold;                  // detection threshold - the
                                            // minimal signal to noise ratio
@@ -148 +148 @@
    casa::Vector<Int> signs;                // An array to store the signs of
                                            // the value - current mean
-                                           // (used to search wings)
+                                           // (used to search wings)
    casa::Int last_sign;                    // a sign (+1, -1 or 0) of the
                                            // last point of the detected line
@@ -157 +157 @@
    LFAboveThreshold(std::list<pair<int,int> > &in_lines,
                     int in_min_nchan = 3,
-                    casa::Float in_threshold = 5) throw();
+                    casa::Float in_threshold = 5) throw();
    virtual ~LFAboveThreshold() throw();
 
@@ -175 +175 @@
    //    max_box_nchan  - number of channels in the running box
    void findLines(const casa::Vector<casa::Float> &spectrum,
-                  const casa::Vector<casa::Bool> &mask,
-                  const std::pair<int,int> &edge,
-                  int max_box_nchan) throw(casa::AipsError);
+                  const casa::Vector<casa::Bool> &mask,
+                  const std::pair<int,int> &edge,
+                  int max_box_nchan) throw(casa::AipsError);
 
 protected:
@@ -213 +213 @@
 RunningBox::RunningBox(const casa::Vector<casa::Float>  &in_spectrum,
                        const casa::Vector<casa::Bool>   &in_mask,
-                       const std::pair<int,int>         &in_edge,
-                       int in_max_box_nchan) throw(AipsError) :
+                       const std::pair<int,int>         &in_edge,
+                       int in_max_box_nchan) throw(AipsError) :
         spectrum(in_spectrum), mask(in_mask), edge(in_edge),
-        max_box_nchan(in_max_box_nchan)
+        max_box_nchan(in_max_box_nchan)
 {
   rewind();
@@ -287 +287 @@
           sumf+=spectrum[ch];
           sumf2+=square(spectrum[ch]);
-          sumch+=Float(ch);
-          sumch2+=square(Float(ch));
-          sumfch+=spectrum[ch]*Float(ch);
-          need2recalculate=True;
+          sumch+=Float(ch);
+          sumch2+=square(Float(ch));
+          sumfch+=spectrum[ch]*Float(ch);
+          need2recalculate=True;
       }
   int ch2remove=ch-max_box_nchan;
@@ -298 +298 @@
           sumf-=spectrum[ch2remove];
           sumf2-=square(spectrum[ch2remove]);
-          sumch-=Float(ch2remove);
-          sumch2-=square(Float(ch2remove));
-          sumfch-=spectrum[ch2remove]*Float(ch2remove);
-          need2recalculate=True;
+          sumch-=Float(ch2remove);
+          sumch2-=square(Float(ch2remove));
+          sumfch-=spectrum[ch2remove]*Float(ch2remove);
+          need2recalculate=True;
       }
 }
@@ -361 +361 @@
                                    casa::Float in_threshold) throw() :
              min_nchan(in_min_nchan), threshold(in_threshold),
-             lines(in_lines), running_box(NULL) {}
+             lines(in_lines), running_box(NULL) {}
 
 LFAboveThreshold::~LFAboveThreshold() throw()
@@ -427 +427 @@
        if (is_detected_before) {
            if (cur_line.second-cur_line.first>min_nchan) {
-               // it was a detection. We need to change the list
-               Bool add_new_line=False;
-               if (lines.size()) {
-                   for (int i=lines.back().second;i<cur_line.first;++i)
-                        if (mask[i]) { // one valid channel in between
-                                //  means that we deal with a separate line
-                            add_new_line=True;
-                            break;
-                        }
-               } else add_new_line=True;
-               if (add_new_line)
-                   lines.push_back(cur_line);
+               // it was a detection. We need to change the list
+               Bool add_new_line=False;
+               if (lines.size()) {
+                   for (int i=lines.back().second;i<cur_line.first;++i)
+                        if (mask[i]) { // one valid channel in between
+                                //  means that we deal with a separate line
+                            add_new_line=True;
+                            break;
+                        }
+               } else add_new_line=True;
+               if (add_new_line)
+                   lines.push_back(cur_line);
                else lines.back().second=cur_line.second;
-           }
-           is_detected_before=False;
+           }
+           is_detected_before=False;
        }
   }
@@ -463 +463 @@
 // find spectral lines and add them into list
 void LFAboveThreshold::findLines(const casa::Vector<casa::Float> &spectrum,
-                              const casa::Vector<casa::Bool> &mask,
-                              const std::pair<int,int> &edge,
-                              int max_box_nchan)
+                              const casa::Vector<casa::Bool> &mask,
+                              const std::pair<int,int> &edge,
+                              int max_box_nchan)
                         throw(casa::AipsError)
 {
@@ -483 +483 @@
       for (;running_box->haveMore();running_box->next())
            variances[running_box->getChannel()-edge.first]=
-                                running_box->getLinVariance();
+                                running_box->getLinVariance();
 
       // in the future we probably should do a proper Chi^2 estimation
@@ -511 +511 @@
            const int ch=running_box->getChannel();
            if (running_box->getNumberOfBoxPoints()>=minboxnchan)
-               processChannel(mask[ch] && (fabs(running_box->aboveMean()) >=
-                  threshold*offline_variance), mask);
-           else processCurLine(mask); // just finish what was accumulated before
-
-           signs[ch]=getAboveMeanSign();
-           // os<<ch<<" "<<spectrum[ch]<<" "<<fabs(running_box->aboveMean())<<" "<<
+               processChannel(mask[ch] && (fabs(running_box->aboveMean()) >=
+                  threshold*offline_variance), mask);
+           else processCurLine(mask); // just finish what was accumulated before
+
+           signs[ch]=getAboveMeanSign();
+           // os<<ch<<" "<<spectrum[ch]<<" "<<fabs(running_box->aboveMean())<<" "<<
            //   threshold*offline_variance<<endl;
 
-           const Float buf=running_box->aboveMean();
-           if (buf>0) signs[ch]=1;
-           else if (buf<0) signs[ch]=-1;
-           else if (buf==0) signs[ch]=0;
-        //   os<<ch<<" "<<spectrum[ch]<<" "<<running_box->getLinMean()<<" "<<
-          //              threshold*offline_variance<<endl;
+           const Float buf=running_box->aboveMean();
+           if (buf>0) signs[ch]=1;
+           else if (buf<0) signs[ch]=-1;
+           else if (buf==0) signs[ch]=0;
+        //   os<<ch<<" "<<spectrum[ch]<<" "<<running_box->getLinMean()<<" "<<
+          //              threshold*offline_variance<<endl;
       }
       if (lines.size())
@@ -653 +653 @@
 void STLineFinder::setOptions(const casa::Float &in_threshold,
                               const casa::Int &in_min_nchan,
-                              const casa::Int &in_avg_limit,
+                              const casa::Int &in_avg_limit,
                               const casa::Float &in_box_size) throw()
 {
@@ -680 +680 @@
 //   can be achieved using a spectrum mask only
 int STLineFinder::findLines(const std::vector<bool> &in_mask,
-                const std::vector<int> &in_edge,
-                const casa::uInt &whichRow) throw(casa::AipsError)
-{
-  const int minboxnchan=4;
+                const std::vector<int> &in_edge,
+                const casa::uInt &whichRow) throw(casa::AipsError)
+{
+  //const int minboxnchan=4;
   if (scan.null())
       throw AipsError("STLineFinder::findLines - a scan should be set first,"
@@ -704 +704 @@
   if (in_edge.size()>2)
       throw AipsError("STLineFinder::findLines - the length of the in_edge parameter"
-                      "should not exceed 2");
+                      "should not exceed 2");
       if (!in_edge.size()) {
            // all spectra, no rejection
            edge.first=0;
-           edge.second=nchan;
+           edge.second=nchan;
       } else {
            edge.first=in_edge[0];
-           if (edge.first<0)
-               throw AipsError("STLineFinder::findLines - the in_edge parameter has a negative"
-                                "number of channels to drop");
-           if (edge.first>=nchan)
-               throw AipsError("STLineFinder::findLines - all channels are rejected by the in_edge parameter");
+           if (edge.first<0)
+               throw AipsError("STLineFinder::findLines - the in_edge parameter has a negative"
+                                "number of channels to drop");
+           if (edge.first>=int(nchan))
+               throw AipsError("STLineFinder::findLines - all channels are rejected by the in_edge parameter");
            if (in_edge.size()==2) {
-               edge.second=in_edge[1];
-               if (edge.second<0)
-                   throw AipsError("STLineFinder::findLines - the in_edge parameter has a negative"
-                                   "number of channels to drop");
+               edge.second=in_edge[1];
+               if (edge.second<0)
+                   throw AipsError("STLineFinder::findLines - the in_edge parameter has a negative"
+                                   "number of channels to drop");
                edge.second=nchan-edge.second;
-           } else edge.second=nchan-edge.first;
+           } else edge.second=nchan-edge.first;
            if (edge.second<0 || (edge.first>=edge.second))
-               throw AipsError("STLineFinder::findLines - all channels are rejected by the in_edge parameter");
+               throw AipsError("STLineFinder::findLines - all channels are rejected by the in_edge parameter");
        }
 
@@ -743 +743 @@
   Int avg_factor=1; // this number of adjacent channels is averaged together
                     // the total number of the channels is not altered
-                    // instead, min_nchan is also scaled
-                    // it helps to search for broad lines
+                    // instead, min_nchan is also scaled
+                    // it helps to search for broad lines
   Vector<Int> signs; // a buffer for signs of the value - mean quantity
                      // see LFAboveThreshold for details
-                     // We need only signs resulted from last iteration
-                     // because all previous values may be corrupted by the
-                     // presence of spectral lines
+                     // We need only signs resulted from last iteration
+                     // because all previous values may be corrupted by the
+                     // presence of spectral lines
   while (true) {
      // a buffer for new lines found at this iteration
@@ -758 +758 @@
          LFAboveThreshold lfalg(new_lines,avg_factor*min_nchan, threshold);
          lfalg.findLines(spectrum,temp_mask,edge,max_box_nchan);
-         signs.resize(lfalg.getSigns().nelements());
-         signs=lfalg.getSigns();
+         signs.resize(lfalg.getSigns().nelements());
+         signs=lfalg.getSigns();
          first_pass=False;
          if (!new_lines.size())
-              throw AipsError("spurious"); // nothing new - use the same
-                                           // code as for a real exception
+              throw AipsError("spurious"); // nothing new - use the same
+                                           // code as for a real exception
      }
      catch(const AipsError &ae) {
          if (first_pass) throw;
          // nothing new - proceed to the next step of averaging, if any
-         // (to search for broad lines)
-         if (avg_factor>avg_limit) break; // averaging up to avg_limit
-                                          // adjacent channels,
-                                          // stop after that
-         avg_factor*=2; // twice as more averaging
-         subtractBaseline(temp_mask,9);
-         averageAdjacentChannels(temp_mask,avg_factor);
-         continue;
+         // (to search for broad lines)
+         if (avg_factor>avg_limit) break; // averaging up to avg_limit
+                                          // adjacent channels,
+                                          // stop after that
+         avg_factor*=2; // twice as more averaging
+         subtractBaseline(temp_mask,9);
+         averageAdjacentChannels(temp_mask,avg_factor);
+         continue;
      }
      keepStrongestOnly(temp_mask,new_lines,max_box_nchan);
@@ -804 +804 @@
   Fitter sdf;
   std::vector<float> absc(spectrum.nelements());
-  for (Int i=0;i<absc.size();++i)
+  for (unsigned int i=0;i<absc.size();++i)
        absc[i]=float(i)/float(spectrum.nelements());
   std::vector<float> spec;
@@ -835 +835 @@
        for (int k=n;k<n+boxsize && k<edge.second;++k)
             if (mask2update[k]) {  // k is a valid channel
-                mean+=spectrum[k];
-                ++nboxch;
+                mean+=spectrum[k];
+                ++nboxch;
             }
        if (nboxch<boxsize) // mask these channels
            for (int k=n;k<n+boxsize && k<edge.second;++k)
-                mask2update[k]=False;
+                mask2update[k]=False;
        else {
           mean/=Float(boxsize);
-           for (int k=n;k<n+boxsize && k<edge.second;++k)
-                spectrum[k]=mean;
+           for (int k=n;k<n+boxsize && k<edge.second;++k)
+                spectrum[k]=mean;
        }
   }
@@ -866 +866 @@
        if (!lines.size())
            throw AipsError("STLineFinder::getMask - one have to search for "
-                           "lines first, use find_lines");
+                           "lines first, use find_lines");
        */
        std::vector<bool> res_mask(mask.nelements());
        // iterator through lines
        std::list<std::pair<int,int> >::const_iterator cli=lines.begin();
-       for (int ch=0;ch<res_mask.size();++ch)
+       for (int ch=0;ch<int(res_mask.size());++ch)
             if (ch<edge.first || ch>=edge.second) res_mask[ch]=false;
-            else if (!mask[ch]) res_mask[ch]=false;
-            else {
-                    res_mask[ch]=!invert; // no line by default
-                    if (cli==lines.end()) continue;
-                    if (ch>=cli->first && ch<cli->second)
-                        res_mask[ch]=invert; // this is a line
+            else if (!mask[ch]) res_mask[ch]=false;
+            else {
+                    res_mask[ch]=!invert; // no line by default
+                    if (cli==lines.end()) continue;
+                    if (ch>=cli->first && ch<cli->second)
+                        res_mask[ch]=invert; // this is a line
                     if (ch>=cli->second)
-                        ++cli; // next line in the list
-                 }
+                        ++cli; // next line in the list
+                 }
 
        return res_mask;
@@ -925 +925 @@
        if (!lines.size())
            throw AipsError("STLineFinder::getLineRangesInChannels - one have to search for "
-                           "lines first, use find_lines");
+                           "lines first, use find_lines");
 
        std::vector<int> res(2*lines.size());
@@ -932 +932 @@
        std::vector<int>::iterator ri=res.begin();
        for (;cli!=lines.end() && ri!=res.end();++cli,++ri) {
-            *ri=cli->first;
-            if (++ri!=res.end())
-                *ri=cli->second-1;
+            *ri=cli->first;
+            if (++ri!=res.end())
+                *ri=cli->second-1;
        }
        return res;
@@ -962 +962 @@
 // max_box_nchan - channels in the running box for baseline filtering
 void STLineFinder::keepStrongestOnly(const casa::Vector<casa::Bool> &temp_mask,
-                  std::list<std::pair<int, int> > &lines2update,
-                  int max_box_nchan)
+                  std::list<std::pair<int, int> > &lines2update,
+                  int max_box_nchan)
                                    throw (casa::AipsError)
 {
@@ -982 +982 @@
 
            if (li==lines2update.end()) break; // no more lines
-           const int ch=running_box.getChannel();
-           if (ch>=li->first && ch<li->second)
-               if (temp_mask[ch] && tmp_flux<fabs(running_box.aboveMean()))
-                   tmp_flux=fabs(running_box.aboveMean());
-           if (ch==li->second-1) {
-               if (peak_flux<tmp_flux) { // if peak_flux=-1, this condition
-                   peak_flux=tmp_flux;   // will be satisfied
-                   strongli=li;
-               }
-               ++li;
-               tmp_flux=-1;
-           }
+           const int ch=running_box.getChannel();
+           if (ch>=li->first && ch<li->second)
+               if (temp_mask[ch] && tmp_flux<fabs(running_box.aboveMean()))
+                   tmp_flux=fabs(running_box.aboveMean());
+           if (ch==li->second-1) {
+               if (peak_flux<tmp_flux) { // if peak_flux=-1, this condition
+                   peak_flux=tmp_flux;   // will be satisfied
+                   strongli=li;
+               }
+               ++li;
+               tmp_flux=-1;
+           }
       }
       std::list<std::pair<int,int> > res;
@@ -1029 +1029 @@
            cli!=newlines.end();++cli) {
 
-           // the first item, which has a non-void intersection or touches
-           // the new line
-           std::list<pair<int,int> >::iterator pos_beg=find_if(lines_list.begin(),
-                          lines_list.end(), IntersectsWith(*cli));
-           // the last such item
-           std::list<pair<int,int> >::iterator pos_end=find_if(pos_beg,
-                          lines_list.end(), not1(IntersectsWith(*cli)));
+           // the first item, which has a non-void intersection or touches
+           // the new line
+           std::list<pair<int,int> >::iterator pos_beg=find_if(lines_list.begin(),
+                          lines_list.end(), IntersectsWith(*cli));
+           // the last such item
+           std::list<pair<int,int> >::iterator pos_end=find_if(pos_beg,
+                          lines_list.end(), not1(IntersectsWith(*cli)));
 
            // extract all lines which intersect or touch a new one into
-           // a temporary buffer. This may invalidate the iterators
-           // line_buffer may be empty, if no lines intersects with a new
-           // one.
-           std::list<pair<int,int> > lines_buffer;
-           lines_buffer.splice(lines_buffer.end(),lines_list, pos_beg, pos_end);
-
-           // build a union of all intersecting lines
-           pair<int,int> union_line=for_each(lines_buffer.begin(),
-                   lines_buffer.end(),BuildUnion(*cli)).result();
-
-           // search for a right place for the new line (union_line) and add
-           std::list<pair<int,int> >::iterator pos2insert=find_if(lines_list.begin(),
-                          lines_list.end(), LaterThan(union_line));
-           lines_list.insert(pos2insert,union_line);
+           // a temporary buffer. This may invalidate the iterators
+           // line_buffer may be empty, if no lines intersects with a new
+           // one.
+           std::list<pair<int,int> > lines_buffer;
+           lines_buffer.splice(lines_buffer.end(),lines_list, pos_beg, pos_end);
+
+           // build a union of all intersecting lines
+           pair<int,int> union_line=for_each(lines_buffer.begin(),
+                   lines_buffer.end(),BuildUnion(*cli)).result();
+
+           // search for a right place for the new line (union_line) and add
+           std::list<pair<int,int> >::iterator pos2insert=find_if(lines_list.begin(),
+                          lines_list.end(), LaterThan(union_line));
+           lines_list.insert(pos2insert,union_line);
       }
   }
@@ -1069 +1069 @@
 void LFLineListOperations::searchForWings(std::list<std::pair<int, int> > &newlines,
            const casa::Vector<casa::Int> &signs,
-           const casa::Vector<casa::Bool> &mask,
-           const std::pair<int,int> &edge) throw(casa::AipsError)
+           const casa::Vector<casa::Bool> &mask,
+           const std::pair<int,int> &edge) throw(casa::AipsError)
 {
   try {
       for (std::list<pair<int,int> >::iterator li=newlines.begin();
            li!=newlines.end();++li) {
-           // update the left hand side
-           for (int n=li->first-1;n>=edge.first;--n) {
-                if (!mask[n]) break;
-                if (signs[n]==signs[li->first] && signs[li->first])
-                    li->first=n;
-                else break;
-           }
-           // update the right hand side
-           for (int n=li->second;n<edge.second;++n) {
-                if (!mask[n]) break;
-                if (signs[n]==signs[li->second-1] && signs[li->second-1])
-                    li->second=n;
-                else break;
-           }
+           // update the left hand side
+           for (int n=li->first-1;n>=edge.first;--n) {
+                if (!mask[n]) break;
+                if (signs[n]==signs[li->first] && signs[li->first])
+                    li->first=n;
+                else break;
+           }
+           // update the right hand side
+           for (int n=li->second;n<edge.second;++n) {
+                if (!mask[n]) break;
+                if (signs[n]==signs[li->second-1] && signs[li->second-1])
+                    li->second=n;
+                else break;
+           }
       }
       // need to search for possible mergers.

trunk/src/STMath.cpp

@@ -128 +128 @@
 
   for (uInt i=0; i < tout.nrow(); ++i) {
-    for ( int j=0; j < in.size(); ++j ) {
+    for ( int j=0; j < int(in.size()); ++j ) {
       const Table& tin = in[j]->table();
       const TableRecord& rec = row.get(i);
@@ -425 +425 @@
 //
 {
-  InterpolateArray1D<Double,Float>::InterpolationMethod interp;
+  //InterpolateArray1D<Double,Float>::InterpolationMethod interp;
   Int interpMethod(stringToIMethod(method));
 
@@ -621 +621 @@
   // Interpolate (and extrapolate) with desired method
 
-   //InterpolateArray1D<Double,Float>::InterpolationMethod method;
-   Int intmethod(stringToIMethod(method));
+  InterpolateArray1D<Double,Float>::InterpolationMethod interp = stringToIMethod(method);
 
    Vector<Float> yout;
    Vector<Bool> maskout;
    InterpolateArray1D<Float,Float>::interpolate(yout, maskout, xout,
-                                                xin, yin, maskin, intmethod,
+                                                xin, yin, maskin, interp,
                                                 True, True);
 
@@ -706 +705 @@
     STAttr sda;
     if (d < 0) d = sda.diameter(inst);
-    Float jyPerk = STAttr::findJyPerK(etaap, d);
+    jyperk = STAttr::findJyPerK(etaap, d);
     ostringstream oss;
     oss << "Jy/K = " << jyperk;
@@ -898 +897 @@
   STMath::invertPhase( const CountedPtr < Scantable >& in )
 {
-  applyToPol(in, &STPol::invertPhase, Float(0.0));
+  return applyToPol(in, &STPol::invertPhase, Float(0.0));
 }
 
@@ -1025 +1024 @@
   MPosition refPos = in->getAntennaPosition();
 
-  InterpolateArray1D<Double,Float>::InterpolationMethod interp;
-  Int interpMethod(stringToIMethod(method));
+  InterpolateArray1D<Double,Float>::InterpolationMethod interp = stringToIMethod(method);
   // test if user frame is different to base frame
   if ( in->frequencies().getFrameString(true)
@@ -1095 +1093 @@
         bool first = true;
         // these rows should be just be POLNO
-        for (int i=0; i<tab.nrow(); ++i) {
+        for (int i=0; i<int(tab.nrow()); ++i) {
           // input values
           Vector<uChar> flag = flagCol(i);

trunk/src/STMathWrapper.h

@@ -43 +43 @@
   {
     std::vector<casa::CountedPtr<Scantable> > sts;
-    for (int i=0; i<in.size(); ++i) sts.push_back(in[i].getCP());
+    for (unsigned int i=0; i<in.size(); ++i) sts.push_back(in[i].getCP());
     return ScantableWrapper(STMath::average(sts, mask, weight, avmode));
   }
@@ -87 +87 @@
                   const std::vector<float>& coeff,
                   const std::string& filename,
-                  const std::string& method)
+                  const std::string& method)
 
   { return
@@ -106 +106 @@
   {
     std::vector<casa::CountedPtr<Scantable> > sts;
-    for (int i=0; i<in.size(); ++i) sts.push_back(in[i].getCP());
+    for (unsigned int i=0; i<in.size(); ++i) sts.push_back(in[i].getCP());
     return ScantableWrapper(STMath::merge(sts)); }
 

trunk/src/STWriter.cpp

@@ -141 +141 @@
   Int status;
   Bool havexpol = Bool(in->npol() > 2);
-  if (status = writer_->create(filename, hdr.observer, hdr.project,
+  status = writer_->create(filename, hdr.observer, hdr.project,
                                hdr.antennaname, hdr.antennaposition,
                                hdr.obstype, hdr.equinox, hdr.freqref,
-                               nChan, nPol, False, havexpol)) {
+                               nChan, nPol, False, havexpol);
+  if ( status ) {
     throw(AipsError("Failed to create output file"));
   }
@@ -214 +215 @@
           Vector<Float>   sigma(npol, 0.0f);
           Vector<Float>   calFctr(npol, 0.0f);
-          if (status = writer_->write(scanno, cycno, rec.asDouble("TIME"),
+          status = writer_->write(scanno, cycno, rec.asDouble("TIME"),
                                       rec.asDouble("INTERVAL"),
                                       rec.asString("FIELDNAME"),
@@ -239 +240 @@
                                       specs, flags,
                                       xCalFctr,//
-                                      xpol)
-                                      ) {
+                                      xpol);
+          if ( status ) {
             writer_->close();
             throw(AipsError("STWriter: Failed to export Scantable."));
@@ -281 +282 @@
                               Vector< Complex > & xpol, const Table & tab )
 {
-  TableRow row(tab);
   String poltype = tab.keywordSet().asString("POLTYPE");
   if ( poltype != "linear") {
@@ -287 +287 @@
     throw(AipsError(msg));
   }
-  // use the first row to fill in all the "metadata"
-  const TableRecord& rec = row.get(0);
   ROArrayColumn<Float> specCol(tab, "SPECTRA");
   ROArrayColumn<uChar> flagCol(tab, "FLAGTRA");

trunk/src/Scantable.cpp

@@ -101 +101 @@
   initFactories();
   Table tab(name, Table::Update);
-  Int version;
+  uInt version;
   tab.keywordSet().get("VERSION", version);
   if (version != version_) {
@@ -322 +322 @@
 
 int Scantable::nscan() const {
-  int n = 0;
-  Int previous = -1; Int current = 0;
   Vector<uInt> scannos(scanCol_.getColumn());
   uInt nout = GenSort<uInt>::sort( scannos, Sort::Ascending,
@@ -384 +382 @@
 {
   bool throwIt = true;
-  Instrument ins = STAttr::convertInstrument(name, throwIt);
+  // create an Instrument to see if this is valid
+  STAttr::convertInstrument(name, throwIt);
   String nameU(name);
   nameU.upcase();
@@ -555 +554 @@
   oss << "Computed azimuth/elevation using " << endl
       << mp << endl;
-  for (uInt i=0; i<nrow(); ++i) {
+  for (Int i=0; i<nrow(); ++i) {
     MEpoch me = timeCol(i);
     MDirection md = getDirection(i);
@@ -795 +794 @@
 std::vector< double > asap::Scantable::getAbcissa( int whichrow ) const
 {
-  if ( whichrow > table_.nrow() ) throw(AipsError("Illegal ro number"));
+  if ( whichrow > int(table_.nrow()) ) throw(AipsError("Illegal ro number"));
   std::vector<double> stlout;
   int nchan = specCol_(whichrow).nelements();
@@ -864 +863 @@
 std::string Scantable::getAbcissaLabel( int whichrow ) const
 {
-  if ( whichrow > table_.nrow() ) throw(AipsError("Illegal ro number"));
+  if ( whichrow > int(table_.nrow()) ) throw(AipsError("Illegal ro number"));
   const MPosition& mp = getAntennaPosition();
   const MDirection& md = getDirection(whichrow);