void CAMmatrixBase::plot(const CAMmatrixBase& Ordinates) const { // // Need Conversion Check // long dimension; long M,N; CAMmatrixBase A; const CAMmatrixBase* InputPtr; double* AdataPtr; double* BdataPtr; long j; int autoFlag; double x_min, x_max, y_min, y_max; CAMmatrixBase O; double* OdataPtr; long Odimension; long Ocount; // if(Structure.isSubset() == 1) { A.initializeMinDuplicate(*this); dimension = A.getDimension(); AdataPtr = (double*)A.getDataPointer(); if(dimension >= 1) M = A[1].getIndexCount(); if(dimension == 2) N = A[2].getIndexCount(); InputPtr = &A; } else { dimension = getDimension(); AdataPtr = (double*)getDataPointer(); if(dimension >= 1) M = Structure[1].getIndexCount(); if(dimension == 2) N = Structure[2].getIndexCount(); InputPtr = this; } if(Ordinates.Structure.isSubset() == 1) { O.initializeMinDuplicate(Ordinates); Odimension = O.getDimension(); OdataPtr = (double*)O.getDataPointer(); Ocount = O[1].getIndexCount(); } else { Odimension = Ordinates.getDimension(); OdataPtr = (double*)Ordinates.getDataPointer(); Ocount = Ordinates[1].getIndexCount(); } if(Odimension != 1) {CAMmatrixBase::ordinateError(Ordinates.Structure);} if(M != Ocount) {CAMmatrixBase::ordinateError(Ordinates.Structure);} switch (dimension) { case 1 : CAMgraphics::plot(OdataPtr,AdataPtr,M); break; case 2 : autoFlag = CAMgraphics::getAutoScaleFlag(); x_min = *OdataPtr; x_max = *(OdataPtr +(M-1)); y_min = InputPtr->min(); y_max = InputPtr->max(); CAMgraphics::axis(x_min,x_max,y_min,y_max); for(j = 1; j <= N; j++) { BdataPtr = AdataPtr + (j-1)*M; CAMgraphics::plot(OdataPtr, BdataPtr,M); } CAMgraphics::axis(autoFlag); break; default : CAMmatrixBase::plotDimensionError(A.Structure); } }
void MdamPoint::printBrief() const { char * dataPointer = getDataPointer(); Lng32 keyLen = tupp_.getAllocatedSize(); // We don't know what the data type is, but we do know how // long the field is. So we will guess the data type. // The Generator transforms varchars to chars, so we don't // have to worry about varchar length fields. // We might have a null indicator, but we have no way of knowing // that here. So we will ignore that possibility. (Sorry!) // If the length is 2 or 4 or 8, we'll guess that it is an // integer and print a signed integer interpretation. // If the length is 7 and the first two bytes, when interpreted // as Big Endian, looks like a year within 100 years of 2000, // we'll interpret it as a TIMESTAMP(0). // There are other possibilities of course which can be added // over time but a better solution would be to change the // Generator and Executor to simply give us the data type info. char local[1001]; // will assume our length is <= 1000 local[0] = '\0'; if (dataPointer) { bool allNulls = true; bool allFFs = true; bool allPrintable = true; size_t i = 0; while (i < keyLen && (allNulls || allFFs)) { if (dataPointer[i] != '\0') allNulls = false; if (dataPointer[i] != -1) allFFs = false; if (!isprint(dataPointer[i])) allPrintable = false; i++; } if (allNulls) { strcpy(local,"*lo*"); // hopefully there won't be a legitimate value of *lo* } else if (allFFs) { strcpy(local,"*hi*"); // hopefully there won't be a legitimate value of *hi* } else if (allPrintable) { size_t lengthToMove = sizeof(local) - 1; if (keyLen < lengthToMove) lengthToMove = keyLen; strncpy(local,dataPointer,lengthToMove); local[lengthToMove] = '\0'; } else { // create a hex representation of the first 498 characters strcpy(local,"hex "); char * nextTarget = local + strlen(local); size_t repdChars = ((sizeof(local) - 1)/2) - 4; // -4 to allow for "hex " if (keyLen < repdChars) repdChars = keyLen; for (size_t i = 0; i < repdChars; i++) { unsigned char nibbles[2]; nibbles[0] = ((unsigned char)dataPointer[i] & (unsigned char)0xf0)/16; nibbles[1] = (unsigned char)dataPointer[i] & (unsigned char)0x0f; for (size_t j = 0; j < 2; j++) { if (nibbles[j] < 10) *nextTarget = '0' + nibbles[j]; else *nextTarget = 'a' + (nibbles[j] - 10); nextTarget++; } // for j } // for i *nextTarget = '\0'; } if (keyLen == 2) // if it might be a short { // append an interpretation as a short (note that there // is room in local for this purpose) // the value is big-endian hence the weird computation long value = 256 * dataPointer[0] + (unsigned char)dataPointer[1]; sprintf(local + strlen(local), " (short %ld)",value); } else if (keyLen == 4) // if it might be a long { // append an interpretation as a long (note that there // is room in local for this purpose) // the value is big-endian hence the weird computation long value = 256 * 256 * 256 * dataPointer[0] + 256 * 256 * (unsigned char)dataPointer[1] + 256 * (unsigned char)dataPointer[2] + (unsigned char)dataPointer[3]; sprintf(local + strlen(local), " (long %ld)",value); } else if (keyLen == 8) // if it might be a 64-bit integer { // append an interpretation as a short (note that there // is room in local for this purpose) // the value is big-endian hence the weird computation long long value = 256 * 256 * 256 * dataPointer[0] + 256 * 256 * (unsigned char)dataPointer[1] + 256 * (unsigned char)dataPointer[2] + (unsigned char)dataPointer[3]; value = (long long)256 * 256 * 256 * 256 * value + 256 * 256 * 256 * (unsigned char)dataPointer[4] + 256 * 256 * (unsigned char)dataPointer[5] + 256 * (unsigned char)dataPointer[6] + (unsigned char)dataPointer[7]; sprintf(local + strlen(local), " (long long %lld)",value); } else if (keyLen == 7) // a TIMESTAMP(0) perhaps? { long year = 256 * dataPointer[0] + (unsigned char)dataPointer[1]; if ((year >= 1900) && (year <= 2100)) { // looks like a TIMESTAMP(0); look further long month = (unsigned char)dataPointer[2]; long day = (unsigned char)dataPointer[3]; long hour = (unsigned char)dataPointer[4]; long minute = (unsigned char)dataPointer[5]; long second = (unsigned char)dataPointer[6]; if ((month >= 1) && (month <= 12) && (day >= 1) && (day <= 31) && (hour >= 0) && (hour <= 23) && (minute >= 0) && (minute <= 59) && (second >= 0) && (second <= 59)) { sprintf(local + strlen(local), " (TIMESTAMP(0) %ld-%02ld-%02ld %02ld:%02ld:%02ld)", year,month,day,hour,minute,second); } } } } cout << local; // cout << *(Lng32 *)dataPointer; // End test change }
void setQuaternion(Item* target, const Quaternion& newValue) { Quaternion* data = static_cast<Quaternion*>(getDataPointer(target)); *data = newValue; }
//-------------------------------------------------------------------------------------------- ParamData& ParamContainer::getData(long _id) { ParamData* data = getDataPointer(_id); GOTHOGRE_ASSERT(data != nullptr, "ParamContainer: Not found data by ID = " << _id); return *data; }