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);
433 if (!varLength() && cellsize != repeat() )
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);
483 parent()->updateRows();
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);
543 parent()->updateRows();
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);
576 long nelements(repeat());
580 readVariableRow(row,nullValue);
584 readColumnData(row,nelements,1,nullValue);
588 template <
typename T>
589 void ColumnVectorData<T>::readVariableRow (
size_t row, T* nullValue)
594 if (fits_read_descript(fitsPointer(),index(),static_cast<long>(row),
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();
610 if (fits_read_col(fitsPointer(), abs(type()),index(), firstrow, firstelem,
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);
815 if (fits_write_colnull(fitsPointer(),abs(type()),index(),firstRow,
816 1,nElements,data,nullValue,&status))
throw FitsError(status);
820 if (fits_write_col(fitsPointer(),abs(type()),index(),firstRow,
821 1,nElements,data,&status))
throw FitsError(status);
824 parent()->updateRows();
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)
900 if (fits_write_colnull(fitsPointer(),type(),index(),row, firstElem, rowSize,
901 array, nullValue,&status))
throw FitsError(status);
905 if (fits_write_col(fitsPointer(),abs(type()),index(),row,firstElem,rowSize,
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();
964 if (fits_read_col_cmp(fitsPointer(),index(),firstRow, firstElem,
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;
1004 std::copy(&readData[countRead],&readData[0]+nelements,¤t[0]);
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;
1022 std::copy(&readData[0],&readData[0]+elementsInFirstRow,
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();
1054 if (fits_read_col_dblcmp(fitsPointer(),index(),firstRow, firstElem,
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;
1094 std::copy(&readData[countRead],&readData[0]+nelements,¤t[0]);
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;
1112 std::copy(&readData[0],&readData[0]+elementsInFirstRow,
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();
1172 if (fits_write_col_cmp(fitsPointer(),index(),firstRow,
1173 1,nElements,realData.get(),&status))
throw FitsError(status);
1175 parent()->updateRows();
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();
1224 if (fits_write_col_dblcmp(fitsPointer(),index(),firstRow,
1225 1,nElements,realData.get(),&status))
throw FitsError(status);
1227 parent()->updateRows();
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();
1250 if (fits_write_col_cmp(fitsPointer(),index(),row,firstElem,rowSize,
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();
1267 if (fits_write_col_dblcmp(fitsPointer(),index(),row,firstElem,rowSize,
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 );