C++ checkParameters函数代码示例

int OrientationSaliencyMap::calculate()
{
  calculated = false;

  int rt_code = checkParameters();
  if(rt_code != AM_OK)
    return(rt_code);

  printf("[INFO]: %s: Computation started.\n",mapName.c_str());
  
  cv::Mat image_cur;
  image.copyTo(image_cur);
  image_cur.convertTo(image_cur,CV_32F,1.0f/255);
  cv::Mat image_gray;
  cv::cvtColor(image_cur,image_gray,CV_BGR2GRAY);
  
  cv::blur(image_gray,image_gray,cv::Size(filter_size,filter_size));
  
  orientationMap(image_gray,width,height,angle,max_sum,bandwidth,map);
  
  cv::blur(map,map,cv::Size(filter_size,filter_size));

  v4r::normalize(map,normalization_type);

  calculated = true;
  printf("[INFO]: %s: Computation succeed.\n",mapName.c_str());
  return(AM_OK);
}

 Texture2DResource(ptr<ResourceManager> manager, const string &name, ptr<ResourceDescriptor> desc, const TiXmlElement *e = NULL) :
     ResourceTemplate<0, Texture2D>(manager, name, desc)
 {
     e = e == NULL ? desc->descriptor : e;
     TextureInternalFormat tf;
     TextureFormat f;
     PixelType t;
     Texture::Parameters params;
     Buffer::Parameters s;
     int w;
     int h;
     try {
         checkParameters(desc, e, "name,source,internalformat,format,type,min,mag,wraps,wrapt,minLod,maxLod,compare,borderType,borderr,borderg,borderb,bordera,maxAniso,width,height,");
         getIntParameter(desc, e, "width", &w);
         getIntParameter(desc, e, "height", &h);
         getParameters(desc, e, tf, f, t);
         getParameters(desc, e, params);
         s.compressedSize(desc->getSize());
         init(w, h, tf, f, t, params, s, CPUBuffer(desc->getData()));
         desc->clearData();
     } catch (...) {
         desc->clearData();
         throw exception();
     }
 }

    ParticleProducerResource(ptr<ResourceManager> manager, const string &name, ptr<ResourceDescriptor> desc, const TiXmlElement *e = NULL) :
        ResourceTemplate<50, ParticleProducer>(manager, name, desc)
    {
        e = e == NULL ? desc->descriptor : e;
        checkParameters(desc, e, "name,storage,");

        ptr<ParticleStorage> storage = manager->loadResource(getParameter(desc, e, "storage")).cast<ParticleStorage>();

        const TiXmlNode *n = e->FirstChild();
        while (n != NULL) {
            const TiXmlElement *f = n->ToElement();
            if (f == NULL) {
                n = n->NextSibling();
                continue;
            }

            ptr<ParticleLayer> l = manager->loadResource(desc, f).cast<ParticleLayer>();
            if (l != NULL) {
                addLayer(l);
            } else {
                if (Logger::WARNING_LOGGER != NULL) {
                    log(Logger::WARNING_LOGGER, desc, f, "Unknown scene node element '" + f->ValueStr() + "'");
                }
            }
            n = n->NextSibling();
        }

        init(storage);

    }

    ForestOrthoLayerResource(ptr<ResourceManager> manager, const string &name, ptr<ResourceDescriptor> desc,
            const TiXmlElement *e = NULL) :
        ResourceTemplate<40, ForestOrthoLayer> (manager, name, desc)
    {
        e = e == NULL ? desc->descriptor : e;
        ptr<GraphProducer>graphProducer;
        int displayLevel = 0;
        vec4f color = vec4f((float)30/255,(float)62/255,(float)45/255, 1.0f);

        checkParameters(desc, e, "name,graph,renderProg,level,color,quality,");
        string g = getParameter(desc, e, "graph");

        graphProducer = manager->loadResource(g).cast<GraphProducer>();
        if (e->Attribute("level") != NULL) {
            getIntParameter(desc, e, "level", &displayLevel);
        }
        if (e->Attribute("quality") != NULL) {
            quality = strcmp(e->Attribute("quality"), "true") == 0;
        }

        if (e->Attribute("color") != NULL) {
            string c = getParameter(desc, e, "color") + ",";
            string::size_type start = 0;
            string::size_type index;
            for (int i = 0; i < 3; i++) {
                index = c.find(',', start);
                color[i] = (float) atof(c.substr(start, index - start).c_str()) / 255;
                start = index + 1;
            }
        }

        ptr<Program> layerProgram = manager->loadResource(getParameter(desc, e, "renderProg")).cast<Program>();
        init(graphProducer, layerProgram, displayLevel, quality, color);
    }

    TerrainNodeResource(ptr<ResourceManager> manager, const string &name, ptr<ResourceDescriptor> desc, const TiXmlElement *e = NULL) :
        ResourceTemplate<0, TerrainNode>(manager, name, desc)
    {
        e = e == NULL ? desc->descriptor : e;
        float size;
        float zmin;
        float zmax;
        ptr<Deformation> deform;
        float splitFactor;
        int maxLevel;
        checkParameters(desc, e, "name,size,zmin,zmax,deform,radius,splitFactor,horizonCulling,maxLevel,");
        getFloatParameter(desc, e, "size", &size);
        getFloatParameter(desc, e, "zmin", &zmin);
        getFloatParameter(desc, e, "zmax", &zmax);
        if (e->Attribute("deform") != NULL && strcmp(e->Attribute("deform"), "sphere") == 0) {
            deform = new SphericalDeformation(size);
        }
        if (e->Attribute("deform") != NULL && strcmp(e->Attribute("deform"), "cylinder") == 0) {
            float radius;
            getFloatParameter(desc, e, "radius", &radius);
            deform = new CylindricalDeformation(radius);
        }
        if (deform == NULL) {
            deform = new Deformation();
        }
        getFloatParameter(desc, e, "splitFactor", &splitFactor);
        getIntParameter(desc, e, "maxLevel", &maxLevel);

        ptr<TerrainQuad> root = new TerrainQuad(NULL, NULL, 0, 0, -size, -size, 2.0 * size, zmin, zmax);
        init(deform, root, splitFactor, maxLevel);

        if (e->Attribute("horizonCulling") != NULL && strcmp(e->Attribute("horizonCulling"), "false") == 0) {
            horizonCulling = false;
        }
    }

