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);
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);
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);
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);
578 readVariableRow(row,nullValue);
582 readColumnData(row,nelements,1,nullValue);
586 template <
typename T>
587 void ColumnVectorData<T>::readVariableRow (
size_t row, T* nullValue)
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();
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);
814 1,nElements,data,nullValue,&status))
throw FitsError(status);
819 1,nElements,data,&status))
throw FitsError(status);
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)
899 array, nullValue,&status))
throw FitsError(status);
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();
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;
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;
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();
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;
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;
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();
1171 1,nElements,realData.get(),&status))
throw FitsError(status);
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();
1223 1,nElements,realData.get(),&status))
throw FitsError(status);
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();
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();
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 );
const String & name() const
return name of Column (TTYPEn keyword)
Definition: Column.h:1505
size_t repeat() const
get the repeat count for the rows
Definition: Column.h:1363
fitsfile * fitsPointer()
fits pointer corresponding to fits file containing column data.
Definition: Column.cxx:264
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:305
void makeHDUCurrent()
make HDU containing this the current HDU of the fits file.
Definition: Column.cxx:270
Definition: MSconfig.h:123
const String & dimen() const
return TDIMn keyword
Definition: Column.h:1400
bool isRead() const
flag set to true if the entire column data has been read from disk
Definition: Column.h:1343
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
const String & unit() const
get units of data in Column (TUNITn keyword)
Definition: Column.h:1500
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
int index() const
get the Column index (the n in TTYPEn etc).
Definition: Column.h:1333
const String & comment() const
retrieve comment for Column
Definition: Column.h:1490
ValueType type() const
returns the data type of the column
Definition: Column.h:1410
bool varLength() const
boolean, set to true if Column has variable length vector rows.
Definition: Column.h:1368
const String & format() const
return TFORMn keyword
Definition: Column.h:1495
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.
Table * parent() const
return a pointer to the Table which owns this Column
Definition: Column.cxx:312