9 #ifndef COLUMNVECTORDATA_H
10 #define COLUMNVECTORDATA_H 1
50 class ColumnVectorData :
public Column
54 ColumnVectorData(
const ColumnVectorData< T > &right);
55 ColumnVectorData (Table* p = 0);
56 ColumnVectorData (
int columnIndex,
const string &columnName,
ValueType type,
const string &format,
const string &unit, Table* p,
int rpt = 1,
long w = 1,
const string &comment =
"");
59 virtual void readData (
long firstrow,
long nelements,
long firstelem = 1);
60 virtual ColumnVectorData<T>* clone ()
const;
61 virtual void setDimen ();
62 void setDataLimits (T* limits);
63 const T minLegalValue ()
const;
64 void minLegalValue (T value);
65 const T maxLegalValue ()
const;
66 void maxLegalValue (T value);
67 const T minDataValue ()
const;
68 void minDataValue (T value);
69 const T maxDataValue ()
const;
70 void maxDataValue (T value);
71 const std::vector<std::valarray<T> >& data ()
const;
72 void setData (
const std::vector<std::valarray<T> >& value);
73 const std::valarray<T>& data (
int i)
const;
74 void data (
int i,
const std::valarray<T>& value);
82 ColumnVectorData< T > & operator=(
const ColumnVectorData< T > &right);
84 virtual bool compare (
const Column &right)
const;
85 void resizeDataObject (
const std::vector<std::valarray<T> >& indata,
size_t firstRow);
91 virtual void readColumnData (
long first,
long last, T* nullValue = 0);
92 virtual std::ostream& put (std::ostream& s)
const;
93 void writeData (
const std::valarray<T>& indata,
long numRows,
long firstRow = 1, T* nullValue = 0);
94 void writeData (
const std::vector<std::valarray<T> >& indata,
long firstRow = 1, T* nullValue = 0);
100 virtual void readRow (
size_t row, T* nullValue = 0);
102 virtual void readVariableRow (
size_t row, T* nullValue = 0);
103 void readColumnData (
long firstrow,
long nelements,
long firstelem, T* nullValue = 0);
104 void writeData (
const std::valarray<T>& indata,
const std::vector<long>& vectorLengths,
long firstRow = 1, T* nullValue = 0);
105 void writeFixedRow (
const std::valarray<T>& data,
long row,
long firstElem = 1, T* nullValue = 0);
106 void writeFixedArray (T* data,
long nElements,
long nRows,
long firstRow, T* nullValue = 0);
108 virtual void insertRows (
long first,
long number = 1);
109 virtual void deleteRows (
long first,
long number = 1);
110 void doWrite (T* array,
long row,
long rowSize,
long firstElem, T* nullValue);
122 std::vector<std::valarray<T> > m_data;
130 template <
typename T>
131 inline void ColumnVectorData<T>::readData (
long firstrow,
long nelements,
long firstelem)
133 readColumnData(firstrow,nelements,firstelem,static_cast<T*>(0));
136 template <
typename T>
137 inline const T ColumnVectorData<T>::minLegalValue ()
const
139 return m_minLegalValue;
142 template <
typename T>
143 inline void ColumnVectorData<T>::minLegalValue (T value)
145 m_minLegalValue = value;
148 template <
typename T>
149 inline const T ColumnVectorData<T>::maxLegalValue ()
const
151 return m_maxLegalValue;
154 template <
typename T>
155 inline void ColumnVectorData<T>::maxLegalValue (T value)
157 m_maxLegalValue = value;
160 template <
typename T>
161 inline const T ColumnVectorData<T>::minDataValue ()
const
163 return m_minDataValue;
166 template <
typename T>
167 inline void ColumnVectorData<T>::minDataValue (T value)
169 m_minDataValue = value;
172 template <
typename T>
173 inline const T ColumnVectorData<T>::maxDataValue ()
const
175 return m_maxDataValue;
178 template <
typename T>
179 inline void ColumnVectorData<T>::maxDataValue (T value)
181 m_maxDataValue = value;
184 template <
typename T>
185 inline const std::vector<std::valarray<T> >& ColumnVectorData<T>::data ()
const
190 template <
typename T>
191 inline void ColumnVectorData<T>::setData (
const std::vector<std::valarray<T> >& value)
196 template <
typename T>
197 inline const std::valarray<T>& ColumnVectorData<T>::data (
int i)
const
199 return m_data[i - 1];
202 template <
typename T>
203 inline void ColumnVectorData<T>::data (
int i,
const std::valarray<T>& value)
205 if (m_data[i-1].size() != value.size())
206 m_data[i-1].resize(value.size());
207 m_data[i - 1] = value;
212 template <
typename T>
213 ColumnVectorData<T>::ColumnVectorData(
const ColumnVectorData<T> &right)
215 m_minLegalValue(right.m_minLegalValue),
216 m_maxLegalValue(right.m_maxLegalValue),
217 m_minDataValue(right.m_minDataValue),
218 m_maxDataValue(right.m_maxDataValue),
223 template <
typename T>
224 ColumnVectorData<T>::ColumnVectorData (Table* p)
234 template <
typename T>
235 ColumnVectorData<T>::ColumnVectorData (
int columnIndex,
const string &columnName,
ValueType type,
const string &format,
const string &unit, Table* p,
int rpt,
long w,
const string &comment)
236 : Column(columnIndex,columnName,type,format,unit,p,rpt,w,comment),
246 template <
typename T>
247 ColumnVectorData<T>::~ColumnVectorData()
253 template <
typename T>
254 bool ColumnVectorData<T>::compare (
const Column &right)
const
256 if ( !Column::compare(right) )
return false;
257 const ColumnVectorData<T>& that =
static_cast<const ColumnVectorData<T>&
>(right);
258 size_t n = m_data.size();
260 if ( that.m_data.size() != n )
return false;
261 for (
size_t i = 0; i < n ; i++)
263 size_t nn = m_data[i].size();
266 if (that.m_data[i].size() != nn )
return false;
268 std::valarray<bool> test = (m_data[i] == that.m_data[i]);
269 for (
size_t j = 0; j < nn ; j++ )
if ( !test[j] )
return false;
274 template <
typename T>
275 ColumnVectorData<T>* ColumnVectorData<T>::clone ()
const
277 return new ColumnVectorData<T>(*this);
280 template <
typename T>
281 void ColumnVectorData<T>::resizeDataObject (
const std::vector<std::valarray<T> >& indata,
size_t firstRow)
288 const size_t lastInputRow(indata.size() + firstRow - 1);
289 const size_t newLastRow = std::max(lastInputRow,static_cast<size_t>(rows()));
296 const size_t origNRows(m_data.size());
299 if (newLastRow > origNRows) m_data.resize(newLastRow);
306 for (
size_t iRow = firstRow-1; iRow < lastInputRow; ++iRow)
308 std::valarray<T>& current = m_data[iRow];
309 const size_t newSize = indata[iRow - (firstRow-1)].size();
310 if (current.size() != newSize)
311 current.resize(newSize);
322 for (
size_t iRow = firstRow-1; iRow < lastInputRow; ++iRow)
324 if (m_data[iRow].size() != repeat())
325 m_data[iRow].resize(repeat());
330 template <
typename T>
331 void ColumnVectorData<T>::setDimen ()
334 FITSUtil:: auto_array_ptr<char> dimValue (
new char[FLEN_VALUE]);
336 #ifdef SSTREAM_DEFECT
339 std::ostringstream key;
341 key <<
"TDIM" << index();
343 #ifdef SSTREAM_DEFECT
344 fits_read_key_str(fitsPointer(), key.str(), dimValue.get(),0,&status);
346 fits_read_key_str(fitsPointer(),const_cast<char*>(key.str().c_str()),dimValue.get(),0,&status);
351 dimen(String(dimValue.get()));
355 template <
typename T>
356 void ColumnVectorData<T>::readColumnData (
long first,
long last, T* nullValue)
363 std::cerr <<
"CCfits: More data requested than contained in table. ";
364 std::cerr <<
"Extracting complete column.\n";
368 long nelements = (last - first + 1)*repeat();
371 readColumnData(first,nelements,1,nullValue);
372 if (first <= 1 && last == rows()) isRead(
true);
375 template <
typename T>
376 std::ostream& ColumnVectorData<T>::put (std::ostream& s)
const
382 s <<
" Column Legal limits: ( " << m_minLegalValue <<
"," << m_maxLegalValue <<
" )\n"
383 <<
" Column Data limits: ( " << m_minDataValue <<
"," << m_maxDataValue <<
" )\n";
387 for (
size_t j = 0; j < m_data.size(); j++)
389 size_t n = m_data[j].size();
392 s <<
"Row " << j + 1 <<
" Vector Size " << n <<
'\n';
393 for (
size_t k = 0; k < n - 1; k++)
395 s << m_data[j][k] <<
'\t';
397 s << m_data[j][n - 1] <<
'\n';
405 template <
typename T>
406 void ColumnVectorData<T>::writeData (
const std::valarray<T>& indata,
long numRows,
long firstRow, T* nullValue)
415 if (numRows <= 0)
throw InvalidNumberOfRows(numRows);
417 #ifdef SSTREAM_DEFECT
418 std::ostrstream msgStr;
420 std::ostringstream msgStr;
422 if (indata.size() %
static_cast<size_t>(numRows))
424 msgStr <<
"To use this write function, input array size"
425 <<
"\n must be exactly divisible by requested num rows: "
427 throw InsufficientElements(msgStr.str());
429 const size_t cellsize = indata.size()/
static_cast<size_t>(numRows);
431 if (!varLength() && cellsize != repeat() )
433 msgStr <<
"column: " << name()
434 <<
"\n input data size: " << indata.size()
435 <<
" required: " << numRows*repeat();
436 String msg(msgStr.str());
437 throw InsufficientElements(msg);
440 std::vector<std::valarray<T> > internalFormat(numRows);
444 for (
long j = 0; j < numRows; ++j)
446 internalFormat[j].resize(cellsize);
447 internalFormat[j] = indata[std::slice(cellsize*j,cellsize,1)];
453 writeData(internalFormat,firstRow,nullValue);
456 template <
typename T>
457 void ColumnVectorData<T>::writeData (
const std::vector<std::valarray<T> >& indata,
long firstRow, T* nullValue)
462 const size_t nInputRows(indata.size());
465 resizeDataObject(indata,firstRow);
474 const size_t endRow = nInputRows + firstRow-1;
475 for (
size_t iRow = firstRow-1; iRow < endRow; ++iRow)
477 m_data[iRow] = indata[iRow - (firstRow-1)];
479 doWrite(&m_data[iRow][0], iRow+1, m_data[iRow].size(), 1, nullValue);
481 parent()->updateRows();
487 const size_t colRepeat = repeat();
488 bool allEqualRepeat =
true;
489 for (
size_t i=0; i<nInputRows; ++i)
491 const size_t sz = indata[i].size();
494 #ifdef SSTREAM_DEFECT
497 std::ostringstream oss;
499 oss <<
" vector column length " << colRepeat
500 <<
", input valarray length " << sz;
501 throw InvalidRowParameter(oss.str());
504 allEqualRepeat =
false;
510 const size_t nElements (colRepeat*nInputRows);
511 FITSUtil::CVAarray<T> convert;
512 FITSUtil::auto_array_ptr<T> pArray(convert(indata));
513 T* array = pArray.get();
520 writeFixedArray(array,nElements,nInputRows,firstRow,nullValue);
522 for (
size_t j = 0; j < nInputRows ; ++j)
524 const valarray<T>& input = indata[j];
525 valarray<T>& current = m_data[j + firstRow - 1];
533 const size_t endRow = nInputRows + firstRow-1;
534 for (
size_t iRow = firstRow-1; iRow<endRow; ++iRow)
538 const valarray<T>& input = indata[iRow-(firstRow-1)];
539 writeFixedRow(input, iRow, 1, nullValue);
541 parent()->updateRows();
547 template <
typename T>
548 void ColumnVectorData<T>::readRow (
size_t row, T* nullValue)
554 if ( row > static_cast<size_t>(rows()) )
556 #ifdef SSTREAM_DEFECT
559 std::ostringstream msg;
561 msg <<
" row requested: " << row <<
" row range: 1 - " << rows();
562 #ifdef SSTREAM_DEFECT
566 throw Column::InvalidRowNumber(msg.str());
571 bool variable(type() < 0);
574 long nelements(repeat());
578 readVariableRow(row,nullValue);
582 readColumnData(row,nelements,1,nullValue);
586 template <
typename T>
587 void ColumnVectorData<T>::readVariableRow (
size_t row, T* nullValue)
592 if (fits_read_descript(fitsPointer(),index(),static_cast<long>(row),
593 &repeat,&offset,&status))
throw FitsError(status);
594 readColumnData(row,repeat,1,nullValue);
597 template <
typename T>
598 void ColumnVectorData<T>::readColumnData (
long firstrow,
long nelements,
long firstelem, T* nullValue)
602 FITSUtil::auto_array_ptr<T> pArray(
new T[nelements]);
603 T* array = pArray.get();
608 if (fits_read_col(fitsPointer(), abs(type()),index(), firstrow, firstelem,
609 nelements, nullValue, array, &anynul, &status) != 0)
610 throw FitsError(status);
612 size_t countRead = 0;
613 const size_t ONE = 1;
615 if (m_data.size() !=
static_cast<size_t>(rows())) m_data.resize(rows());
616 size_t vectorSize(0);
620 vectorSize = std::max(repeat(),ONE);
629 vectorSize = nelements;
631 size_t n = nelements;
635 while ( countRead < n)
637 std::valarray<T>& current = m_data[ii];
638 if (current.size() != vectorSize) current.resize(vectorSize);
639 int elementsInFirstRow = vectorSize-firstelem + 1;
640 bool lastRow = ( (nelements - countRead) < vectorSize);
643 int elementsInLastRow = nelements - countRead;
644 std::valarray<T> ttmp(array + vectorSize*(ii-firstrow) + elementsInFirstRow,
646 for (
int kk = 0; kk < elementsInLastRow; kk++) current[kk] = ttmp[kk];
647 countRead += elementsInLastRow;
653 if (firstelem == 1 || (firstelem > 1 && i > firstrow) )
655 std::valarray<T> ttmp(array + vectorSize*(ii - firstrow) +
656 elementsInFirstRow,vectorSize);
660 countRead += vectorSize;
666 std::valarray<T> ttmp(array,elementsInFirstRow);
667 for (
size_t kk = firstelem ; kk < vectorSize ; kk++)
668 current[kk] = ttmp[kk-firstelem];
669 countRead += elementsInFirstRow;
678 template <
typename T>
679 void ColumnVectorData<T>::writeData (
const std::valarray<T>& indata,
const std::vector<long>& vectorLengths,
long firstRow, T* nullValue)
684 const size_t N(vectorLengths.size());
685 vector<long> sums(N);
687 partial_sum(vectorLengths.begin(),vectorLengths.end(),sums.begin());
689 if (indata.size() <
static_cast<size_t>(sums[N-1]) )
691 #ifdef SSTREAM_DEFECT
694 ostringstream msgStr;
696 msgStr <<
" input data size: " << indata.size() <<
" vector length sum: " << sums[N-1];
697 #ifdef SSTREAM_DEFECT
701 String msg(msgStr.str());
702 throw InsufficientElements(msg);
705 vector<valarray<T> > vvArray(N);
706 long& last = sums[0];
707 vvArray[0].resize(last);
708 for (
long jj = 0; jj < last; ++jj) vvArray[0][jj] = indata[jj];
710 for (
size_t j = 1; j < N; ++j)
712 valarray<T>& __tmp = vvArray[j];
714 long& first = sums[j-1];
715 long& jlast = sums[j];
716 __tmp.resize(jlast - first);
717 for (
long k = first; k < jlast; ++k)
719 __tmp[k - first] = indata[k];
723 writeData(vvArray,firstRow,nullValue);
726 template <
typename T>
727 void ColumnVectorData<T>::writeFixedRow (
const std::valarray<T>& data,
long row,
long firstElem, T* nullValue)
735 #ifdef SSTREAM_DEFECT
736 std::ostrstream msgStr;
738 std::ostringstream msgStr;
742 msgStr <<
"Calling ColumnVectorData::writeFixedRow for a variable length column.\n";
743 throw FitsFatal(msgStr.str());
746 std::valarray<T>& storedRow = m_data[row];
747 long inputSize =
static_cast<long>(data.size());
748 long storedSize(storedRow.size());
749 if (storedSize != static_cast<long>(repeat()))
751 msgStr<<
"stored array size vs. column width mismatch in ColumnVectorData::writeFixedRow.\n";
752 throw FitsFatal(msgStr.str());
755 if (inputSize + firstElem - 1 > storedSize)
757 msgStr <<
" requested write " << firstElem <<
" to "
758 << firstElem + inputSize - 1 <<
" exceeds vector length " << repeat();
759 throw InvalidRowParameter(msgStr.str());
774 std::valarray<T>& lvData =
const_cast<std::valarray<T>&
>(data);
775 T* inPointer = &lvData[0];
776 doWrite(inPointer, row+1, inputSize, firstElem, nullValue);
779 const size_t offset =
static_cast<size_t>(firstElem) - 1;
780 for (
size_t iElem=0; iElem < static_cast<size_t>(inputSize); ++iElem)
784 storedRow[iElem + offset] = inPointer[iElem];
788 template <
typename T>
789 void ColumnVectorData<T>::writeFixedArray (T* data,
long nElements,
long nRows,
long firstRow, T* nullValue)
798 if ( nElements < nRows*static_cast<long>(repeat()) )
800 #ifdef SSTREAM_DEFECT
801 std::ostrstream msgStr;
803 std::ostringstream msgStr;
805 msgStr <<
" input array size: " << nElements <<
" required " << nRows*repeat();
806 String msg(msgStr.str());
808 throw Column::InsufficientElements(msg);
813 if (fits_write_colnull(fitsPointer(),abs(type()),index(),firstRow,
814 1,nElements,data,nullValue,&status))
throw FitsError(status);
818 if (fits_write_col(fitsPointer(),abs(type()),index(),firstRow,
819 1,nElements,data,&status))
throw FitsError(status);
822 parent()->updateRows();
825 template <
typename T>
826 void ColumnVectorData<T>::insertRows (
long first,
long number)
828 typename std::vector<std::valarray<T> >::iterator in;
831 in = m_data.begin()+first;
839 m_data.insert(in,number,std::valarray<T>(T(),0));
842 template <
typename T>
843 void ColumnVectorData<T>::deleteRows (
long first,
long number)
848 long N =
static_cast<long>(m_data.size());
849 size_t newSize =
static_cast<size_t>(N - number);
850 std::vector<std::valarray<T> > __tmp(newSize);
852 long lastDeleted( number + first - 1 );
853 long firstDeleted(first);
856 for (
long j = 1; j <= N; ++j)
858 if ( (j - firstDeleted)*(lastDeleted - j) >= 0 )
863 __tmp[j - 1 - count].resize(m_data[j - 1].size());
864 __tmp[j - 1 - count] = m_data[j - 1];
870 m_data.resize(newSize);
872 for (
size_t j = 0; j < newSize; ++j)
874 m_data[j].resize(__tmp[j].size());
875 m_data[j] = __tmp[j];
880 template <
typename T>
881 void ColumnVectorData<T>::setDataLimits (T* limits)
883 m_minLegalValue = limits[0];
884 m_maxLegalValue = limits[1];
885 m_minDataValue = std::max(limits[2],limits[0]);
886 m_maxDataValue = std::min(limits[3],limits[1]);
889 template <
typename T>
890 void ColumnVectorData<T>::doWrite (T* array,
long row,
long rowSize,
long firstElem, T* nullValue)
898 if (fits_write_colnull(fitsPointer(),type(),index(),row, firstElem, rowSize,
899 array, nullValue,&status))
throw FitsError(status);
903 if (fits_write_col(fitsPointer(),abs(type()),index(),row,firstElem,rowSize,
904 array,&status))
throw FitsError(status);
920 #if SPEC_TEMPLATE_IMP_DEFECT || SPEC_TEMPLATE_DECL_DEFECT
922 inline void ColumnVectorData<complex<float> >::setDataLimits (complex<float>* limits)
924 m_minLegalValue = limits[0];
925 m_maxLegalValue = limits[1];
926 m_minDataValue = limits[2];
927 m_maxDataValue = limits[3];
932 ColumnVectorData<complex<float> >::setDataLimits (complex<float>* limits);
935 #if SPEC_TEMPLATE_IMP_DEFECT || SPEC_TEMPLATE_DECL_DEFECT
937 inline void ColumnVectorData<complex<double> >::setDataLimits (complex<double>* limits)
939 m_minLegalValue = limits[0];
940 m_maxLegalValue = limits[1];
941 m_minDataValue = limits[2];
942 m_maxDataValue = limits[3];
947 ColumnVectorData<complex<double> >::setDataLimits (complex<double>* limits);
951 #if SPEC_TEMPLATE_IMP_DEFECT || SPEC_TEMPLATE_DECL_DEFECT
953 inline void ColumnVectorData<std::complex<float> >::readColumnData(
long firstRow,
954 long nelements,
long firstElem, std::complex<float>* null )
958 FITSUtil::auto_array_ptr<float> pArray(
new float[2*nelements]);
959 float* array = pArray.get();
962 if (fits_read_col_cmp(fitsPointer(),index(),firstRow, firstElem,
963 nelements,nulval,array,&anynul,&status) )
throw FitsError(status);
965 if (m_data.size() !=
static_cast<size_t>(rows())) m_data.resize(rows());
967 std::valarray<std::complex<float> > readData(nelements);
968 for (
long j = 0; j < nelements; ++j)
970 readData[j] = std::complex<float>(array[2*j],array[2*j+1]);
972 size_t countRead = 0;
973 const size_t ONE = 1;
975 if (m_data.size() !=
static_cast<size_t>(rows())) m_data.resize(rows());
976 size_t vectorSize(0);
979 vectorSize = std::max(repeat(),ONE);
987 vectorSize = nelements;
989 size_t n = nelements;
993 while ( countRead < n)
995 std::valarray<complex<float> >& current = m_data[ii];
996 if (current.size() != vectorSize) current.resize(vectorSize,0.);
997 int elementsInFirstRow = vectorSize-firstElem + 1;
998 bool lastRow = ( (nelements - countRead) < vectorSize);
1001 int elementsInLastRow = nelements - countRead;
1002 std::copy(&readData[countRead],&readData[0]+nelements,¤t[0]);
1003 countRead += elementsInLastRow;
1008 if (firstElem == 1 || (firstElem > 1 && i > firstRow) )
1010 current = readData[std::slice(vectorSize*(ii-firstRow)+
1011 elementsInFirstRow,vectorSize,1)];
1014 countRead += vectorSize;
1020 std::copy(&readData[0],&readData[0]+elementsInFirstRow,
1021 ¤t[firstElem]);
1022 countRead += elementsInFirstRow;
1032 void ColumnVectorData<complex<float> >::readColumnData(
long firstRow,
1034 long firstElem, complex<float>* null);
1037 #if SPEC_TEMPLATE_IMP_DEFECT || SPEC_TEMPLATE_DECL_DEFECT
1039 inline void ColumnVectorData<complex<double> >::readColumnData (
long firstRow,
1040 long nelements,
long firstElem,
1041 complex<double>* nullValue)
1048 FITSUtil::auto_array_ptr<double> pArray(
new double[2*nelements]);
1049 double* array = pArray.get();
1052 if (fits_read_col_dblcmp(fitsPointer(),index(),firstRow, firstElem,
1053 nelements,nulval,array,&anynul,&status) )
throw FitsError(status);
1055 if (m_data.size() !=
static_cast<size_t>(rows())) m_data.resize(rows());
1057 std::valarray<std::complex<double> > readData(nelements);
1058 for (
long j = 0; j < nelements; ++j)
1060 readData[j] = std::complex<double>(array[2*j],array[2*j+1]);
1062 size_t countRead = 0;
1063 const size_t ONE = 1;
1065 if (m_data.size() !=
static_cast<size_t>(rows())) m_data.resize(rows());
1066 size_t vectorSize(0);
1069 vectorSize = std::max(repeat(),ONE);
1077 vectorSize = nelements;
1079 size_t n = nelements;
1083 while ( countRead < n)
1085 std::valarray<std::complex<double> >& current = m_data[ii];
1086 if (current.size() != vectorSize) current.resize(vectorSize,0.);
1087 int elementsInFirstRow = vectorSize-firstElem + 1;
1088 bool lastRow = ( (nelements - countRead) < vectorSize);
1091 int elementsInLastRow = nelements - countRead;
1092 std::copy(&readData[countRead],&readData[0]+nelements,¤t[0]);
1093 countRead += elementsInLastRow;
1098 if (firstElem == 1 || (firstElem > 1 && i > firstRow) )
1100 current = readData[std::slice(vectorSize*(ii-firstRow)+
1101 elementsInFirstRow,vectorSize,1)];
1104 countRead += vectorSize;
1110 std::copy(&readData[0],&readData[0]+elementsInFirstRow,
1111 ¤t[firstElem]);
1112 countRead += elementsInFirstRow;
1122 void ColumnVectorData<complex<double> >::readColumnData (
long firstRow,
1124 long firstElem, complex<double>* null);
1127 #if SPEC_TEMPLATE_IMP_DEFECT || SPEC_TEMPLATE_DECL_DEFECT
1129 inline void ColumnVectorData<complex<float> >::writeFixedArray
1130 (complex<float>* data,
long nElements,
long nRows,
long firstRow,
1131 complex<float>* nullValue)
1141 if ( nElements < nRows*static_cast<long>(repeat()) )
1143 #ifdef SSTREAM_DEFECT
1144 std::ostrstream msgStr;
1146 std::ostringstream msgStr;
1148 msgStr <<
" input array size: " << nElements
1149 <<
" required " << nRows*repeat();
1150 #ifdef SSTREAM_DEFECT
1151 msgStr << std::ends;
1155 String msg(msgStr.str());
1157 throw Column::InsufficientElements(msg);
1160 FITSUtil::auto_array_ptr<float> realData(
new float[2*nElements]);
1162 for (
int j = 0; j < nElements; ++j)
1164 realData[2*j] = data[j].real();
1165 realData[2*j+1] = data[j].imag();
1170 if (fits_write_col_cmp(fitsPointer(),index(),firstRow,
1171 1,nElements,realData.get(),&status))
throw FitsError(status);
1173 parent()->updateRows();
1177 void ColumnVectorData<complex<float> >::writeFixedArray
1178 (complex<float>* data,
long nElements,
long nRows,
long firstRow, std::complex<float>* null);
1181 #if SPEC_TEMPLATE_IMP_DEFECT || SPEC_TEMPLATE_DECL_DEFECT
1183 inline void ColumnVectorData<complex<double> >::writeFixedArray
1184 (complex<double>* data,
long nElements,
long nRows,
long firstRow,
1185 complex<double>* nullValue)
1194 if ( nElements < nRows*static_cast<long>(repeat()) )
1196 #ifdef SSTREAM_DEFECT
1197 std::ostrstream msgStr;
1199 std::ostringstream msgStr;
1201 msgStr <<
" input array size: " << nElements
1202 <<
" required " << nRows*repeat();
1203 #ifdef SSTREAM_DEFECT
1204 msgStr << std::ends;
1207 String msg(msgStr.str());
1209 throw Column::InsufficientElements(msg);
1212 FITSUtil::auto_array_ptr<double> realData(
new double[2*nElements]);
1214 for (
int j = 0; j < nElements; ++j)
1216 realData[2*j] = data[j].real();
1217 realData[2*j+1] = data[j].imag();
1222 if (fits_write_col_dblcmp(fitsPointer(),index(),firstRow,
1223 1,nElements,realData.get(),&status))
throw FitsError(status);
1225 parent()->updateRows();
1230 void ColumnVectorData<complex<double> >::writeFixedArray
1231 (complex<double>* data,
long nElements,
long nRows,
long firstRow,
1232 std::complex<double>* null);
1235 #ifdef SPEC_TEMPLATE_DECL_DEFECT
1238 ColumnVectorData<std::complex<float> >::doWrite
1239 (std::complex<float>* data,
long row,
long rowSize,
long firstElem, std::complex<float>* nullValue )
1242 FITSUtil::auto_array_ptr<float> carray(
new float[2*rowSize]);
1243 for (
long j = 0 ; j < rowSize; ++ j)
1245 carray[2*j] = data[j].real();
1246 carray[2*j + 1] = data[j].imag();
1248 if (fits_write_col_cmp(fitsPointer(),index(),row,firstElem,rowSize,
1249 carray.get(),&status))
throw FitsError(status);
1255 ColumnVectorData<std::complex<double> >::doWrite
1256 (std::complex<double>* data,
long row,
long rowSize,
long firstElem, std::complex<double>* nullValue )
1259 FITSUtil::auto_array_ptr<double> carray(
new double[2*rowSize]);
1260 for (
long j = 0 ; j < rowSize; ++ j)
1262 carray[2*j] = data[j].real();
1263 carray[2*j + 1] = data[j].imag();
1265 if (fits_write_col_dblcmp(fitsPointer(),index(),row,firstElem,rowSize,
1266 carray.get(),&status))
throw FitsError(status);
1273 ColumnVectorData<complex<float> >::doWrite
1274 ( complex<float>* data,
long row,
long rowSize,
long firstElem, complex<float>* nullValue);
1278 ColumnVectorData<complex<double> >::doWrite
1279 ( complex<double>* data,
long row,
long rowSize,
long firstElem, complex<double>* nullValue );
Definition: MSconfig.h:123
virtual std::ostream & put(std::ostream &s) const
internal implementation of << operator.
Definition: Column.cxx:302
static bool verboseMode()
return verbose setting for library
Definition: FITS.h:891
Namespace enclosing all CCfits classes and globals definitions.
Definition: AsciiTable.cxx:26
ValueType
CCfits value types and their CFITSIO equivalents (in caps)
Definition: CCfits.h:79
Column(const Column &right)
copy constructor, used in copying Columns to standard library containers.
Definition: Column.cxx:171