sExpression *apply(sExpression *procOrLambda, sExpression *argument, sEnvironment *env){
  if(isPrimitiveProc(procOrLambda))
  {
    sProc *cfunc = toProc(procOrLambda);
    return applyProc(cfunc, argument);
  }
  else if(isLambdaType(procOrLambda))
  {
    sLambda *lambd = toLambda(procOrLambda);
    sList *body = lambd->body;
    sList *arguments;
    sList *parameters;

    if(isList(argument)){
      //可変長引数のため
      parameters = checkParameters(lambd->parameters, toList(argument));
      arguments = checkArguments(parameters, toList(argument), lambd->isVarArgument);
    }else{
      parameters = lambd->parameters;
      arguments = toList(cons(argument, &sNull));
    }

    sEnvironment *env = extendEnvironment(parameters, arguments, lambd->frame);
    if(isList(car(body))){
      return evalSequence(body, env);
    }else{
      return eval(newExp(body, LIST_TAG), env);
    }
  }
  return &sNull;
}

static xbt_dynar_t initDynamicThrottling(int *argc, char *argv[])
{
  /* Initialize SD */
  SD_init(argc, argv);

  /* Check parameters */
  checkParameters(*argc,argv);

  /* Create environment */
  SD_create_environment(argv[1]);
  /* Load DAX file */
  xbt_dynar_t dax = SD_daxload(argv[2]);

  //  createDottyFile(dax, argv[2]);

  // Schedule DAX
  fprintf(stdout, "Scheduling DAX...\n");
  scheduleDAX(dax);
  fprintf(stdout, "DAX scheduled\n");
  xbt_dynar_t ret = SD_simulate(-1);
  xbt_dynar_free(&ret);
  fprintf(stdout, "Simulation end. Time: %f\n", SD_get_clock());

  return dax;
}

 Texture3DResource(ptr<ResourceManager> manager, const string &name, ptr<ResourceDescriptor> desc, const TiXmlElement *e = NULL) :
     ResourceTemplate<0, Texture3D>(manager, name, desc)
 {
     e = e == NULL ? desc->descriptor : e;
     TextureInternalFormat tf;
     TextureFormat f;
     PixelType t;
     Texture::Parameters params;
     Buffer::Parameters s;
     int w;
     int h;
     int d;
     try {
         checkParameters(desc, e, "name,source,internalformat,format,type,min,mag,wraps,wrapt,wrapr,minLod,maxLod,width,height,depth,");
         getIntParameter(desc, e, "width", &w);
         getIntParameter(desc, e, "height", &h);
         getIntParameter(desc, e, "depth", &d);
         if (h % d != 0) {
             if (Logger::ERROR_LOGGER != NULL) {
                 log(Logger::ERROR_LOGGER, desc, e, "Inconsistent 'height' and 'depth' attributes");
             }
             throw exception();
         }
         getParameters(desc, e, tf, f, t);
         getParameters(desc, e, params);
         s.compressedSize(desc->getSize());
         init(w, h / d, d, tf, f, t, params, s, CPUBuffer(desc->getData()));
         desc->clearData();
     } catch (...) {
         desc->clearData();
         throw exception();
     }
 }

    HydroFlowProducerResource(ptr<ResourceManager> manager, const string &name, ptr<ResourceDescriptor> desc, const TiXmlElement *e = NULL) :
        ResourceTemplate<30, HydroFlowProducer>(manager, name, desc)
    {
        e = e == NULL ? desc->descriptor : e;
        ptr<TileCache> cache;
        ptr<GraphProducer> graphs;
        int displayTileSize = 192;
        float slip = 1.0f;
        float searchRadiusFactor = 1.0f;
        float potentialDelta = 0.01f;
        int minLevel = 0;

        checkParameters(desc, e, "name,cache,graphs,displayTileSize,slip,searchRadiusFactor, potentialDelta,minLevel,");
        cache = manager->loadResource(getParameter(desc, e, "cache")).cast<TileCache>();
        graphs = manager->loadResource(getParameter(desc, e, "graphs")).cast<GraphProducer>();
        if (e->Attribute("displayTileSize") != NULL) {
            getIntParameter(desc, e, "displayTileSize", &displayTileSize);
        }
        if (e->Attribute("slip") != NULL) {
            getFloatParameter(desc, e, "slip", &slip);
        }
        if (e->Attribute("searchRadiusFactor") != NULL) {
            getFloatParameter(desc, e, "searchRadiusFactor", &searchRadiusFactor);
        }
        if (e->Attribute("potentialDelta") != NULL) {
            getFloatParameter(desc, e, "potentialDelta", &potentialDelta);
        }
        if (e->Attribute("minLevel") != NULL) {
            getIntParameter(desc, e, "minLevel", &minLevel);
        }

        init(graphs, cache, displayTileSize, slip, searchRadiusFactor, potentialDelta, minLevel);
    }

    LifeCycleParticleLayerResource(ptr<ResourceManager> manager, const string &name, ptr<ResourceDescriptor> desc, const TiXmlElement *e = NULL) :
        ResourceTemplate<50, LifeCycleParticleLayer>(manager, name, desc)
    {
        e = e == NULL ? desc->descriptor : e;
        checkParameters(desc, e, "name,fadeInDelay,fadeOutDelay,activeDelay,unit,");

        float fadeInDelay = 5.0f;
        float fadeOutDelay = 5.0f;
        float activeDelay = 30.0f;

        float unit = 1000000.0f; // delays are converted into seconds.

        if (e->Attribute("unit") != NULL) {
            if (strcmp(e->Attribute("unit"), "s") == 0) {
                unit = 1000000.0f;
            } else if (strcmp(e->Attribute("unit"), "ms") == 0) {
                unit = 1000.0f;
            } else if (strcmp(e->Attribute("unit"), "us") == 0) {
                unit = 10.f;
            }
        }

        //delays are taken in seconds
        getFloatParameter(desc, e, "fadeInDelay", &fadeInDelay);
        getFloatParameter(desc, e, "fadeOutDelay", &fadeOutDelay);
        getFloatParameter(desc, e, "activeDelay", &activeDelay);

        init(fadeInDelay * unit, activeDelay * unit, fadeOutDelay * unit);
    }

