9 #ifndef COLUMNVECTORDATA_H 10 #define COLUMNVECTORDATA_H 1 49 class ColumnVectorData :
public Column
53 ColumnVectorData(
const ColumnVectorData< T > &right);
54 ColumnVectorData (Table* p = 0);
55 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 =
"");
58 virtual void readData (
long firstrow,
long nelements,
long firstelem = 1);
59 virtual ColumnVectorData<T>* clone ()
const;
60 virtual void setDimen ();
61 void setDataLimits (T* limits);
62 const T minLegalValue ()
const;
63 void minLegalValue (T value);
64 const T maxLegalValue ()
const;
65 void maxLegalValue (T value);
66 const T minDataValue ()
const;
67 void minDataValue (T value);
68 const T maxDataValue ()
const;
69 void maxDataValue (T value);
70 const std::vector<std::valarray<T> >& data ()
const;
71 void setData (
const std::vector<std::valarray<T> >& value);
72 const std::valarray<T>& data (
int i)
const;
73 void data (
int i,
const std::valarray<T>& value);
81 ColumnVectorData< T > & operator=(
const ColumnVectorData< T > &right);
83 virtual bool compare (
const Column &right)
const;
84 void resizeDataObject (
const std::vector<std::valarray<T> >& indata,
size_t firstRow);
90 virtual void readColumnData (
long first,
long last, T* nullValue = 0);
91 virtual std::ostream& put (std::ostream& s)
const;
92 void writeData (
const std::valarray<T>& indata,
long numRows,
long firstRow = 1, T* nullValue = 0);
93 void writeData (
const std::vector<std::valarray<T> >& indata,
long firstRow = 1, T* nullValue = 0);
99 virtual void readRow (
size_t row, T* nullValue = 0);
101 virtual void readVariableRow (
size_t row, T* nullValue = 0);
102 void readColumnData (
long firstrow,
long nelements,
long firstelem, T* nullValue = 0);
103 void writeData (
const std::valarray<T>& indata,
const std::vector<long>& vectorLengths,
long firstRow = 1, T* nullValue = 0);
104 void writeFixedRow (
const std::valarray<T>& data,
long row,
long firstElem = 1, T* nullValue = 0);
105 void writeFixedArray (T* data,
long nElements,
long nRows,
long firstRow, T* nullValue = 0);
107 virtual void insertRows (
long first,
long number = 1);
108 virtual void deleteRows (
long first,
long number = 1);
109 void doWrite (T* array,
long row,
long rowSize,
long firstElem, T* nullValue);
121 std::vector<std::valarray<T> > m_data;
129 template <
typename T>
130 inline void ColumnVectorData<T>::readData (
long firstrow,
long nelements,
long firstelem)
132 readColumnData(firstrow,nelements,firstelem,static_cast<T*>(0));
135 template <
typename T>
136 inline const T ColumnVectorData<T>::minLegalValue ()
const 138 return m_minLegalValue;
141 template <
typename T>
142 inline void ColumnVectorData<T>::minLegalValue (T value)
144 m_minLegalValue = value;
147 template <
typename T>
148 inline const T ColumnVectorData<T>::maxLegalValue ()
const 150 return m_maxLegalValue;
153 template <
typename T>
154 inline void ColumnVectorData<T>::maxLegalValue (T value)
156 m_maxLegalValue = value;
159 template <
typename T>
160 inline const T ColumnVectorData<T>::minDataValue ()
const 162 return m_minDataValue;
165 template <
typename T>
166 inline void ColumnVectorData<T>::minDataValue (T value)
168 m_minDataValue = value;
171 template <
typename T>
172 inline const T ColumnVectorData<T>::maxDataValue ()
const 174 return m_maxDataValue;
177 template <
typename T>
178 inline void ColumnVectorData<T>::maxDataValue (T value)
180 m_maxDataValue = value;
183 template <
typename T>
184 inline const std::vector<std::valarray<T> >& ColumnVectorData<T>::data ()
const 189 template <
typename T>
190 inline void ColumnVectorData<T>::setData (
const std::vector<std::valarray<T> >& value)
195 template <
typename T>
196 inline const std::valarray<T>& ColumnVectorData<T>::data (
int i)
const 198 return m_data[i - 1];
201 template <
typename T>
202 inline void ColumnVectorData<T>::data (
int i,
const std::valarray<T>& value)
204 if (m_data[i-1].size() != value.size())
205 m_data[i-1].resize(value.size());
206 m_data[i - 1] = value;
211 template <
typename T>
212 ColumnVectorData<T>::ColumnVectorData(
const ColumnVectorData<T> &right)
214 m_minLegalValue(right.m_minLegalValue),
215 m_maxLegalValue(right.m_maxLegalValue),
216 m_minDataValue(right.m_minDataValue),
217 m_maxDataValue(right.m_maxDataValue),
222 template <
typename T>
223 ColumnVectorData<T>::ColumnVectorData (Table* p)
233 template <
typename T>
234 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)
235 :
Column(columnIndex,columnName,type,format,unit,p,rpt,w,comment),
245 template <
typename T>
246 ColumnVectorData<T>::~ColumnVectorData()
252 template <
typename T>
253 bool ColumnVectorData<T>::compare (
const Column &right)
const 255 if ( !Column::compare(right) )
return false;
256 const ColumnVectorData<T>& that =
static_cast<const ColumnVectorData<T>&
>(right);
257 size_t n = m_data.size();
259 if ( that.m_data.size() != n )
return false;
260 for (
size_t i = 0; i < n ; i++)
262 const std::valarray<T>& thisValArray=m_data[i];
263 const std::valarray<T>& thatValArray=that.m_data[i];
264 size_t nn = thisValArray.size();
265 if (thatValArray.size() != nn )
return false;
267 for (
size_t j = 0; j < nn ; j++ )
269 if (thisValArray[j] != thatValArray[j])
276 template <
typename T>
277 ColumnVectorData<T>* ColumnVectorData<T>::clone ()
const 279 return new ColumnVectorData<T>(*this);
282 template <
typename T>
283 void ColumnVectorData<T>::resizeDataObject (
const std::vector<std::valarray<T> >& indata,
size_t firstRow)
290 const size_t lastInputRow(indata.size() + firstRow - 1);
291 const size_t newLastRow = std::max(lastInputRow,static_cast<size_t>(
rows()));
298 const size_t origNRows(m_data.size());
301 if (newLastRow > origNRows) m_data.resize(newLastRow);
308 for (
size_t iRow = firstRow-1; iRow < lastInputRow; ++iRow)
310 std::valarray<T>& current = m_data[iRow];
311 const size_t newSize = indata[iRow - (firstRow-1)].size();
312 if (current.size() != newSize)
313 current.resize(newSize);
324 for (
size_t iRow = firstRow-1; iRow < lastInputRow; ++iRow)
326 if (m_data[iRow].size() !=
repeat())
327 m_data[iRow].resize(
repeat());
332 template <
typename T>
333 void ColumnVectorData<T>::setDimen ()
336 FITSUtil:: auto_array_ptr<char> dimValue (
new char[FLEN_VALUE]);
338 #ifdef SSTREAM_DEFECT 341 std::ostringstream key;
343 key <<
"TDIM" <<
index();
345 #ifdef SSTREAM_DEFECT 346 fits_read_key_str(
fitsPointer(), key.str(), dimValue.get(),0,&status);
348 fits_read_key_str(
fitsPointer(),const_cast<char*>(key.str().c_str()),dimValue.get(),0,&status);
353 dimen(String(dimValue.get()));
357 template <
typename T>
358 void ColumnVectorData<T>::readColumnData (
long first,
long last, T* nullValue)
365 std::cerr <<
"CCfits: More data requested than contained in table. ";
366 std::cerr <<
"Extracting complete column.\n";
370 long nelements = (last - first + 1)*
repeat();
373 readColumnData(first,nelements,1,nullValue);
374 if (first <= 1 && last ==
rows())
isRead(
true);
377 template <
typename T>
378 std::ostream& ColumnVectorData<T>::put (std::ostream& s)
const 384 s <<
" Column Legal limits: ( " << m_minLegalValue <<
"," << m_maxLegalValue <<
" )\n" 385 <<
" Column Data limits: ( " << m_minDataValue <<
"," << m_maxDataValue <<
" )\n";
389 for (
size_t j = 0; j < m_data.size(); j++)
391 size_t n = m_data[j].size();
394 s <<
"Row " << j + 1 <<
" Vector Size " << n <<
'\n';
395 for (
size_t k = 0; k < n - 1; k++)
397 s << m_data[j][k] <<
'\t';
399 s << m_data[j][n - 1] <<
'\n';
407 template <
typename T>
408 void ColumnVectorData<T>::writeData (
const std::valarray<T>& indata,
long numRows,
long firstRow, T* nullValue)
417 if (numRows <= 0)
throw InvalidNumberOfRows(numRows);
419 #ifdef SSTREAM_DEFECT 420 std::ostrstream msgStr;
422 std::ostringstream msgStr;
424 if (indata.size() %
static_cast<size_t>(numRows))
426 msgStr <<
"To use this write function, input array size" 427 <<
"\n must be exactly divisible by requested num rows: " 429 throw InsufficientElements(msgStr.str());
431 const size_t cellsize = indata.size()/
static_cast<size_t>(numRows);
435 msgStr <<
"column: " <<
name()
436 <<
"\n input data size: " << indata.size()
437 <<
" required: " << numRows*
repeat();
438 String msg(msgStr.str());
439 throw InsufficientElements(msg);
442 std::vector<std::valarray<T> > internalFormat(numRows);
446 for (
long j = 0; j < numRows; ++j)
448 internalFormat[j].resize(cellsize);
449 internalFormat[j] = indata[std::slice(cellsize*j,cellsize,1)];
455 writeData(internalFormat,firstRow,nullValue);
458 template <
typename T>
459 void ColumnVectorData<T>::writeData (
const std::vector<std::valarray<T> >& indata,
long firstRow, T* nullValue)
464 const size_t nInputRows(indata.size());
467 resizeDataObject(indata,firstRow);
476 const size_t endRow = nInputRows + firstRow-1;
477 for (
size_t iRow = firstRow-1; iRow < endRow; ++iRow)
479 m_data[iRow] = indata[iRow - (firstRow-1)];
481 doWrite(&m_data[iRow][0], iRow+1, m_data[iRow].size(), 1, nullValue);
489 const size_t colRepeat =
repeat();
490 bool allEqualRepeat =
true;
491 for (
size_t i=0; i<nInputRows; ++i)
493 const size_t sz = indata[i].size();
496 #ifdef SSTREAM_DEFECT 499 std::ostringstream oss;
501 oss <<
" vector column length " << colRepeat
502 <<
", input valarray length " << sz;
503 throw InvalidRowParameter(oss.str());
506 allEqualRepeat =
false;
512 const size_t nElements (colRepeat*nInputRows);
513 FITSUtil::CVAarray<T> convert;
514 FITSUtil::auto_array_ptr<T> pArray(convert(indata));
515 T* array = pArray.get();
522 writeFixedArray(array,nElements,nInputRows,firstRow,nullValue);
524 for (
size_t j = 0; j < nInputRows ; ++j)
526 const valarray<T>& input = indata[j];
527 valarray<T>& current = m_data[j + firstRow - 1];
535 const size_t endRow = nInputRows + firstRow-1;
536 for (
size_t iRow = firstRow-1; iRow<endRow; ++iRow)
540 const valarray<T>& input = indata[iRow-(firstRow-1)];
541 writeFixedRow(input, iRow, 1, nullValue);
549 template <
typename T>
550 void ColumnVectorData<T>::readRow (
size_t row, T* nullValue)
556 if ( row > static_cast<size_t>(
rows()) )
558 #ifdef SSTREAM_DEFECT 561 std::ostringstream msg;
563 msg <<
" row requested: " << row <<
" row range: 1 - " <<
rows();
564 #ifdef SSTREAM_DEFECT 568 throw Column::InvalidRowNumber(msg.str());
573 bool variable(
type() < 0);
580 readVariableRow(row,nullValue);
584 readColumnData(row,nelements,1,nullValue);
588 template <
typename T>
589 void ColumnVectorData<T>::readVariableRow (
size_t row, T* nullValue)
595 &
repeat,&offset,&status))
throw FitsError(status);
596 readColumnData(row,
repeat,1,nullValue);
599 template <
typename T>
600 void ColumnVectorData<T>::readColumnData (
long firstrow,
long nelements,
long firstelem, T* nullValue)
604 FITSUtil::auto_array_ptr<T> pArray(
new T[nelements]);
605 T* array = pArray.get();
611 nelements, nullValue, array, &anynul, &status) != 0)
612 throw FitsError(status);
614 size_t countRead = 0;
615 const size_t ONE = 1;
617 if (m_data.size() !=
static_cast<size_t>(
rows())) m_data.resize(
rows());
618 size_t vectorSize(0);
622 vectorSize = std::max(
repeat(),ONE);
631 vectorSize = nelements;
633 size_t n = nelements;
637 while ( countRead < n)
639 std::valarray<T>& current = m_data[ii];
640 if (current.size() != vectorSize) current.resize(vectorSize);
641 int elementsInFirstRow = vectorSize-firstelem + 1;
642 bool lastRow = ( (nelements - countRead) < vectorSize);
645 int elementsInLastRow = nelements - countRead;
646 std::valarray<T> ttmp(array + vectorSize*(ii-firstrow) + elementsInFirstRow,
648 for (
int kk = 0; kk < elementsInLastRow; kk++) current[kk] = ttmp[kk];
649 countRead += elementsInLastRow;
655 if (firstelem == 1 || (firstelem > 1 && i > firstrow) )
657 std::valarray<T> ttmp(array + vectorSize*(ii - firstrow) +
658 elementsInFirstRow,vectorSize);
662 countRead += vectorSize;
668 std::valarray<T> ttmp(array,elementsInFirstRow);
669 for (
size_t kk = firstelem ; kk < vectorSize ; kk++)
670 current[kk] = ttmp[kk-firstelem];
671 countRead += elementsInFirstRow;
680 template <
typename T>
681 void ColumnVectorData<T>::writeData (
const std::valarray<T>& indata,
const std::vector<long>& vectorLengths,
long firstRow, T* nullValue)
686 const size_t N(vectorLengths.size());
687 vector<long> sums(N);
689 partial_sum(vectorLengths.begin(),vectorLengths.end(),sums.begin());
691 if (indata.size() <
static_cast<size_t>(sums[N-1]) )
693 #ifdef SSTREAM_DEFECT 696 ostringstream msgStr;
698 msgStr <<
" input data size: " << indata.size() <<
" vector length sum: " << sums[N-1];
699 #ifdef SSTREAM_DEFECT 703 String msg(msgStr.str());
704 throw InsufficientElements(msg);
707 vector<valarray<T> > vvArray(N);
708 long& last = sums[0];
709 vvArray[0].resize(last);
710 for (
long jj = 0; jj < last; ++jj) vvArray[0][jj] = indata[jj];
712 for (
size_t j = 1; j < N; ++j)
714 valarray<T>& __tmp = vvArray[j];
716 long& first = sums[j-1];
717 long& jlast = sums[j];
718 __tmp.resize(jlast - first);
719 for (
long k = first; k < jlast; ++k)
721 __tmp[k - first] = indata[k];
725 writeData(vvArray,firstRow,nullValue);
728 template <
typename T>
729 void ColumnVectorData<T>::writeFixedRow (
const std::valarray<T>& data,
long row,
long firstElem, T* nullValue)
737 #ifdef SSTREAM_DEFECT 738 std::ostrstream msgStr;
740 std::ostringstream msgStr;
744 msgStr <<
"Calling ColumnVectorData::writeFixedRow for a variable length column.\n";
745 throw FitsFatal(msgStr.str());
748 std::valarray<T>& storedRow = m_data[row];
749 long inputSize =
static_cast<long>(data.size());
750 long storedSize(storedRow.size());
751 if (storedSize != static_cast<long>(
repeat()))
753 msgStr<<
"stored array size vs. column width mismatch in ColumnVectorData::writeFixedRow.\n";
754 throw FitsFatal(msgStr.str());
757 if (inputSize + firstElem - 1 > storedSize)
759 msgStr <<
" requested write " << firstElem <<
" to " 760 << firstElem + inputSize - 1 <<
" exceeds vector length " <<
repeat();
761 throw InvalidRowParameter(msgStr.str());
776 std::valarray<T>& lvData =
const_cast<std::valarray<T>&
>(data);
777 T* inPointer = &lvData[0];
778 doWrite(inPointer, row+1, inputSize, firstElem, nullValue);
781 const size_t offset =
static_cast<size_t>(firstElem) - 1;
782 for (
size_t iElem=0; iElem < static_cast<size_t>(inputSize); ++iElem)
786 storedRow[iElem + offset] = inPointer[iElem];
790 template <
typename T>
791 void ColumnVectorData<T>::writeFixedArray (T* data,
long nElements,
long nRows,
long firstRow, T* nullValue)
800 if ( nElements < nRows*static_cast<long>(
repeat()) )
802 #ifdef SSTREAM_DEFECT 803 std::ostrstream msgStr;
805 std::ostringstream msgStr;
807 msgStr <<
" input array size: " << nElements <<
" required " << nRows*
repeat();
808 String msg(msgStr.str());
810 throw Column::InsufficientElements(msg);
816 1,nElements,data,nullValue,&status))
throw FitsError(status);
821 1,nElements,data,&status))
throw FitsError(status);
827 template <
typename T>
828 void ColumnVectorData<T>::insertRows (
long first,
long number)
830 typename std::vector<std::valarray<T> >::iterator in;
833 in = m_data.begin()+first;
841 m_data.insert(in,number,std::valarray<T>(T(),0));
844 template <
typename T>
845 void ColumnVectorData<T>::deleteRows (
long first,
long number)
850 long N =
static_cast<long>(m_data.size());
851 size_t newSize =
static_cast<size_t>(N - number);
852 std::vector<std::valarray<T> > __tmp(newSize);
854 long lastDeleted( number + first - 1 );
855 long firstDeleted(first);
858 for (
long j = 1; j <= N; ++j)
860 if ( (j - firstDeleted)*(lastDeleted - j) >= 0 )
865 __tmp[j - 1 - count].resize(m_data[j - 1].size());
866 __tmp[j - 1 - count] = m_data[j - 1];
872 m_data.resize(newSize);
874 for (
size_t j = 0; j < newSize; ++j)
876 m_data[j].resize(__tmp[j].size());
877 m_data[j] = __tmp[j];
882 template <
typename T>
883 void ColumnVectorData<T>::setDataLimits (T* limits)
885 m_minLegalValue = limits[0];
886 m_maxLegalValue = limits[1];
887 m_minDataValue = std::max(limits[2],limits[0]);
888 m_maxDataValue = std::min(limits[3],limits[1]);
891 template <
typename T>
892 void ColumnVectorData<T>::doWrite (T* array,
long row,
long rowSize,
long firstElem, T* nullValue)
901 array, nullValue,&status))
throw FitsError(status);
906 array,&status))
throw FitsError(status);
922 #if SPEC_TEMPLATE_IMP_DEFECT || SPEC_TEMPLATE_DECL_DEFECT 924 inline void ColumnVectorData<complex<float> >::setDataLimits (complex<float>* limits)
926 m_minLegalValue = limits[0];
927 m_maxLegalValue = limits[1];
928 m_minDataValue = limits[2];
929 m_maxDataValue = limits[3];
934 ColumnVectorData<complex<float> >::setDataLimits (complex<float>* limits);
937 #if SPEC_TEMPLATE_IMP_DEFECT || SPEC_TEMPLATE_DECL_DEFECT 939 inline void ColumnVectorData<complex<double> >::setDataLimits (complex<double>* limits)
941 m_minLegalValue = limits[0];
942 m_maxLegalValue = limits[1];
943 m_minDataValue = limits[2];
944 m_maxDataValue = limits[3];
949 ColumnVectorData<complex<double> >::setDataLimits (complex<double>* limits);
953 #if SPEC_TEMPLATE_IMP_DEFECT || SPEC_TEMPLATE_DECL_DEFECT 955 inline void ColumnVectorData<std::complex<float> >::readColumnData(
long firstRow,
956 long nelements,
long firstElem, std::complex<float>* null )
960 FITSUtil::auto_array_ptr<float> pArray(
new float[2*nelements]);
961 float* array = pArray.get();
965 nelements,nulval,array,&anynul,&status) )
throw FitsError(status);
967 if (m_data.size() !=
static_cast<size_t>(
rows())) m_data.resize(
rows());
969 std::valarray<std::complex<float> >
readData(nelements);
970 for (
long j = 0; j < nelements; ++j)
972 readData[j] = std::complex<float>(array[2*j],array[2*j+1]);
974 size_t countRead = 0;
975 const size_t ONE = 1;
977 if (m_data.size() !=
static_cast<size_t>(
rows())) m_data.resize(
rows());
978 size_t vectorSize(0);
981 vectorSize = std::max(
repeat(),ONE);
989 vectorSize = nelements;
991 size_t n = nelements;
995 while ( countRead < n)
997 std::valarray<complex<float> >& current = m_data[ii];
998 if (current.size() != vectorSize) current.resize(vectorSize,0.);
999 int elementsInFirstRow = vectorSize-firstElem + 1;
1000 bool lastRow = ( (nelements - countRead) < vectorSize);
1003 int elementsInLastRow = nelements - countRead;
1005 countRead += elementsInLastRow;
1010 if (firstElem == 1 || (firstElem > 1 && i > firstRow) )
1012 current =
readData[std::slice(vectorSize*(ii-firstRow)+
1013 elementsInFirstRow,vectorSize,1)];
1016 countRead += vectorSize;
1023 ¤t[firstElem]);
1024 countRead += elementsInFirstRow;
1034 void ColumnVectorData<complex<float> >::readColumnData(
long firstRow,
1036 long firstElem, complex<float>* null);
1039 #if SPEC_TEMPLATE_IMP_DEFECT || SPEC_TEMPLATE_DECL_DEFECT 1041 inline void ColumnVectorData<complex<double> >::readColumnData (
long firstRow,
1042 long nelements,
long firstElem,
1043 complex<double>* nullValue)
1050 FITSUtil::auto_array_ptr<double> pArray(
new double[2*nelements]);
1051 double* array = pArray.get();
1055 nelements,nulval,array,&anynul,&status) )
throw FitsError(status);
1057 if (m_data.size() !=
static_cast<size_t>(
rows())) m_data.resize(
rows());
1059 std::valarray<std::complex<double> >
readData(nelements);
1060 for (
long j = 0; j < nelements; ++j)
1062 readData[j] = std::complex<double>(array[2*j],array[2*j+1]);
1064 size_t countRead = 0;
1065 const size_t ONE = 1;
1067 if (m_data.size() !=
static_cast<size_t>(
rows())) m_data.resize(
rows());
1068 size_t vectorSize(0);
1071 vectorSize = std::max(
repeat(),ONE);
1079 vectorSize = nelements;
1081 size_t n = nelements;
1085 while ( countRead < n)
1087 std::valarray<std::complex<double> >& current = m_data[ii];
1088 if (current.size() != vectorSize) current.resize(vectorSize,0.);
1089 int elementsInFirstRow = vectorSize-firstElem + 1;
1090 bool lastRow = ( (nelements - countRead) < vectorSize);
1093 int elementsInLastRow = nelements - countRead;
1095 countRead += elementsInLastRow;
1100 if (firstElem == 1 || (firstElem > 1 && i > firstRow) )
1102 current =
readData[std::slice(vectorSize*(ii-firstRow)+
1103 elementsInFirstRow,vectorSize,1)];
1106 countRead += vectorSize;
1113 ¤t[firstElem]);
1114 countRead += elementsInFirstRow;
1124 void ColumnVectorData<complex<double> >::readColumnData (
long firstRow,
1126 long firstElem, complex<double>* null);
1129 #if SPEC_TEMPLATE_IMP_DEFECT || SPEC_TEMPLATE_DECL_DEFECT 1131 inline void ColumnVectorData<complex<float> >::writeFixedArray
1132 (complex<float>* data,
long nElements,
long nRows,
long firstRow,
1133 complex<float>* nullValue)
1143 if ( nElements < nRows*static_cast<long>(
repeat()) )
1145 #ifdef SSTREAM_DEFECT 1146 std::ostrstream msgStr;
1148 std::ostringstream msgStr;
1150 msgStr <<
" input array size: " << nElements
1151 <<
" required " << nRows*
repeat();
1152 #ifdef SSTREAM_DEFECT 1153 msgStr << std::ends;
1157 String msg(msgStr.str());
1159 throw Column::InsufficientElements(msg);
1162 FITSUtil::auto_array_ptr<float> realData(
new float[2*nElements]);
1164 for (
int j = 0; j < nElements; ++j)
1166 realData[2*j] = data[j].real();
1167 realData[2*j+1] = data[j].imag();
1173 1,nElements,realData.get(),&status))
throw FitsError(status);
1179 void ColumnVectorData<complex<float> >::writeFixedArray
1180 (complex<float>* data,
long nElements,
long nRows,
long firstRow, std::complex<float>* null);
1183 #if SPEC_TEMPLATE_IMP_DEFECT || SPEC_TEMPLATE_DECL_DEFECT 1185 inline void ColumnVectorData<complex<double> >::writeFixedArray
1186 (complex<double>* data,
long nElements,
long nRows,
long firstRow,
1187 complex<double>* nullValue)
1196 if ( nElements < nRows*static_cast<long>(
repeat()) )
1198 #ifdef SSTREAM_DEFECT 1199 std::ostrstream msgStr;
1201 std::ostringstream msgStr;
1203 msgStr <<
" input array size: " << nElements
1204 <<
" required " << nRows*
repeat();
1205 #ifdef SSTREAM_DEFECT 1206 msgStr << std::ends;
1209 String msg(msgStr.str());
1211 throw Column::InsufficientElements(msg);
1214 FITSUtil::auto_array_ptr<double> realData(
new double[2*nElements]);
1216 for (
int j = 0; j < nElements; ++j)
1218 realData[2*j] = data[j].real();
1219 realData[2*j+1] = data[j].imag();
1225 1,nElements,realData.get(),&status))
throw FitsError(status);
1232 void ColumnVectorData<complex<double> >::writeFixedArray
1233 (complex<double>* data,
long nElements,
long nRows,
long firstRow,
1234 std::complex<double>* null);
1237 #ifdef SPEC_TEMPLATE_DECL_DEFECT 1240 ColumnVectorData<std::complex<float> >::doWrite
1241 (std::complex<float>* data,
long row,
long rowSize,
long firstElem, std::complex<float>* nullValue )
1244 FITSUtil::auto_array_ptr<float> carray(
new float[2*rowSize]);
1245 for (
long j = 0 ; j < rowSize; ++ j)
1247 carray[2*j] = data[j].real();
1248 carray[2*j + 1] = data[j].imag();
1251 carray.get(),&status))
throw FitsError(status);
1257 ColumnVectorData<std::complex<double> >::doWrite
1258 (std::complex<double>* data,
long row,
long rowSize,
long firstElem, std::complex<double>* nullValue )
1261 FITSUtil::auto_array_ptr<double> carray(
new double[2*rowSize]);
1262 for (
long j = 0 ; j < rowSize; ++ j)
1264 carray[2*j] = data[j].real();
1265 carray[2*j + 1] = data[j].imag();
1268 carray.get(),&status))
throw FitsError(status);
1275 ColumnVectorData<complex<float> >::doWrite
1276 ( complex<float>* data,
long row,
long rowSize,
long firstElem, complex<float>* nullValue);
1280 ColumnVectorData<complex<double> >::doWrite
1281 ( complex<double>* data,
long row,
long rowSize,
long firstElem, complex<double>* nullValue );
fitsfile * fitsPointer()
fits pointer corresponding to fits file containing column data.
Definition: Column.cxx:264
int index() const
get the Column index (the n in TTYPEn etc).
Definition: Column.h:1357
const String & format() const
return TFORMn keyword
Definition: Column.h:1519
Table * parent() const
return a pointer to the Table which owns this Column
Definition: Column.cxx:312
int rows() const
return the number of rows in the table.
Definition: Column.cxx:275
void updateRows()
update the number of rows in the table
Definition: Table.cxx:301
void makeHDUCurrent()
make HDU containing this the current HDU of the fits file.
Definition: Column.cxx:270
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
const String & comment() const
retrieve comment for Column
Definition: Column.h:1514
const String & dimen() const
return TDIMn keyword
Definition: Column.h:1424
bool isRead() const
flag set to true if the entire column data has been read from disk
Definition: Column.h:1367
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:81
Column(const Column &right)
copy constructor, used in copying Columns to standard library containers.
Definition: Column.cxx:171
const String & unit() const
get units of data in Column (TUNITn keyword)
Definition: Column.h:1524
const String & name() const
return name of Column (TTYPEn keyword)
Definition: Column.h:1529
virtual void readData(long firstRow, long nelements, long firstElem=1)=0
Read (or reread) data from the disk into the Column object's internal arrays.
size_t repeat() const
get the repeat count for the rows
Definition: Column.h:1387
ValueType type() const
returns the data type of the column
Definition: Column.h:1434
bool varLength() const
boolean, set to true if Column has variable length vector rows.
Definition: Column.h:1392