void ParameterList::append(const QString &pName) { append(Parameter(pName, QVariant())); }
//----------------------------------------------------------------------- ParameterPtr ParameterFactory::createOutColor(int index) { return ParameterPtr(OGRE_NEW Parameter(GCT_FLOAT4, "oColor_" + StringConverter::toString(index), Parameter::SPS_COLOR, index, index == 0 ? Parameter::SPC_COLOR_DIFFUSE : Parameter::SPC_COLOR_SPECULAR)); }
AD<Base>& AD<Base>::operator -= (const AD<Base> &right) { ADTape<Base> *tape = AD<Base>::tape_ptr(); size_t tape_id = 0; if( tape != CPPAD_NULL ) tape_id = tape->id_; // id_ setting for parameters cannot match 0 bool var_left = id_ == tape_id; bool var_right = right.id_ == tape_id; CPPAD_ASSERT_KNOWN( Parameter(*this) || var_left , "-=: left operand is a variable for a different thread" ); CPPAD_ASSERT_KNOWN( Parameter(right) || var_right , "-=: right operand is a variable for a different thread" ); Base left; left = value_; value_ -= right.value_; if( var_left ) { if( var_right ) { // this = variable - variable CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 ); CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 ); // put operand addresses in tape tape->Rec_.PutArg(taddr_, right.taddr_); // put operator in the tape taddr_ = tape->Rec_.PutOp(SubvvOp); // make this a variable CPPAD_ASSERT_UNKNOWN( id_ == tape_id ); } else if( IdenticalZero( right.value_ ) ) { // this = variable - 0 } else { // this = variable - parameter CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 ); CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 ); // put operand addresses in tape addr_t p = tape->Rec_.PutPar(right.value_); tape->Rec_.PutArg(taddr_, p); // put operator in the tape taddr_ = tape->Rec_.PutOp(SubvpOp); // make this a variable CPPAD_ASSERT_UNKNOWN( id_ == tape_id ); } } else if( var_right ) { // this = parameter - variable CPPAD_ASSERT_UNKNOWN( NumRes(SubpvOp) == 1 ); CPPAD_ASSERT_UNKNOWN( NumArg(SubpvOp) == 2 ); // put operand addresses in tape addr_t p = tape->Rec_.PutPar(left); tape->Rec_.PutArg(p, right.taddr_); // put operator in the tape taddr_ = tape->Rec_.PutOp(SubpvOp); // make this a variable id_ = tape_id; } return *this; }
//----------------------------------------------------------------------- ParameterPtr ParameterFactory::createOutPosition(int index) { return ParameterPtr(OGRE_NEW Parameter(GCT_FLOAT4, "oPos_" + StringConverter::toString(index), Parameter::SPS_POSITION, index, Parameter::SPC_POSITION_PROJECTIVE_SPACE)); }
//----------------------------------------------------------------------- ParameterPtr ParameterFactory::createOutBiNormal(int index) { return ParameterPtr(OGRE_NEW Parameter(GCT_FLOAT3, "oBiNormal_" + StringConverter::toString(index), Parameter::SPS_BINORMAL, index, Parameter::SPC_BINORMAL)); }
// ************************************************************************** // Function: Preflight // Purpose: Checks parameters for availability and consistency with // input signal properties; requests minimally needed properties for // the output signal; checks whether resources are available. // Parameters: Input and output signal properties pointers. // Returns: N/A // ************************************************************************** void DataGlove5DTUFilter::Preflight( const SignalProperties& Input, SignalProperties& Output ) const { HINSTANCE hinstLib = NULL; FDOPEN fdOpenCall = NULL; FDCLOSE fdCloseCall = NULL; FDSCANUSB fdScanUSBCall = NULL; FDGETGLOVETYPE fdGetGloveTypeCall = NULL; FDGETGLOVEHAND fdGetGloveHandCall = NULL; FDGETNUMSENSORS fdGetNumSensorsCall = NULL; FDGETSENSORRAWALL fdGetSensorRawAllCall = NULL; FDGETSENSORRAW fdGetSensorRawCall = NULL; fdGlove *pGlove = NULL; int ret = -1; char *szPort = NULL; char szPortToOpen[6]; int glovetype = FD_GLOVENONE; int glovehand = -1; int glovesensors = -1; bool datagloveenable = false; datagloveenable = ( ( int )Parameter( "DataGloveEnable" ) != 0 ); if (!datagloveenable) { hinstLib = NULL; hinstLib = LoadLibrary(TEXT("fglove.dll")); if (hinstLib != NULL) { fdOpenCall = (FDOPEN) GetProcAddress(hinstLib, TEXT("?fdOpen@@YAPAUfdGlove@@PAD@Z")); fdCloseCall = (FDCLOSE) GetProcAddress(hinstLib, TEXT("?fdClose@@YAHPAUfdGlove@@@Z")); fdScanUSBCall = (FDSCANUSB) GetProcAddress(hinstLib, TEXT("?fdScanUSB@@YAHPAGAAH@Z")); fdGetGloveTypeCall = (FDGETGLOVETYPE) GetProcAddress(hinstLib, TEXT("?fdGetGloveType@@YAHPAUfdGlove@@@Z")); fdGetGloveHandCall = (FDGETGLOVEHAND) GetProcAddress(hinstLib, TEXT("?fdGetGloveHand@@YAHPAUfdGlove@@@Z")); fdGetNumSensorsCall = (FDGETNUMSENSORS) GetProcAddress(hinstLib, TEXT("?fdGetNumSensors@@YAHPAUfdGlove@@@Z")); fdGetSensorRawAllCall = (FDGETSENSORRAWALL) GetProcAddress(hinstLib, TEXT("?fdGetSensorRawAll@@YAXPAUfdGlove@@PAG@Z")); fdGetSensorRawCall = (FDGETSENSORRAW) GetProcAddress(hinstLib, TEXT("?fdGetSensorRaw@@YAGPAUfdGlove@@H@Z")); if (fdOpenCall != NULL && fdCloseCall != NULL && fdScanUSBCall != NULL || fdGetGloveTypeCall != NULL && fdGetGloveHandCall != NULL && fdGetNumSensorsCall != NULL || fdGetSensorRawAllCall != NULL && fdGetSensorRawCall != NULL) { unsigned short aPID[5]; int nNumFound = 5; int nChosen = 0; fdScanUSBCall(aPID,nNumFound); if (nNumFound > 0) { szPort = "USB"; strcpy(szPortToOpen,szPort); sprintf(szPortToOpen,"USB%i",nChosen); pGlove = fdOpenCall(szPortToOpen); if (pGlove != NULL) { glovetype = fdGetGloveTypeCall(pGlove); glovehand = fdGetGloveHandCall(pGlove); glovesensors = fdGetNumSensorsCall(pGlove); int parameter_hand_type = Parameter( "DataGloveHandType" ); if (glovetype == FD_GLOVE5U_USB) { if (parameter_hand_type == 0) { bciout << "Left handed data glove 5DTU found on USB port." << std::endl; } // if (parameter_hand_type == 0) if (parameter_hand_type == 1) { bciout << "Right handed data glove 5DTU found on USB port." << std::endl; } // if (parameter_hand_type == 1) bciout << "Recording form data glove 5DTU is disabled. To enable recording check DataGloveEnable in section HumanInterface Devices" << std::endl; } // if (glovetype == FD_GLOVE5U_USB) } // if (pGlove != NULL) } //if (nNumFound > 0) } // if call == NULL } // (hinstLib != NULL) } else { hinstLib = NULL; hinstLib = LoadLibrary(TEXT("fglove.dll")); if (hinstLib == NULL) { bcierr << "Dynamic Link Library fglove.dll for data glove 5DTU not found" << std::endl; return; } else { fdOpenCall = (FDOPEN) GetProcAddress(hinstLib, TEXT("?fdOpen@@YAPAUfdGlove@@PAD@Z")); fdCloseCall = (FDCLOSE) GetProcAddress(hinstLib, TEXT("?fdClose@@YAHPAUfdGlove@@@Z")); fdScanUSBCall = (FDSCANUSB) GetProcAddress(hinstLib, TEXT("?fdScanUSB@@YAHPAGAAH@Z")); fdGetGloveTypeCall = (FDGETGLOVETYPE) GetProcAddress(hinstLib, TEXT("?fdGetGloveType@@YAHPAUfdGlove@@@Z")); fdGetGloveHandCall = (FDGETGLOVEHAND) GetProcAddress(hinstLib, TEXT("?fdGetGloveHand@@YAHPAUfdGlove@@@Z")); fdGetNumSensorsCall = (FDGETNUMSENSORS) GetProcAddress(hinstLib, TEXT("?fdGetNumSensors@@YAHPAUfdGlove@@@Z")); fdGetSensorRawAllCall = (FDGETSENSORRAWALL) GetProcAddress(hinstLib, TEXT("?fdGetSensorRawAll@@YAXPAUfdGlove@@PAG@Z")); fdGetSensorRawCall = (FDGETSENSORRAW) GetProcAddress(hinstLib, TEXT("?fdGetSensorRaw@@YAGPAUfdGlove@@H@Z")); } if (fdOpenCall == NULL || fdCloseCall == NULL || fdScanUSBCall == NULL || fdGetGloveTypeCall == NULL || fdGetGloveHandCall == NULL || fdGetNumSensorsCall == NULL || fdGetSensorRawAllCall == NULL || fdGetSensorRawCall == NULL) { bcierr << "Invalid version of fglove.dll" << std::endl; return; } if (fdOpenCall != NULL) { unsigned short aPID[5]; int nNumFound = 5; int nChosen = 0; fdScanUSBCall(aPID,nNumFound); if (nNumFound == 0) { bcierr << "No data glove 5DTU found on USB port" << std::endl; return; } if (nNumFound > 1) { bciout << "More than one data glove 5DTU found on USB port, will proceed with first found" << std::endl; } szPort = "USB"; strcpy(szPortToOpen,szPort); sprintf(szPortToOpen,"USB%i",nChosen); pGlove = fdOpenCall(szPortToOpen); if (pGlove == NULL) { bcierr << "Data Glove 5DTU is not connected to the USB port" << std::endl; return; } else { glovetype = fdGetGloveTypeCall(pGlove); glovehand = fdGetGloveHandCall(pGlove); glovesensors = fdGetNumSensorsCall(pGlove); if (glovetype != FD_GLOVE5U_USB) { bcierr << "Wrong type of data glove is connected to the USB port" << std::endl; return; } int parameter_hand_type = Parameter( "DataGloveHandType" ); if (glovehand == FD_HAND_LEFT && parameter_hand_type != 0) { bcierr << "Mismatch between left handed data glove 5DTU found on USB port and right handed selected in DataGloveHandType in section HumanInterfaceDevices" << std::endl; return; } if (glovehand == FD_HAND_RIGHT && parameter_hand_type != 1) { bcierr << "Mismatch between right handed data glove 5DTU found on USB port and left handed selected in DataGloveHandType in section HumanInterfaceDevices" << std::endl; return; } } } } Output = Input; }
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION AD<Base> CondExpOp( enum CompareOp cop , const AD<Base> &left , const AD<Base> &right , const AD<Base> &if_true , const AD<Base> &if_false ) { AD<Base> returnValue; CPPAD_ASSERT_UNKNOWN( Parameter(returnValue) ); // check first case where do not need to tape if( IdenticalPar(left) & IdenticalPar(right) ) { switch( cop ) { case CompareLt: if( left.value_ < right.value_ ) returnValue = if_true; else returnValue = if_false; break; case CompareLe: if( left.value_ <= right.value_ ) returnValue = if_true; else returnValue = if_false; break; case CompareEq: if( left.value_ == right.value_ ) returnValue = if_true; else returnValue = if_false; break; case CompareGe: if( left.value_ >= right.value_ ) returnValue = if_true; else returnValue = if_false; break; case CompareGt: if( left.value_ > right.value_ ) returnValue = if_true; else returnValue = if_false; break; default: CPPAD_ASSERT_UNKNOWN(0); returnValue = if_true; } return returnValue; } // must use CondExp incase Base is an AD type and recording returnValue.value_ = CondExpOp(cop, left.value_, right.value_, if_true.value_, if_false.value_); ADTape<Base> *tape = CPPAD_NULL; if( Variable(left) ) tape = left.tape_this(); if( Variable(right) ) tape = right.tape_this(); if( Variable(if_true) ) tape = if_true.tape_this(); if( Variable(if_false) ) tape = if_false.tape_this(); // add this operation to the tape if( tape != CPPAD_NULL ) tape->RecordCondExp(cop, returnValue, left, right, if_true, if_false); return returnValue; }
//int TARGETSEQUENCE::LoadPotentialTargets(const int targetRow, const int targetCol, const int treeRow, const int treeCol) int TARGETSEQUENCE::LoadPotentialTargets() { /*shidong starts */ int targetID, parentID, displaypos, ptr, targettype; TARGET *cur_target; // if we already have a list of potential targets, delete this list if (targets) delete targets; targets=new TARGETLIST(); if(debug)fprintf(f, "Row # is %d.\n", Parameter("TargetDefinitionMatrix")->NumRows()); if(debug)fprintf(f, "ID \tType \tDisplay\tFontSizeFactor\tIconFile\n"); /* */ // parse the target definition matrix for (int i = 0; i < Parameter("TargetDefinitionMatrix")->NumRows(); i++) { targetID = AnsiString(Parameter("TargetDefinitionMatrix")(i,0).c_str()).ToInt(); cur_target = new TARGET(targetID); cur_target->targettype = AnsiString(Parameter("TargetDefinitionMatrix")(i,1).c_str()).ToInt(); cur_target->Caption = AnsiString(Parameter("TargetDefinitionMatrix")(i,2).c_str()); cur_target->FontSizeFactor = (float)(Parameter("TargetDefinitionMatrix")(i,3)); cur_target->IconFile = AnsiString(Parameter("TargetDefinitionMatrix")(i,4).c_str()); cur_target->SoundFile = AnsiString(Parameter("TargetDefinitionMatrix")(i,5).c_str()); if(debug)fprintf(f, "%d\t", cur_target->targetID); if(debug)fprintf(f, "%d\t", cur_target->targettype); if(debug)fprintf(f, "%s\t", cur_target->Caption); if(debug)fprintf(f, "%f\n", cur_target->FontSizeFactor); if(debug)fprintf(f, "%s\n", cur_target->IconFile); if(debug)fprintf(f, "%s\n", cur_target->SoundFile); // VK adding for playing .wav files if ((cur_target->SoundFile != "") && (cur_target->SoundFile != " ")) { // perform parsing to determine sound file or TextToSpeech if (cur_target->SoundFile.SubString(0,1) != "'" && (!cur_target->wavplayer) ) // implies .wav file { cur_target->wavplayer = new WavePlayer; cur_target->wavplayer->SetFile(cur_target->SoundFile.c_str()); } } targets->Add(cur_target); }//for /* char buf[256], line[256]; FILE *fp; int targetID, parentID, displaypos, ptr, targettype; TARGET *cur_target; // if we already have a list of potential targets, delete this list if (targets) delete targets; targets=new TARGETLIST(); // read the target definition file fp=fopen(targetdeffilename, "rb"); if (!fp) return(0); while (!feof(fp)) { fgets(line, 255, fp); if (strlen(line) > 2) { ptr=0; // first column ... target code ptr=get_argument(ptr, buf, line, 255); targetID=atoi(buf); cur_target=new TARGET(targetID); // second column ... caption ptr=get_argument(ptr, buf, line, 255); cur_target->Caption=AnsiString(buf).Trim(); // third column ... icon ptr=get_argument(ptr, buf, line, 255); cur_target->IconFile=AnsiString(buf).Trim(); targettype=TARGETTYPE_NOTYPE; if ((targetID == TARGETID_BLANK) || (targetID == TARGETID_BACKUP) || (targetID == TARGETID_ROOT)) targettype=TARGETTYPE_CONTROL; if ((targetID >= TARGETID_A) && (targetID <= TARGETID__)) targettype=TARGETTYPE_CHARACTER; if ((targetID >= TARGETID_ABCDEFGHI) && (targetID <= TARGETID_YZ_)) targettype=TARGETTYPE_CHARACTERS; cur_target->targettype=targettype; targets->Add(cur_target); } } fclose(fp); */ // load the tree file to go with the list of targets //if (tree->LoadTree(treeRow, treeCol) == 0) if (tree->LoadTree() == 0) return(-1); return(1); /*shidong ends*/ }
static Parameter create(const std::string& name, const T& value) { return Parameter(name, value); }
void ParameterList::append(const QString &pName, unsigned int pValue) { append(Parameter(pName, pValue)); }
void ParameterList::append(const QString &pName, double pValue) { append(Parameter(pName, pValue)); }
void ParameterList::append(const QString &pName, const QDate &pValue) { append(Parameter(pName, QVariant(pValue))); }
void ParameterList::append(const QString &pName, const char *pValue) { append(Parameter(pName, QString(pValue))); }
void ParameterList::append(const QString &pName, const QVariant &pValue) { append(Parameter(pName, pValue)); }
void AddParameter(int p) { mParameters.push_back(Parameter(p)); }
ShaderPlugin::ShaderPlugin() : CFreeFrameGLPlugin() , m_initResources(1) { SetMinInputs(0); SetMaxInputs(0); SetTimeSupported(true); m_HostSupportsSetTime = false; m_time = 0; m_timeLocation = -1; m_resolution[0] = 0; m_resolution[1] = 0; m_resolution[2] = 0; m_resolutionLocation = -1; // To FFGLize an arbitrary shader, replace shader_frag.glsl and the parameters below. // Parameter(uniform name, minimum value, maximum value, default value) // Standard parameters/float uniforms only for now. m_parameters.push_back(Parameter("sVert", 0.0, 1.0, 0.0)); m_parameters.push_back(Parameter("sHorizon", 0.0, 1.0, 0.0)); m_parameters.push_back(Parameter("sDiag", 0.0, 1.0, 0.0)); m_parameters.push_back(Parameter("sDiagAlt", 0.0, 1.0, 0.0)); m_parameters.push_back(Parameter("sArms", 0.0, 1.0, 0.0)); m_parameters.push_back(Parameter("sRings", 0.0, 1.0, 1.0)); m_parameters.push_back(Parameter("sSpiral", 0.0, 1.0, 0.0)); m_parameters.push_back(Parameter("sSpiralAlt", 0.0, 1.0, 0.0)); m_parameters.push_back(Parameter("vertPeriod", -20.0, 10.0, 4.0)); m_parameters.push_back(Parameter("horizonPeriod", -20.0, 20.0, 4.0)); m_parameters.push_back(Parameter("diagPeriod", -20.0, 20.0, 4.0)); m_parameters.push_back(Parameter("diagAltPeriod", -20.0, 20.0, 4.0)); m_parameters.push_back(Parameter("armPeriod", -20.0, 20.0, 4.0)); m_parameters.push_back(Parameter("ringPeriod", -20.0, 20.0, 4.0)); m_parameters.push_back(Parameter("spiralPeriod", -20.0, 20.0, 4.0)); m_parameters.push_back(Parameter("spiralAltPeriod", -20.0, 20.0, 4.0)); m_parameters.push_back(Parameter("numVert", 0.0, 100.0, 40.0)); m_parameters.push_back(Parameter("numHorizon", 0.0, 100.0, 40.0)); m_parameters.push_back(Parameter("numDiag", 0.0, 100.0, 40.0)); m_parameters.push_back(Parameter("numDiagAlt", 0.0, 100.0, 40.0)); m_parameters.push_back(Parameter("numArms", 0.0, 24.0, 4.0)); m_parameters.push_back(Parameter("numRings", 0.0, 24.0, 4.0)); m_parameters.push_back(Parameter("numSpiral", 0.0, 24.0, 4.0)); m_parameters.push_back(Parameter("numSpiralAlt", 0.0, 24.0, 4.0)); for (int ii = 0; ii < m_parameters.size(); ii++) { auto p = m_parameters[ii]; SetParamInfo(ii, p.Name.c_str(), FF_TYPE_STANDARD, p.Value); } }
bool Span::On(const Point& p, double* t)const { if(p != NearestPoint(p))return false; if(t)*t = Parameter(p); return true; }
Core::Core(const std::string& refPath, double probaRequiered) : _refPath(refPath), _probaRequiered(probaRequiered) { this->fillDataBase(); for (int i = IA1::nbControler; i <= IA1::control; i++) { this->_ParameterList.insert(std::pair<IA1::argumentOrder, Parameter>((IA1::argumentOrder)i, Parameter((IA1::argumentOrder)i))); } }
AD<Base> operator + (const AD<Base> &left , const AD<Base> &right) { // compute the Base part of this AD object AD<Base> result; result.value_ = left.value_ + right.value_; CPPAD_ASSERT_UNKNOWN( Parameter(result) ); // check if there is a recording in progress ADTape<Base>* tape = AD<Base>::tape_ptr(); if( tape == CPPAD_NULL ) return result; tape_id_t tape_id = tape->id_; // tape_id cannot match the default value for tape_id_; i.e., 0 CPPAD_ASSERT_UNKNOWN( tape_id > 0 ); bool var_left = left.tape_id_ == tape_id; bool var_right = right.tape_id_ == tape_id; if( var_left ) { if( var_right ) { // result = variable + variable CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 ); CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 ); // put operand addresses in tape tape->Rec_.PutArg(left.taddr_, right.taddr_); // put operator in the tape result.taddr_ = tape->Rec_.PutOp(AddvvOp); // make result a variable result.tape_id_ = tape_id; } else if( IdenticalZero(right.value_) ) { // result = variable + 0 result.make_variable(left.tape_id_, left.taddr_); } else { // result = variable + parameter // = parameter + variable CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 ); CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 ); // put operand addresses in tape addr_t p = tape->Rec_.PutPar(right.value_); tape->Rec_.PutArg(p, left.taddr_); // put operator in the tape result.taddr_ = tape->Rec_.PutOp(AddpvOp); // make result a variable result.tape_id_ = tape_id; } } else if( var_right ) { if( IdenticalZero(left.value_) ) { // result = 0 + variable result.make_variable(right.tape_id_, right.taddr_); } else { // result = parameter + variable CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 ); CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 ); // put operand addresses in tape addr_t p = tape->Rec_.PutPar(left.value_); tape->Rec_.PutArg(p, right.taddr_); // put operator in the tape result.taddr_ = tape->Rec_.PutOp(AddpvOp); // make result a variable result.tape_id_ = tape_id; } } return result; }
void mexFunction ( INT nlhs, Matrix * plhs[], INT nrhs, const Matrix * prhs[] ) { char * opname; OPCODE opcode; Matrix * mat; int status; char * path; int cmode; int mode; int cdfid; int ndims; int nvars; int natts; int recdim; char * name; long length; int dimid; nc_type datatype; int * dim; int varid; long * coords; VOIDP value; long * start; long * count; int * intcount; long * stride; long * imap; long recnum; int nrecvars; int * recvarids; long * recsizes; VOIDPP datap; /* pointers for record access. */ int len; int incdf; int invar; int outcdf; int outvar; int attnum; char * attname; char * newname; int fillmode; int i; int m; int n; char * p; char buffer[MAX_BUFFER]; DOUBLE * pr; DOUBLE addoffset; DOUBLE scalefactor; int autoscale; /* do auto-scaling if this flag is non-zero. */ /* Disable the NC_FATAL option from ncopts. */ if (ncopts & NC_FATAL) { ncopts -= NC_FATAL; } /* Display usage if less than one input argument. */ if (nrhs < 1) { Usage(); return; } /* Convert the operation name to its opcode. */ opname = Mat2Str(prhs[0]); for (i = 0; i < strlen(opname); i++) { opname[i] = (char) tolower((int) opname[i]); } p = opname; if (strncmp(p, "nc", 2) == 0) { /* Trim away "nc". */ p += 2; } i = 0; opcode = NONE; while (ops[i].opcode != NONE) { if (!strcmp(p, ops[i].opname)) { opcode = ops[i].opcode; if (ops[i].nrhs > nrhs) { mexPrintf("MEXCDF: opname = %s\n", opname); mexErrMsgTxt("MEXCDF: Too few input arguments.\n"); } else if (0 && ops[i].nlhs > nlhs) { /* Disabled. */ mexPrintf("MEXCDF: opname = %s\n", opname); mexErrMsgTxt("MEXCDF: Too few output arguments.\n"); } break; } else { i++; } } if (opcode == NONE) { mexPrintf("MEXCDF: opname = %s\n", opname); mexErrMsgTxt("MEXCDF: No such operation.\n"); } Free((VOIDPP) & opname); /* Extract the cdfid by number. */ switch (opcode) { case USAGE: case CREATE: case OPEN: case TYPELEN: case SETOPTS: case ERR: case PARAMETER: break; default: cdfid = Scalar2Int(prhs[1]); break; } /* Extract the dimid by number or name. */ switch (opcode) { case DIMINQ: case DIMRENAME: if (mxIsNumeric(prhs[2])) { dimid = Scalar2Int(prhs[2]); } else { name = Mat2Str(prhs[2]); dimid = ncdimid(cdfid, name); Free((VOIDPP) & name); } break; default: break; } /* Extract the varid by number or name. */ switch (opcode) { case VARINQ: case VARPUT1: case VARGET1: case VARPUT: case VARGET: case VARPUTG: case VARGETG: case VARRENAME: case VARCOPY: case ATTPUT: case ATTINQ: case ATTGET: case ATTCOPY: case ATTNAME: case ATTRENAME: case ATTDEL: if (mxIsNumeric(prhs[2])) { varid = Scalar2Int(prhs[2]); } else { name = Mat2Str(prhs[2]); varid = ncvarid(cdfid, name); Free((VOIDPP) & name); if (varid == -1) { varid = Parameter(prhs[2]); } } break; default: break; } /* Extract the attname by name or number. */ switch (opcode) { case ATTPUT: case ATTINQ: case ATTGET: case ATTCOPY: case ATTRENAME: case ATTDEL: if (mxIsNumeric(prhs[3])) { attnum = Scalar2Int(prhs[3]); attname = (char *) mxCalloc(MAX_NC_NAME, sizeof(char)); status = ncattname(cdfid, varid, attnum, attname); } else { attname = Mat2Str(prhs[3]); } break; default: break; } /* Extract the "add_offset" and "scale_factor" attributes. */ switch (opcode) { case VARPUT1: case VARGET1: case VARPUT: case VARGET: case VARPUTG: case VARGETG: addoffset = Add_Offset(cdfid, varid); scalefactor = Scale_Factor(cdfid, varid); if (scalefactor == 0.0) { scalefactor = 1.0; } break; default: break; } /* Perform the NetCDF operation. */ switch (opcode) { case USAGE: Usage(); break; case CREATE: path = Mat2Str(prhs[1]); if (nrhs > 2) { cmode = Parameter(prhs[2]); } else { cmode = NC_NOCLOBBER; /* Default. */ } cdfid = nccreate(path, cmode); plhs[0] = Int2Scalar(cdfid); plhs[1] = Int2Scalar((cdfid >= 0) ? 0 : -1); Free((VOIDPP) & path); break; case OPEN: path = Mat2Str(prhs[1]); if (nrhs > 2) { mode = Parameter(prhs[2]); } else { mode = NC_NOWRITE; /* Default. */ } cdfid = ncopen(path, mode); plhs[0] = Int2Scalar(cdfid); plhs[1] = Int2Scalar((cdfid >= 0) ? 0 : -1); Free((VOIDPP) & path); break; case REDEF: status = ncredef(cdfid); plhs[0] = Int2Scalar(status); break; case ENDEF: status = ncendef(cdfid); plhs[0] = Int2Scalar(status); break; case CLOSE: status = ncclose(cdfid); plhs[0] = Int2Scalar(status); break; case INQUIRE: status = ncinquire(cdfid, & ndims, & nvars, & natts, & recdim); if (nlhs > 1) { plhs[0] = Int2Scalar(ndims); plhs[1] = Int2Scalar(nvars); plhs[2] = Int2Scalar(natts); plhs[3] = Int2Scalar(recdim); plhs[4] = Int2Scalar(status); } else { /* Default to 1 x 5 row vector. */ plhs[0] = mxCreateFull(1, 5, REAL); pr = mxGetPr(plhs[0]); if (status == 0) { pr[0] = (DOUBLE) ndims; pr[1] = (DOUBLE) nvars; pr[2] = (DOUBLE) natts; pr[3] = (DOUBLE) recdim; } pr[4] = (DOUBLE) status; } break; case SYNC: status = ncsync(cdfid); plhs[0] = Int2Scalar(status); break; case ABORT: status = ncabort(cdfid); plhs[0] = Int2Scalar(status); break; case DIMDEF: name = Mat2Str(prhs[2]); length = Parameter(prhs[3]); dimid = ncdimdef(cdfid, name, length); plhs[0] = Int2Scalar(dimid); plhs[1] = Int2Scalar((dimid >= 0) ? 0 : dimid); Free((VOIDPP) & name); break; case DIMID: name = Mat2Str(prhs[2]); dimid = ncdimid(cdfid, name); plhs[0] = Int2Scalar(dimid); plhs[1] = Int2Scalar((dimid >= 0) ? 0 : dimid); Free((VOIDPP) & name); break; case DIMINQ: name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char)); status = ncdiminq(cdfid, dimid, name, & length); plhs[0] = Str2Mat(name); plhs[1] = Long2Scalar(length); plhs[2] = Int2Scalar(status); Free((VOIDPP) & name); break; case DIMRENAME: name = Mat2Str(prhs[3]); status = ncdimrename(cdfid, dimid, name); plhs[0] = Int2Scalar(status); Free((VOIDPP) & name); break; case VARDEF: name = Mat2Str(prhs[2]); datatype = (nc_type) Parameter(prhs[3]); ndims = Scalar2Int(prhs[4]); if (ndims == -1) { ndims = Count(prhs[5]); } dim = Mat2Int(prhs[5]); varid = ncvardef(cdfid, name, datatype, ndims, dim); Free((VOIDPP) & name); plhs[0] = Int2Scalar(varid); plhs[1] = Int2Scalar((varid >= 0) ? 0 : varid); break; case VARID: name = Mat2Str(prhs[2]); varid = ncvarid(cdfid, name); Free((VOIDPP) & name); plhs[0] = Int2Scalar(varid); plhs[1] = Int2Scalar((varid >= 0) ? 0 : varid); break; case VARINQ: name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char)); dim = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int)); status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts); datatype = RepairBadDataType(datatype); plhs[0] = Str2Mat(name); plhs[1] = Int2Scalar(datatype); plhs[2] = Int2Scalar(ndims); plhs[3] = Int2Mat(dim, 1, ndims); plhs[4] = Int2Scalar(natts); plhs[5] = Int2Scalar(status); Free((VOIDPP) & name); Free((VOIDPP) & dim); break; case VARPUT1: coords = Mat2Long(prhs[3]); name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char)); dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int)); status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts); datatype = RepairBadDataType(datatype); Free((VOIDPP) & name); Free((VOIDPP) & dim); if (datatype == NC_CHAR) { mat = SetNum(prhs[4]); } else { mat = prhs[4]; } if (mat == NULL) { mat = prhs[4]; } pr = mxGetPr(mat); autoscale = (nrhs > 5 && Scalar2Int(prhs[5]) != 0); if (!autoscale) { scalefactor = 1.0; addoffset = 0.0; } status = Convert(opcode, datatype, 1, buffer, scalefactor, addoffset, pr); status = ncvarput1(cdfid, varid, coords, buffer); plhs[0] = Int2Scalar(status); Free((VOIDPP) & coords); break; case VARGET1: coords = Mat2Long(prhs[3]); autoscale = (nrhs > 4 && Scalar2Int(prhs[4]) != 0); if (!autoscale) { scalefactor = 1.0; addoffset = 0.0; } name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char)); dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int)); status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts); datatype = RepairBadDataType(datatype); Free((VOIDPP) & name); Free((VOIDPP) & dim); mat = Int2Scalar(0); pr = mxGetPr(mat); status = ncvarget1(cdfid, varid, coords, buffer); status = Convert(opcode, datatype, 1, buffer, scalefactor, addoffset, pr); if (datatype == NC_CHAR) { plhs[0] = SetStr(mat); } else { plhs[0] = mat; } if (plhs[0] == NULL) { /* prhs[0] = mat; */ plhs[0] = mat; /* ZYDECO 24Jan2000 */ } plhs[1] = Int2Scalar(status); Free((VOIDPP) & coords); break; case VARPUT: start = Mat2Long(prhs[3]); count = Mat2Long(prhs[4]); autoscale = (nrhs > 6 && Scalar2Int(prhs[6]) != 0); if (!autoscale) { scalefactor = 1.0; addoffset = 0.0; } name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char)); dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int)); status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts); datatype = RepairBadDataType(datatype); if (datatype == NC_CHAR) { mat = SetNum(prhs[5]); } else { mat = prhs[5]; } if (mat == NULL) { mat = prhs[5]; } pr = mxGetPr(mat); for (i = 0; i < ndims; i++) { if (count[i] == -1) { status = ncdiminq(cdfid, dim[i], name, & count[i]); count[i] -= start[i]; } } Free((VOIDPP) & name); Free((VOIDPP) & dim); len = 0; if (ndims > 0) { len = 1; for (i = 0; i < ndims; i++) { len *= count[i]; } } value = (VOIDP) mxCalloc(len, nctypelen(datatype)); status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr); status = ncvarput(cdfid, varid, start, count, value); Free((VOIDPP) & value); plhs[0] = Int2Scalar(status); Free((VOIDPP) & start); Free((VOIDPP) & count); break; case VARGET: start = Mat2Long(prhs[3]); count = Mat2Long(prhs[4]); intcount = Mat2Int(prhs[4]); autoscale = (nrhs > 5 && Scalar2Int(prhs[5]) != 0); if (!autoscale) { scalefactor = 1.0; addoffset = 0.0; } name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char)); dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int)); status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts); datatype = RepairBadDataType(datatype); for (i = 0; i < ndims; i++) { if (count[i] == -1) { status = ncdiminq(cdfid, dim[i], name, & count[i]); count[i] -= start[i]; } } Free((VOIDPP) & name); Free((VOIDPP) & dim); m = 0; n = 0; if (ndims > 0) { m = count[0]; n = count[0]; for (i = 1; i < ndims; i++) { n *= count[i]; if (count[i] > 1) { m = count[i]; } } n /= m; } len = m * n; if (ndims < 2) { m = 1; n = len; } for (i = 0; i < ndims; i++) { intcount[i] = count[ndims-i-1]; /* Reverse order. */ } if (MEXCDF_4 || ndims < 2) { mat = mxCreateFull(m, n, mxREAL); /* mxCreateDoubleMatrix */ } # if MEXCDF_5 else { mat = mxCreateNumericArray(ndims, intcount, mxDOUBLE_CLASS, mxREAL); } # endif pr = mxGetPr(mat); value = (VOIDP) mxCalloc(len, nctypelen(datatype)); status = ncvarget(cdfid, varid, start, count, value); status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr); Free((VOIDPP) & value); if (datatype == NC_CHAR) { plhs[0] = SetStr(mat); } else { plhs[0] = mat; } if (plhs[0] == NULL) { plhs[0] = mat; } plhs[1] = Int2Scalar(status); Free((VOIDPP) & intcount); Free((VOIDPP) & count); Free((VOIDPP) & start); break; case VARPUTG: name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char)); dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int)); status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts); datatype = RepairBadDataType(datatype); if (nrhs > 7) { if (datatype == NC_CHAR) { mat = SetStr(prhs[7]); } else { mat = prhs[7]; } if (mat == NULL) { mat = prhs[7]; } } else { if (datatype == NC_CHAR) { mat = SetStr(prhs[6]); } else { mat = prhs[6]; } if (mat == NULL) { mat = prhs[6]; } } pr = mxGetPr(mat); start = Mat2Long(prhs[3]); count = Mat2Long(prhs[4]); stride = Mat2Long(prhs[5]); imap = NULL; for (i = 0; i < ndims; i++) { if (count[i] == -1) { status = ncdiminq(cdfid, dim[i], name, & count[i]); count[i] -= start[i]; } } Free((VOIDPP) & name); Free((VOIDPP) & dim); len = 0; if (ndims > 0) { len = 1; for (i = 0; i < ndims; i++) { len *= count[i]; } } autoscale = (nrhs > 8 && Scalar2Int(prhs[8]) != 0); if (!autoscale) { scalefactor = 1.0; addoffset = 0.0; } value = (VOIDP) mxCalloc(len, nctypelen(datatype)); status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr); status = ncvarputg(cdfid, varid, start, count, stride, imap, value); Free((VOIDPP) & value); plhs[0] = Int2Scalar(status); Free((VOIDPP) & stride); Free((VOIDPP) & count); Free((VOIDPP) & start); break; case VARGETG: start = Mat2Long(prhs[3]); count = Mat2Long(prhs[4]); intcount = Mat2Int(prhs[4]); stride = Mat2Long(prhs[5]); imap = NULL; autoscale = (nrhs > 7 && Scalar2Int(prhs[7]) != 0); if (!autoscale) { scalefactor = 1.0; addoffset = 0.0; } name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char)); dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int)); status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts); datatype = RepairBadDataType(datatype); for (i = 0; i < ndims; i++) { if (count[i] == -1) { status = ncdiminq(cdfid, dim[i], name, & count[i]); count[i] -= start[i]; } } Free((VOIDPP) & name); Free((VOIDPP) & dim); m = 0; n = 0; if (ndims > 0) { m = count[0]; n = count[0]; for (i = 1; i < ndims; i++) { n *= count[i]; if (count[i] > 1) { m = count[i]; } } n /= m; } len = m * n; if (ndims < 2) { m = 1; n = len; } for (i = 0; i < ndims; i++) { intcount[i] = count[ndims-i-1]; /* Reverse order. */ } if (MEXCDF_4 || ndims < 2) { mat = mxCreateFull(m, n, mxREAL); /* mxCreateDoubleMatrix */ } # if MEXCDF_5 else { mat = mxCreateNumericArray(ndims, intcount, mxDOUBLE_CLASS, mxREAL); } # endif pr = mxGetPr(mat); value = (VOIDP) mxCalloc(len, nctypelen(datatype)); status = ncvargetg(cdfid, varid, start, count, stride, imap, value); status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr); Free((VOIDPP) & value); if (datatype == NC_CHAR) { plhs[0] = SetStr(mat); } else { plhs[0] = mat; } if (plhs[0] == NULL) { /* prhs[0] = mat; */ plhs[0] = mat; /* ZYDECO 24Jan2000 */ } plhs[1] = Int2Scalar(status); Free((VOIDPP) & stride); Free((VOIDPP) & intcount); Free((VOIDPP) & count); Free((VOIDPP) & start); break; case VARRENAME: name = Mat2Str(prhs[3]); status = ncvarrename(cdfid, varid, name); plhs[0] = Int2Scalar(status); Free((VOIDPP) & name); break; case VARCOPY: incdf = cdfid; invar = varid; outcdf = Scalar2Int(prhs[3]); outvar = -1; /* outvar = ncvarcopy(incdf, invar, outcdf); */ plhs[0] = Int2Scalar(outvar); plhs[1] = Int2Scalar((outvar >= 0) ? 0 : outvar); break; case ATTPUT: datatype = (nc_type) Parameter(prhs[4]); datatype = RepairBadDataType(datatype); if (datatype == NC_CHAR) { mat = SetNum(prhs[6]); } else { mat = prhs[6]; } if (mat == NULL) { mat = prhs[6]; } len = Scalar2Int(prhs[5]); if (len == -1) { len = Count(mat); } pr = mxGetPr(mat); value = (VOIDP) mxCalloc(len, nctypelen(datatype)); status = Convert(opcode, datatype, len, value, (DOUBLE) 1.0, (DOUBLE) 0.0, pr); status = ncattput(cdfid, varid, attname, datatype, len, value); if (value != NULL) { Free((VOIDPP) & value); } plhs[0] = Int2Scalar(status); Free((VOIDPP) & attname); break; case ATTINQ: status = ncattinq(cdfid, varid, attname, & datatype, & len); datatype = RepairBadDataType(datatype); plhs[0] = Int2Scalar((int) datatype); plhs[1] = Int2Scalar(len); plhs[2] = Int2Scalar(status); Free((VOIDPP) & attname); break; case ATTGET: status = ncattinq(cdfid, varid, attname, & datatype, & len); datatype = RepairBadDataType(datatype); value = (VOIDP) mxCalloc(len, nctypelen(datatype)); status = ncattget(cdfid, varid, attname, value); mat = mxCreateDoubleMatrix(1, len, mxREAL); pr = mxGetPr(mat); status = Convert(opcode, datatype, len, value, (DOUBLE) 1.0, (DOUBLE) 0.0, pr); if (value != NULL) { Free((VOIDPP) & value); } if (datatype == NC_CHAR) { plhs[0] = SetStr(mat); } else { plhs[0] = mat; } if (plhs[0] == NULL) { /* prhs[4] = mat; */ plhs[0] = mat; /* ZYDECO 24Jan2000 */ } plhs[1] = Int2Scalar(status); Free((VOIDPP) & attname); break; case ATTCOPY: incdf = cdfid; invar = varid; outcdf = Scalar2Int(prhs[4]); if (mxIsNumeric(prhs[5])) { outvar = Scalar2Int(prhs[2]); } else { name = Mat2Str(prhs[5]); outvar = ncvarid(cdfid, name); Free((VOIDPP) & name); } status = ncattcopy(incdf, invar, attname, outcdf, outvar); plhs[0] = Int2Scalar(status); Free((VOIDPP) & attname); break; case ATTNAME: attnum = Scalar2Int(prhs[3]); attname = (char *) mxCalloc(MAX_NC_NAME, sizeof(char)); status = ncattname(cdfid, varid, attnum, attname); plhs[0] = Str2Mat(attname); plhs[1] = Int2Scalar(status); Free((VOIDPP) & attname); break; case ATTRENAME: newname = Mat2Str(prhs[4]); status = ncattrename(cdfid, varid, attname, newname); plhs[0] = Int2Scalar(status); Free((VOIDPP) & attname); Free((VOIDPP) & newname); break; case ATTDEL: status = ncattdel(cdfid, varid, attname); plhs[0] = Int2Scalar(status); Free((VOIDPP) & attname); break; case RECPUT: recnum = Scalar2Long(prhs[2]); pr = mxGetPr(prhs[3]); autoscale = (nrhs > 4 && Scalar2Int(prhs[4]) != 0); if (!autoscale) { scalefactor = 1.0; addoffset = 0.0; } recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int)); recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long)); datap = (VOIDPP) mxCalloc(MAX_VAR_DIMS, sizeof(VOIDP)); status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes); if (status == -1) { plhs[0] = Int2Scalar(status); break; } length = 0; n = 0; for (i = 0; i < nrecvars; i++) { ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL); datatype = RepairBadDataType(datatype); length += recsizes[i]; n += (recsizes[i] / nctypelen(datatype)); } if (Count(prhs[3]) < n) { status = -1; plhs[0] = Int2Scalar(status); break; } if ((value = (VOIDP) mxCalloc((int) length, sizeof(char))) == NULL) { status = -1; plhs[0] = Int2Scalar(status); break; } length = 0; p = value; for (i = 0; i < nrecvars; i++) { datap[i] = p; p += recsizes[i]; } p = (char *) value; pr = mxGetPr(prhs[3]); for (i = 0; i < nrecvars; i++) { ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL); datatype = RepairBadDataType(datatype); length = recsizes[i] / nctypelen(datatype); if (autoscale) { addoffset = Add_Offset(cdfid, recvarids[i]); scalefactor = Scale_Factor(cdfid, recvarids[i]); if (scalefactor == 0.0) { scalefactor = 1.0; } } Convert(opcode, datatype, length, (VOIDP) p, scalefactor, addoffset, pr); pr += length; p += recsizes[i]; } status = ncrecput(cdfid, recnum, datap); plhs[0] = Int2Scalar(status); Free ((VOIDPP) & value); Free ((VOIDPP) & datap); Free ((VOIDPP) & recsizes); Free ((VOIDPP) & recvarids); break; case RECGET: recnum = Scalar2Long(prhs[2]); autoscale = (nrhs > 3 && Scalar2Int(prhs[3]) != 0); if (!autoscale) { scalefactor = 1.0; addoffset = 0.0; } recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int)); recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long)); datap = (VOIDPP) mxCalloc(MAX_VAR_DIMS, sizeof(VOIDP)); status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes); if (status == -1) { Free ((VOIDPP) & recsizes); Free ((VOIDPP) & recvarids); plhs[1] = Int2Scalar(status); break; } if (nrecvars == 0) { Free ((VOIDPP) & recsizes); Free ((VOIDPP) & recvarids); plhs[0] = mxCreateFull(0, 0, REAL); break; } length = 0; n = 0; for (i = 0; i < nrecvars; i++) { ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL); datatype = RepairBadDataType(datatype); length += recsizes[i]; n += (recsizes[i] / nctypelen(datatype)); } if ((value = (VOIDP) mxCalloc((int) length, sizeof(char))) == NULL) { status = -1; plhs[1] = Int2Scalar(status); break; } if (value == NULL) { status = -1; plhs[1] = Int2Scalar(status); break; } length = 0; p = value; for (i = 0; i < nrecvars; i++) { datap[i] = p; p += recsizes[i]; } if ((status = ncrecget(cdfid, recnum, datap)) == -1) { plhs[1] = Int2Scalar(status); break; } m = 1; plhs[0] = mxCreateFull(m, n, REAL); if (plhs[0] == NULL) { status = -1; plhs[1] = Int2Scalar(status); break; } pr = mxGetPr(plhs[0]); p = (char *) value; for (i = 0; i < nrecvars; i++) { status = ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL); datatype = RepairBadDataType(datatype); if (status == -1) { plhs[1] = Int2Scalar(status); break; } length = recsizes[i] / nctypelen(datatype); if (autoscale) { addoffset = Add_Offset(cdfid, recvarids[i]); scalefactor = Scale_Factor(cdfid, recvarids[i]); if (scalefactor == 0.0) { scalefactor = 1.0; } } Convert(opcode, datatype, length, (VOIDP) p, scalefactor, addoffset, pr); pr += length; p += recsizes[i]; } plhs[1] = Int2Scalar(status); Free ((VOIDPP) & value); Free ((VOIDPP) & datap); Free ((VOIDPP) & recsizes); Free ((VOIDPP) & recvarids); break; case RECINQ: recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int)); recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long)); status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes); if (status != -1) { for (i = 0; i < nrecvars; i++) { ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL); datatype = RepairBadDataType(datatype); recsizes[i] /= nctypelen(datatype); } m = 1; n = nrecvars; plhs[0] = Int2Mat(recvarids, m, n); plhs[1] = Long2Mat(recsizes, m, n); } plhs[2] = Int2Scalar(status); Free ((VOIDPP) & recsizes); Free ((VOIDPP) & recvarids); break; case TYPELEN: datatype = (nc_type) Parameter(prhs[1]); len = nctypelen(datatype); plhs[0] = Int2Scalar(len); plhs[1] = Int2Scalar((len >= 0) ? 0 : 1); break; case SETFILL: fillmode = Scalar2Int(prhs[1]); status = ncsetfill(cdfid, fillmode); plhs[0] = Int2Scalar(status); plhs[1] = Int2Scalar(0); break; case SETOPTS: plhs[0] = Int2Scalar(ncopts); plhs[1] = Int2Scalar(0); ncopts = Scalar2Int(prhs[1]); break; case ERR: plhs[0] = Int2Scalar(ncerr); ncerr = 0; plhs[1] = Int2Scalar(0); break; case PARAMETER: if (nrhs > 1) { plhs[0] = Int2Scalar(Parameter(prhs[1])); plhs[1] = Int2Scalar(0); } else { i = 0; while (strcmp(parms[i].name, "NONE") != 0) { mexPrintf("%12d %s\n", parms[i].code, parms[i].name); i++; } plhs[0] = Int2Scalar(0); plhs[1] = Int2Scalar(-1); } break; default: break; } return; }
void ADTape<Base>::RecordCondExp( enum CompareOp cop , AD<Base> &returnValue , const AD<Base> &left , const AD<Base> &right , const AD<Base> &if_true , const AD<Base> &if_false ) { size_t ind0, ind1, ind2, ind3, ind4, ind5; size_t returnValue_taddr; // taddr_ of this variable CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 ); returnValue_taddr = Rec_.PutOp(CExpOp); // ind[0] = cop ind0 = addr_t( cop ); // ind[1] = base 2 representaion of the value // [Var(left), Var(right), Var(if_true), Var(if_false)] ind1 = 0; // Make sure returnValue is in the list of variables and set its taddr if( Parameter(returnValue) ) returnValue.make_variable(id_, returnValue_taddr ); else returnValue.taddr_ = returnValue_taddr; // ind[2] = left address if( Parameter(left) ) ind2 = Rec_.PutPar(left.value_); else { ind1 += 1; ind2 = left.taddr_; } // ind[3] = right address if( Parameter(right) ) ind3 = Rec_.PutPar(right.value_); else { ind1 += 2; ind3 = right.taddr_; } // ind[4] = if_true address if( Parameter(if_true) ) ind4 = Rec_.PutPar(if_true.value_); else { ind1 += 4; ind4 = if_true.taddr_; } // ind[5] = if_false address if( Parameter(if_false) ) ind5 = Rec_.PutPar(if_false.value_); else { ind1 += 8; ind5 = if_false.taddr_; } CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 ); CPPAD_ASSERT_UNKNOWN( ind1 > 0 ); Rec_.PutArg(ind0, ind1, ind2, ind3, ind4, ind5); // check that returnValue is a dependent variable CPPAD_ASSERT_UNKNOWN( Variable(returnValue) ); }
CmdPrescaler1() { address.address = kCtrlPrescaler1; address.data = 0; // low-frequency PWM for motors and bulbs switch (Parameter(kParamCH1Type).get()) { case v3_output_type::kLowPowerBulb: case v3_output_type::kHighPowerBulb: case v3_output_type::kMotor: prescaler_1.prs1 = kPRSDiv4; break; default: break; } switch (Parameter(kParamCH2Type).get()) { case v3_output_type::kLowPowerBulb: case v3_output_type::kHighPowerBulb: case v3_output_type::kMotor: prescaler_1.prs2 = kPRSDiv4; break; default: break; } switch (Parameter(kParamCH3Type).get()) { case v3_output_type::kLowPowerBulb: case v3_output_type::kHighPowerBulb: case v3_output_type::kMotor: prescaler_1.prs3 = kPRSDiv4; break; default: break; } switch (Parameter(kParamCH4Type).get()) { case v3_output_type::kLowPowerBulb: case v3_output_type::kHighPowerBulb: case v3_output_type::kMotor: prescaler_1.prs4 = kPRSDiv4; break; default: break; } switch (Parameter(kParamCH5Type).get()) { case v3_output_type::kLowPowerBulb: case v3_output_type::kHighPowerBulb: case v3_output_type::kMotor: prescaler_1.prs5 = kPRSDiv4; break; default: break; } }
//----------------------------------------------------------------------- ParameterPtr ParameterFactory::createOutNormal(int index) { return ParameterPtr(OGRE_NEW Parameter(GCT_FLOAT3, "oNormal_" + StringConverter::toString(index), Parameter::SPS_NORMAL, index, Parameter::SPC_NORMAL_OBJECT_SPACE)); }
virtual void addToggleButton(char* label, float* zone) { mParameters.push_back(Parameter(kToggleButton, label, zone)); }
//----------------------------------------------------------------------- ParameterPtr ParameterFactory::createOutTangent(int index) { return ParameterPtr(OGRE_NEW Parameter(GCT_FLOAT3, "oTangent_" + StringConverter::toString(index), Parameter::SPS_TANGENT, index, Parameter::SPC_TANGENT)); }
virtual void addCheckButton(char* label, float* zone) { mParameters.push_back(Parameter(kCheckButton, label, zone)); }
//----------------------------------------------------------------------- ParameterPtr ParameterFactory::createOutTexcoord4(int index, Parameter::Content content) { return ParameterPtr(OGRE_NEW Parameter(GCT_FLOAT4, "oTexcoord4_" + StringConverter::toString(index), Parameter::SPS_TEXTURE_COORDINATES, index, content)); }
void AddParameter() { mParameters.push_back(Parameter()); }
/*static*/ Variable Variable::Deserialize(const Dictionary& dict, const CNTK::DeviceDescriptor& device) { static const vector<std::wstring> s_requiredDictionaryKeys = { typeKey, uidKey, kindKey, dataTypeKey, dynamicAxisKey, isSparseKey, needsGradientKey, shapeKey }; size_t version = ValidateDictionary<Variable>(dict, s_requiredDictionaryKeys, s_variableTypeValue, s_serializationVersion); const auto& uid = dict[uidKey].Value<std::wstring>(); VariableKind kind = VariableKind(dict[kindKey].Value<std::size_t>()); if (kind != VariableKind::Constant && kind != VariableKind::Input && kind != VariableKind::Parameter && kind != VariableKind::Placeholder) { LogicError("Unexpected variable '%ls':'%u' (%s).", kindKey.c_str(), static_cast<std::underlying_type<VariableKind>::type>(kind), GetVersionsString<Variable>(s_serializationVersion, version).c_str()); } DataType dataType = DataType(dict[dataTypeKey].Value<std::size_t>()); if (dataType != DataType::Unknown && dataType != DataType::Float && dataType != DataType::Double) { LogicError("Unexpected variable '%ls':'%u' (%s).", dataTypeKey.c_str(), static_cast<std::underlying_type<DataType>::type>(dataType), GetVersionsString<Variable>(s_serializationVersion, version).c_str()); } const vector<DictionaryValue>& dictionaryValueVector = dict[dynamicAxisKey].Value<vector<DictionaryValue>>(); vector<Axis> dynamicAxis; dynamicAxis.reserve(dictionaryValueVector.size()); for (const auto& dictionaryValue : dictionaryValueVector) { dynamicAxis.push_back(dictionaryValue.Value<Axis>()); } bool isSparse = dict[isSparseKey].Value<bool>(); std::wstring name = L""; if (dict.Contains(nameKey)) name = dict[nameKey].Value<std::wstring>(); bool needsGradient = dict[needsGradientKey].Value<bool>(); const auto& shape = dict[shapeKey].Value<NDShape>(); if (kind == VariableKind::Constant || kind == VariableKind::Parameter) { auto& value = dict[valueKey].Value<NDArrayView>(); // TODO: this copying here is redundant, value should be moved from the dictionary to the variable. // Also, the correct device should be used upfront when deserializing NDArrayView. Variable var(shape, kind, dataType, value.DeepClone(device, kind == VariableKind::Constant), needsGradient, dynamicAxis, isSparse, name, uid); if (var.IsParameter()) return Parameter(var); else return Constant(var); } return Variable(shape, kind, dataType, nullptr, needsGradient, dynamicAxis, isSparse, name, uid); }
// case where x and y are AD<Base> ----------------------------------------- template <class Base> AD<Base> pow(const AD<Base> &x, const AD<Base> &y) { ADTape<Base> *tape = AD<Base>::tape_ptr(); bool var_x, var_y; # ifdef NDEBUG if( tape == CPPAD_NULL ) { var_x = false; var_y = false; } else { var_x = x.id_ == tape->id_; var_y = y.id_ == tape->id_; } # else var_x = Variable(x); var_y = Variable(y); CPPAD_ASSERT_KNOWN( (! var_x) || x.id_ == tape->id_ , "pow first operand is a variable for a different thread" ); CPPAD_ASSERT_KNOWN( (! var_y) || y.id_ == tape->id_ , "pow second operand is a variable for a different thread" ); # endif AD<Base> result; result.value_ = pow(x.value_, y.value_); CPPAD_ASSERT_UNKNOWN( Parameter(result) ); if( var_x ) { if( var_y ) { // result = variable^variable CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 ); CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 ); // put operand addresses in tape tape->Rec_.PutArg(x.taddr_, y.taddr_); // put operator in the tape result.taddr_ = tape->Rec_.PutOp(PowvvOp); // make result a variable result.id_ = tape->id_; } else if( IdenticalZero( y.value_ ) ) { // result = variable^0 } else { // result = variable^parameter CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 ); CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 ); // put operand addresses in tape size_t p = tape->Rec_.PutPar(y.value_); tape->Rec_.PutArg(x.taddr_, p); // put operator in the tape result.taddr_ = tape->Rec_.PutOp(PowvpOp); // make result a variable result.id_ = tape->id_; } } else if( var_y ) { if( IdenticalZero(x.value_) ) { // result = 0^variable } else { // result = variable^parameter CPPAD_ASSERT_UNKNOWN( NumRes(PowpvOp) == 3 ); CPPAD_ASSERT_UNKNOWN( NumArg(PowpvOp) == 2 ); // put operand addresses in tape size_t p = tape->Rec_.PutPar(x.value_); tape->Rec_.PutArg(p, y.taddr_); // put operator in the tape result.taddr_ = tape->Rec_.PutOp(PowpvOp); // make result a variable result.id_ = tape->id_; } } return result; }