bool      Client::initialize(int ac, const char **av)
{
  struct	sockaddr_in  s_in;
  struct	protoent *pe;
  int		port;
  std::string	ip;

  if (!checkParameters(ac, av, port))
    return false;
  ac < 3 ? ip = "127.0.0.1" : ip = av[4];
  if (!(pe = getprotobyname("TCP")))
    return false;
  if ((_fd = socket(AF_INET, SOCK_STREAM, pe->p_proto)) == -1)
    return false;
  s_in.sin_family = AF_INET;
  s_in.sin_port = htons(port);
  s_in.sin_addr.s_addr = inet_addr(ip.c_str());
  std::cout << "Trying to connect with ip : " << ip << " and port : " << port << std::endl;
  if (connect(_fd, (struct sockaddr *)&s_in, sizeof(s_in)) == -1)
    {
      std::cout << "Error : Connection failed\n";
      return false;
    }
  std::cout << "Connection Success !\n";
  return true;
}

    WaterElevationLayerResource(ptr<ResourceManager> manager, const string &name, ptr<ResourceDescriptor> desc,
            const TiXmlElement *e = NULL) :
        ResourceTemplate<40, WaterElevationLayer> (manager, name, desc)
    {
        e = e == NULL ? desc->descriptor : e;
        ptr<GraphProducer> graphProducer;
        ptr<TileProducer> elevations;
        int displayLevel = 0;
        bool quality = true;
        bool deform = false;

        checkParameters(desc, e, "name,graph,renderProg,fillProg,level,cpuElevations,quality,deform,");

        string g = getParameter(desc, e, "graph");
        graphProducer = manager->loadResource(g).cast<GraphProducer>();

        string r = getParameter(desc, e, "cpuElevations");
        elevations = manager->loadResource(r).cast<TileProducer>();

        if (e->Attribute("level") != NULL) {
            getIntParameter(desc, e, "level", &displayLevel);
        }
        if (e->Attribute("quality") != NULL) {
            quality = strcmp(e->Attribute("quality"), "true") == 0;
        }
        if (e->Attribute("deform") != NULL) {
            deform = strcmp(e->Attribute("deform"), "true") == 0;
        }

        ptr<Program> layerProgram = manager->loadResource(getParameter(desc, e, "renderProg")).cast<Program>();
        ptr<Program> fillProg = manager->loadResource(getParameter(desc, e, "fillProg")).cast<Program>();
        init(graphProducer, layerProgram, fillProg, elevations, displayLevel, quality, deform);
    }

/* call as  model = mexsvmlearn(data,labels,options) */
void mexFunction(int nlhs, mxArray *plhs[],
		  int nrhs, const mxArray *prhs[])
{

  
  DOC **docs; /* hold a test example */
  double *target; /* hold labels */
  WORD *words;  /* the words read from the example */
  long rows, cols; /* the number of rows and cols in the test data */
  double dist, doc_label, costfactor;
  double *err,*pred;
  long int correct=0, incorrect=0, none=0,i;
  MODEL *model;
  checkParameters(nlhs, plhs, nrhs, prhs);

  global_init( );

  /* load model parameters from the "model" parameter */
  model = restore_model((mxArray *)prhs[2]);

  rows = mxGetM(prhs[0]);
  cols = mxGetN(prhs[0]);

  /* load the testing arrays into docs */

  mexToDOC((mxArray *)prhs[0], (mxArray *)prhs[1], &docs, &target, NULL, NULL);
  
  /* setup output environment */
  plhs[0] = mxCreateDoubleMatrix(1,1,mxREAL);
  plhs[1] = mxCreateDoubleMatrix(rows,1,mxREAL);

  err = mxGetPr(plhs[0]);
  pred = mxGetPr(plhs[1]);

  /* classify examples */
  for (i = 0; i < rows; i++) {

    dist = classify_example(model, docs[i]);
    pred[i] = dist;

    if (dist > 0) {
      if (target[i] > 0) correct++;
      else incorrect++;
    } else {
      if (target[i] < 0) correct++;
      else incorrect++;
    }

    if ((int)(0.1+(target[i] * target[i]))!=1)
      none++;

  }

  err[0] = incorrect / (double) rows;

  
  global_destroy( );

}

    Real blackFormulaImpliedStdDev(Option::Type optionType,
                                   Real strike,
                                   Real forward,
                                   Real blackPrice,
                                   Real discount,
                                   Real displacement,
                                   Real guess,
                                   Real accuracy,
                                   Natural maxIterations)
    {
        checkParameters(strike, forward, displacement);

        QL_REQUIRE(discount>0.0,
                   "discount (" << discount << ") must be positive");

        QL_REQUIRE(blackPrice>=0.0,
                   "option price (" << blackPrice << ") must be non-negative");
        // check the price of the "other" option implied by put-call paity
        Real otherOptionPrice = blackPrice - optionType*(forward-strike)*discount;
        QL_REQUIRE(otherOptionPrice>=0.0,
                   "negative " << Option::Type(-1*optionType) <<
                   " price (" << otherOptionPrice <<
                   ") implied by put-call parity. No solution exists for " <<
                   optionType << " strike " << strike <<
                   ", forward " << forward <<
                   ", price " << blackPrice <<
                   ", deflator " << discount);

        // solve for the out-of-the-money option which has
        // greater vega/price ratio, i.e.
        // it is numerically more robust for implied vol calculations
        if (optionType==Option::Put && strike>forward) {
            optionType = Option::Call;
            blackPrice = otherOptionPrice;
        }
        if (optionType==Option::Call && strike<forward) {
            optionType = Option::Put;
            blackPrice = otherOptionPrice;
        }

        strike = strike + displacement;
        forward = forward + displacement;

        if (guess==Null<Real>())
            guess = blackFormulaImpliedStdDevApproximation(
                optionType, strike, forward, blackPrice, discount, displacement);
        else
            QL_REQUIRE(guess>=0.0,
                       "stdDev guess (" << guess << ") must be non-negative");
        BlackImpliedStdDevHelper f(optionType, strike, forward,
                                   blackPrice/discount);
        NewtonSafe solver;
        solver.setMaxEvaluations(maxIterations);
        Real minSdtDev = 0.0, maxStdDev = 24.0; // 24 = 300% * sqrt(60)
        Real stdDev = solver.solve(f, accuracy, guess, minSdtDev, maxStdDev);
        QL_ENSURE(stdDev>=0.0,
                  "stdDev (" << stdDev << ") must be non-negative");
        return stdDev;
    }

 UpdateTerrainTaskResource(ptr<ResourceManager> manager, const string &name, ptr<ResourceDescriptor> desc, const TiXmlElement *e = NULL) :
     ResourceTemplate<40, UpdateTerrainTask>(manager, name, desc)
 {
     e = e == NULL ? desc->descriptor : e;
     checkParameters(desc, e, "name,");
     string n = getParameter(desc, e, "name");
     init(QualifiedName(n));
 }