Esempio n. 1
0
std::vector<track> parse_cue_file(char const *path)
{
	std::ifstream cue_file;
	cue_file.open(path);
	std::vector<std::string> file;
	for (std::string line; std::getline(cue_file, line);)
		file.push_back(line);

	cue_file.close();

	interpreter interp(file);


	return interp.track_list;
}
Esempio n. 2
0
void SetVtx(TLITVERTEX &v, TLITVERTEX &v1, TLITVERTEX &v2, float r)
{
	v.x = interp(v1.x,v2.x,r);
	v.y = interp(v1.y,v2.y,r);
	//v.z = (v1.z-r*v2.z)/(1-r);
	v.dcSpecular = v2.dcSpecular; //fix me here
	v.r = (uint8)(interp((int)v1.r,(int)v2.r,r));
	v.g = (uint8)(interp((int)v1.g,(int)v2.g,r));
	v.b = (uint8)(interp((int)v1.b,(int)v2.b,r));
	v.a = (uint8)(interp((int)v1.a,(int)v2.a,r));

	for( int i=0; i<2; i++ )
	{
		v.tcord[i].u = interp(v1.tcord[i].u,v2.tcord[i].u,r);
		v.tcord[i].v = interp(v1.tcord[i].v,v2.tcord[i].v,r);
	}
}
Esempio n. 3
0
void CKeyframe::Update(float timestep) {
	if (!loaded) return;
	if (!active) return;

	keytime += timestep;
	if (keytime >= frames[keyidx].val[0]) {
		keyidx++;
		keytime = 0;
	}

	if (keyidx >= frames.size()-1 || frames.size() < 2) {
		active = false;
		return;
	}

	double frac;
	TVector3d pos;
	CCharShape *shape = g_game.character->shape;

	if (std::fabs(frames[keyidx].val[0]) < 0.0001) frac = 1.0;
	else frac = (frames[keyidx].val[0] - keytime) / frames[keyidx].val[0];

	pos.x = interp(frac, frames[keyidx].val[1], frames[keyidx+1].val[1]) + refpos.x;
	pos.z = interp(frac, frames[keyidx].val[3], frames[keyidx+1].val[3]) + refpos.z;
	pos.y = interp(frac, frames[keyidx].val[2], frames[keyidx+1].val[2]);
	pos.y += Course.FindYCoord(pos.x, pos.z);

	shape->ResetRoot();
	shape->ResetJoints();

	g_game.player->ctrl->cpos = pos;
	double disp_y = pos.y + TUX_Y_CORR + heightcorr;
	shape->ResetNode(0);
	shape->TranslateNode(0, TVector3d(pos.x, disp_y, pos.z));
	InterpolateKeyframe(keyidx, frac, shape);
}
Esempio n. 4
0
real32 dng_gain_map::Interpolate (int32 row,
								  int32 col,
								  uint32 plane,
								  const dng_rect &bounds) const
	{
	
	dng_gain_map_interpolator interp (*this,
									  bounds,
									  row,
									  col,
									  plane);
									  
	return interp.Interpolate ();
	
	}
Esempio n. 5
0
void sfac_spag()
{
  int nlu;
  fclose (fis);	fis = NULL;
  fis=fopen(ficcdimp,"r");
  if ( fis == NULL) { message(16); return;  }
  nuli=0;
  while ( (nlu=lect_fis()) > 0 )		{
    if ( strncmp(ze, "PAGSUIV",7) == 0) break;
  }
  while ( (nlu=lect_fis()) > 0 )		{
    nmot = isolmot(ze,nlu);
    interp();
  }
}
 inline Eigen::VectorXd
 interpolate(const Model & model,
              const Eigen::VectorXd & q0,
              const Eigen::VectorXd & q1,
              const double u)
 {
   Eigen::VectorXd interp(model.nq);
   for( Model::JointIndex i=1; i<(Model::JointIndex) model.nbody; ++i )
   {
     InterpolateStep::run(model.joints[i],
                           InterpolateStep::ArgsType (q0, q1, u, interp)
                           );
   }
   return interp;
 }
Esempio n. 7
0
/**
 * Redirect the std out to this object
 */
void PythonScript::beginStdoutRedirect() {
  if (!redirectStdOut())
    return;
  stdoutSave = PyDict_GetItemString(interp()->sysDict(), "stdout");
  Py_XINCREF(stdoutSave);
  stderrSave = PyDict_GetItemString(interp()->sysDict(), "stderr");
  Py_XINCREF(stderrSave);
  interp()->setQObject(this, "stdout", interp()->sysDict());
  interp()->setQObject(this, "stderr", interp()->sysDict());
}
Esempio n. 8
0
static double interp_cubic_coords(const double* src, double t)
{
    double ab = interp(src[0], src[2], t);
    double bc = interp(src[2], src[4], t);
    double cd = interp(src[4], src[6], t);
    double abc = interp(ab, bc, t);
    double bcd = interp(bc, cd, t);
    double abcd = interp(abc, bcd, t);
    return abcd;
}
Esempio n. 9
0
File: stable.c Progetto: cran/gnlm
static double romberg(double (*fcn)(double), double eps)
{
  int j,j1;
  double sum,errsum=0,x[16],fx[16];

  x[0]=1.0;
  for(j=0;j<16;j++){
    j1=j+1;
    fx[j]=evalfn(fcn,j1);
    if(j1>=5){
      interp(&x[j1-5],&fx[j1-5],&sum,&errsum);
      if(fabs(errsum)<eps*fabs(sum))return(sum);}
    x[j1]=x[j]/9.0;
    fx[j1]=fx[j];}
  sum=R_NaN;
  return(sum);}
Esempio n. 10
0
/// linear interpolation of the function v = f(x, y) at points xi, yi
/// assumes that x and y are strictly increasing
Vector interp(const Vector& x, const Vector& y, const Matrix& v, const Vector& xi, double yi, InterpMethod interpMethod, ExtrapMethod extrapMethod)
{
    unsigned M = x.size();

    Vector result(M);

    if (M != v.size1()) {
        return result;
    }

    for (unsigned i = 0; i < M; ++i) {
        result(i) = interp(x, y, v, xi(i), yi, interpMethod, extrapMethod);
    }

    return result;
}
Esempio n. 11
0
/// linear interpolation of the function v = f(x, y) at points xi, yi
/// assumes that x and y are strictly increasing
Vector interp(const Vector& x, const Vector& y, const Matrix& v, double xi, const Vector& yi, InterpMethod interpMethod, ExtrapMethod extrapMethod)
{
    unsigned N = y.size();

    Vector result(N);

    if (N != v.size2()) {
        return result;
    }

    for (unsigned j = 0; j < N; ++j) {
        result(j) = interp(x, y, v, xi, yi(j), interpMethod, extrapMethod);
    }

    return result;
}
Esempio n. 12
0
  /// linear interpolation of the function y = f(x) at points xi
  /// assumes that x is strictly increasing
  Vector interp(const Vector& x, const Vector& y, const Vector& xi, InterpMethod interpMethod, ExtrapMethod extrapMethod){
 
    unsigned N = x.size();

    Vector result(N);

    if (y.size() != N){
      return result;
    }

    for (unsigned i = 0; i < N; ++i){
      result(i) = interp(x, y, xi(i), interpMethod, extrapMethod);
    }

    return result;
  }
Esempio n. 13
0
/*
 * relative curvature -> RGB value
 */
color_t crv2color(double in)
{
    double h = crv_conv(in);

    if(crv_style == 0) // lines
    {
        if (  (0.101>h && h>0.09) || (0.201>h && h>0.19) ||
              (0.301>h && h>0.29) || (0.401>h && h>0.39) ||
              (0.501>h && h>0.49) || (0.601>h && h>0.59) ||
              (0.701>h && h>0.69) || (0.801>h && h>0.79) ||
              (0.901>h && h>0.89) )
            return mkcolor3(0,0,0);
       else
            return mkcolor3(0.9f, 0.9f, 0.9f);
    }
    else if (crv_style == 1) // colors
    {

        // B -> C -> G -> Y -> R
        color_t c[5] = { {0.0f, 0.0f, 0.85f, 1.0f},  // blue
                            {0.0f, 0.9f, 0.9f, 1.0f},   // cyan
                            {0.0f, 0.75f, 0.0f, 1.0f},  // green
                            {0.9f, 0.9f, 0.0f, 1.0f},   // yellow
                            {0.85f, 0.0f, 0.0f, 1.0f} };// red


        if (h>=crv_scale[4])
            return c[4];
        else if (h<=crv_scale[0])
            return c[0]; // blue
        else
        {
            int i;
            for(i=0;i<4;i++)
                if (crv_scale[i+1] >= h) break;
            double u = (h - crv_scale[i]) /(crv_scale[i+1] - crv_scale[i]);

            return interp(u, c[i], c[i+1]);
        }
    }
    else // gray scale
    {
        float u = (float) (0.9f-0.7f*h);
        // gray scale from 0.2 to 0.9
        return mkcolor3(u,u,u);
    }
}
Esempio n. 14
0
uchar key_getchar(chardevice_t* dev){

	uchar c;

	while(1){
		
		if (nextchar)	 {
			c = nextchar;
			nextchar=0;
			return c;
		}
		
		//get and interpret next keycode
		interp(key_getcode(NULL));
		
	}
}
Esempio n. 15
0
bool InterpolateConstrainedPath(Robot& robot,const vector<Config>& milestones,const vector<IKGoal>& ikGoals,vector<Config>& path,Real xtol)
{
  if(ikGoals.empty()) {
    path = milestones;
    return true;
  }
  RobotSmoothConstrainedInterpolator interp(robot,ikGoals);
  interp.ftol = xtol*gConstraintToleranceScale;
  interp.xtol = xtol;
  GeneralizedCubicBezierSpline spline;
  if(!MultiSmoothInterpolate(interp,milestones,spline)) return false;
  path.resize(spline.segments.size()+1);
  path[0] = spline.segments[0].x0;
  for(size_t i=0;i<spline.segments.size();i++)
    path[i+1] = spline.segments[i].x3;
  return true;
}
Esempio n. 16
0
TEST(RealVectorFilter, InterpEvenOdd) {
    double inputData[] = {1, 0, -1, -2, -3, -4, -5, -6, -7};
    int filterTaps[] = {1, 2, 3, 4, 5};
    double expectedData[] = {1, 2, 3, 4, 5, 0, -1, -2, -3, -6, -9, -6, -11, -16, -9, -16, -23, -12, -21, -30, -15, -26, -37, -18, -31, -44, -21, -28, -35};
    unsigned numElements = sizeof(inputData)/sizeof(inputData[0]);
	NimbleDSP::RealVector<double> buf(inputData, numElements);
    numElements = sizeof(filterTaps)/sizeof(filterTaps[0]);
    NimbleDSP::RealVector<double> filter(filterTaps, numElements);
    NimbleDSP::RealVector<double> input = buf;
    int rate = 3;
    
    interp(buf, rate, filter);
    EXPECT_EQ(input.size()*rate + filter.size() - rate, buf.size());
    for (unsigned i=0; i<buf.size(); i++) {
        EXPECT_EQ(expectedData[i], buf[i]);
    }
}
Esempio n. 17
0
TEST(RealVectorMethods, ComplexInterpEvenOdd) {
    std::complex<double> inputData[] = {std::complex<double>(1, 2), std::complex<double>(0, 3), std::complex<double>(-1, 4), std::complex<double>(-2, 5), std::complex<double>(-3, 6), std::complex<double>(-4, 7), std::complex<double>(-5, 8), std::complex<double>(-6, 9), std::complex<double>(-7, 10)};
    double filterTaps[] = {1, 2, 3, 4, 5};
    std::complex<double> expectedData[] = {std::complex<double>(1, 2), std::complex<double>(2, 4), std::complex<double>(3, 6), std::complex<double>(4, 11), std::complex<double>(5, 16), std::complex<double>(0, 9), std::complex<double>(-1, 16), std::complex<double>(-2, 23), std::complex<double>(-3, 12), std::complex<double>(-6, 21), std::complex<double>(-9, 30), std::complex<double>(-6, 15), std::complex<double>(-11, 26), std::complex<double>(-16, 37), std::complex<double>(-9, 18), std::complex<double>(-16, 31), std::complex<double>(-23, 44), std::complex<double>(-12, 21), std::complex<double>(-21, 36), std::complex<double>(-30, 51), std::complex<double>(-15, 24), std::complex<double>(-26, 41), std::complex<double>(-37, 58), std::complex<double>(-18, 27), std::complex<double>(-31, 46), std::complex<double>(-44, 65), std::complex<double>(-21, 30), std::complex<double>(-28, 40), std::complex<double>(-35, 50), std::complex<double>(0, 0), std::complex<double>(0, 0)};
    unsigned numElements = sizeof(inputData)/sizeof(inputData[0]);
	NimbleDSP::ComplexVector<double> buf(inputData, numElements);
    numElements = sizeof(filterTaps)/sizeof(filterTaps[0]);
    NimbleDSP::RealVector<double> filter(filterTaps, numElements);
    NimbleDSP::ComplexVector<double> input = buf;
    int rate = 3;
    
    interp(buf, rate, filter);
    EXPECT_EQ(input.size()*rate + filter.size() - rate, buf.size());
    for (unsigned i=0; i<buf.size(); i++) {
        EXPECT_EQ(expectedData[i], buf[i]);
    }
}
TEST(MonotoneCubicInterpolationTest, fitAkimaDataSet)
{
  std::vector<double> x(11);
  std::vector<double> y(11);

  x[0] = 0;
  y[0] = 10;
  x[1] = 2;
  y[1] = 10;
  x[2] = 3;
  y[2] = 10;
  x[3] = 5;
  y[3] = 10;
  x[4] = 6;
  y[4] = 10;
  x[5] = 8;
  y[5] = 10;
  x[6] = 9;
  y[6] = 10.5;
  x[7] = 11;
  y[7] = 15;
  x[8] = 12;
  y[8] = 50;
  x[9] = 14;
  y[9] = 60;
  x[10] = 15;
  y[10] = 85;

  MonotoneCubicInterpolation interp(x, y);

  EXPECT_NEAR(interp.sample(0.), 10., tol);
  EXPECT_NEAR(interp.sample(2.), 10., tol);
  EXPECT_NEAR(interp.sample(3.), 10., tol);
  EXPECT_NEAR(interp.sample(5.), 10., tol);
  EXPECT_NEAR(interp.sample(6.), 10., tol);
  EXPECT_NEAR(interp.sample(8.), 10., tol);
  EXPECT_NEAR(interp.sample(9.), 10.5, tol);
  EXPECT_NEAR(interp.sample(11.), 15., tol);
  EXPECT_NEAR(interp.sample(12.), 50., tol);
  EXPECT_NEAR(interp.sample(14.), 60., tol);
  EXPECT_NEAR(interp.sample(15.), 85., tol);

  for (double z = 0; z <= 15.; z += .1)
    EXPECT_GE(interp.sampleDerivative(z), -tol);
}
Esempio n. 19
0
int
main (int argc, char *argv[])
{
  context_init_default ();
  char *body = "";
  if (argc > 1)
    {
      if (strcmp (argv[1], "-e") == 0)
	{
	  body = argv[2];
	}
      else
	{
	  body = malloc (2 * 4096);
	  FILE *in_file;
	  if (!(in_file = fopen (argv[1], "r")))
	    {
	      perror ("Error opening input file");
	      exit (1);
	    }
	  fread (body, 2, 4096, in_file);
	  if (!feof (in_file))
	    {
	      fprintf (stderr,
		       "Error: file larger than current maximum size (8192).\n");
	      exit (1);
	    }
	}
      struct cons *result = interp (sexp_parse_str (&ctx->symbols, body));

      if (box_type (result) == &Q_z1)
	{
	  return *((char *) result->first.p);
	}
      else
	{
	  return 0;
	}
    }
  else
    {
      fprintf (stderr, "Interactive mode not implemented yet.\n");
      return 0;
    }
}
Esempio n. 20
0
T interpolate(It xbegin, It xend, It ybegin, It yend, T xvalue)
{

	auto upper = std::upper_bound(xbegin, xend, xvalue);
	if (upper == xbegin)
		return *ybegin;
	if (upper == xend)
		return *(yend - 1);
	auto lower = upper;
	std::advance(lower, -1);

	auto lowery = ybegin;
	std::advance(lowery, std::distance(xbegin, lower));
	auto uppery = ybegin;
	std::advance(uppery, std::distance(xbegin, upper));

	return interp( *lower, *upper, *lowery, *uppery, xvalue);
}
Esempio n. 21
0
uchar key_charkbhit(chardevice_t* dev){

	while(1){

		//if we have a character, then its ready
		if (nextchar){
			return 1;
		}
			
		//if we have a keycode interpret it
		if (key_kbhit(NULL))
			interp(key_getcode(NULL));
		else
			return 0;
		
	}

}
Esempio n. 22
0
void LocalClient::interpolate_positions() {
	if (peers.num_peers() <= 0) { 
		posupd_timer.begin();	// workaround, don't know what for though
		return; 
	}
	static const float HALF_GRANULARITY = POSITION_UPDATE_GRANULARITY_MS/2.0;
	const float DT_COEFF = HALF_GRANULARITY/16.666;

	//float local_DT_COEFF = time_since_last_posupd_ms()/16.666;

	auto it = peers.begin();
	while (it != peers.end()) {
		Car &car = it->second.car;
		interp(car, DT_COEFF);
		++it;
	}

}
Esempio n. 23
0
double test_interp(NFunction& f1, NFunction& f2) {
  Interp interp(f1.quad, f2.quad);

  StopWatch timer;
  timer.start();
  interp.apply(f1, f2);
  interp.apply(f1, f2);
  interp.apply(f1, f2);
  interp.apply(f1, f2);
  interp.apply(f1, f2);
  interp.apply(f1, f2);
  interp.apply(f1, f2);
  interp.apply(f1, f2);
  interp.apply(f1, f2);
  interp.apply(f1, f2);
  double time = timer.stop() / 10;

  return time;
}
Esempio n. 24
0
/// linear interpolation of the function v = f(x, y) at points xi, yi
/// assumes that x and y are strictly increasing
Matrix interp(const Vector& x, const Vector& y, const Matrix& v, const Vector& xi, const Vector& yi, InterpMethod interpMethod, ExtrapMethod extrapMethod)
{
    unsigned M = x.size();
    unsigned N = y.size();

    Matrix result(M, N);

    if ((M != v.size1()) || (N != v.size2())) {
        return result;
    }

    for (unsigned i = 0; i < M; ++i) {
        for (unsigned j = 0; j < N; ++j) {
            result(i,j) = interp(x, y, v, xi(i), yi(j), interpMethod, extrapMethod);
        }
    }

    return result;
}
Esempio n. 25
0
std::string matches_regex(cmdline_param const & param, char const * value,
        void /*precpp::RE*/ const * regex) {

    precondition(regex != nullptr);
    pcrecpp::RE const & re = *reinterpret_cast<pcrecpp::RE const *>(regex);
    if (!re.FullMatch(value)) {
        auto pat = re.pattern();
        pcrecpp::RE comment_pat("#\\s*(.*?)\n.*");
        string name;
        if (comment_pat.FullMatch(pat, &name)) {
            pat = "<" + name + ">";
        } else {
            pat = "\"" + pat + "\"";
        }
        return interp("Error with {1}=\"{2}\": expected a value matching regex {3}.",
               {param.get_preferred_name(), value, pat});
    }
    return "";
}
Esempio n. 26
0
void
prim_interp(PRIM_PROTOTYPE)
{
    struct inst *oper1, *oper2, *oper3, *rv;
    char buf[BUFFER_LEN];

    CHECKOP(3);
    oper3 = POP();    /* string -- top stack argument */
    oper2 = POP();    /* dbref  --  trigger */
    oper1 = POP();    /* dbref  --  Program to run */

    if (!valid_object(oper1) || Typeof(oper1->data.objref) != TYPE_PROGRAM)
        abort_interp("Bad program reference. (1)");
    if (!valid_object(oper2))
        abort_interp("Bad object. (2)");
    if ((mlev < 3) && !permissions(ProgUID, oper2->data.objref))
	abort_interp("Permission denied.");
    if (fr->level > 8)
        abort_interp("Interp call loops not allowed.");
    CHECKREMOTE(oper2->data.objref);

    strcpy(buf, match_args);
    strcpy(match_args, oper3->data.string? oper3->data.string->data : "");
    rv = interp(player, DBFETCH(player)->location, oper1->data.objref,
			oper2->data.objref, PREEMPT, STD_HARDUID, 1);
    strcpy(match_args, buf);

    CLEAR(oper3);
    CLEAR(oper2);
    CLEAR(oper1);

    if (rv) {
	if (rv->type < PROG_STRING) {
	    push(arg, top, rv->type, MIPSCAST (&rv->data.number));
	} else {
	    push(arg, top, rv->type, MIPSCAST (rv->data.string));
	}
    } else {
        PushNullStr;
    }

}
Esempio n. 27
0
bool InterpolateAndTimeOptimize(const vector<Config>& configs,
				GeodesicManifold* space,
				VectorFieldFunction* constraint,
				Real constraintTolerance,
				const Vector& vmin,const Vector& vmax,
				const Vector& amin,const Vector& amax,
				TimeScaledBezierCurve& output)
{
  if(constraint) {
    SmoothConstrainedInterpolator interp(space,constraint);
    interp.xtol = constraintTolerance;
    if(!MultiSmoothInterpolate(interp,configs,output.path)) return false;
  }
  else {
    GeneralizedCubicBezierSpline path;
    SplineInterpolate(configs,path.segments,space);
    path.durations.resize(path.segments.size());
    for(size_t i=0;i+1<path.segments.size();i++)
      path.durations[i] = 1.0/path.durations.size();
    //treat constraintTolerance as a resolution, discretize the curves into
    //n pieces
    int n=(int)Ceil(1.0/constraintTolerance);
    output.path.segments.resize(n);
    output.path.durations.resize(n);
    Config xp,vp,xn,vn;
    path.Eval(0,xp);
    path.Deriv(0,vp);
    for(int i=0;i<n;i++) {
      Real u2=Real(i+1)/Real(n);
      path.Eval(u2,xn);
      path.Deriv(u2,vn);
      output.path.segments[i].x0 = xp;
      output.path.segments[i].x3 = xn;
      output.path.segments[i].SetNaturalTangents(vp,vn);
      output.path.durations[i] = 1.0/Real(n);
    }
    swap(xp,xn);
    swap(vp,vn);
  }
  if(!output.OptimizeTimeScaling(vmin,vmax,amin,amax)) return false;
  return true;
}
    InterpolatorVec ReadInterpolatedLimits(const std::string& input_dir_name, Range& mass_range, Units units)
    {
        const auto& file_names = GetOrderedFileList(input_dir_name, ".*\\.root");
        std::vector<std::vector<double>> limits(all_limit_quantiles.size());
        std::set<double> masses;
        const double units_factor = GetUnitsFactor(units);

        if(!file_names.size())
            throw exception("No input files are found.");

        for(const auto& file_entry : file_names) {
            const std::string& file_name = file_entry.second;
            const double mass = file_entry.first;
            std::cout << "Reading " << file_name << std::endl;
            if(masses.count(mass))
                throw exception("More than one file with for the mass point = %1%") % mass;

            masses.insert(mass);
            std::shared_ptr<TFile> file(new TFile(file_name.c_str(), "READ"));
            std::shared_ptr<TTree> tree(dynamic_cast<TTree*>(file->Get("limit")));
            double limit;
            float quantileExpected;
            tree->SetBranchAddress("limit", &limit);
            tree->SetBranchAddress("quantileExpected", &quantileExpected);
            for(Long64_t n = 0; n < tree->GetEntries(); ++n) {
                tree->GetEntry(n);
                const size_t quantile_id = GetQuantileId(quantileExpected);
                limits.at(quantile_id).push_back(limit * units_factor);
            }
        }

        const std::vector<double> mass_vec(masses.begin(), masses.end());
        mass_range = Range(mass_vec.front(), mass_vec.back());
        InterpolatorVec interps;
        for(size_t n = 0; n < limits.size(); ++n) {
            if(limits[n].size() != masses.size())
                throw exception("Inconsistent input limits.");
            InterpolatorPtr interp(new ROOT::Math::Interpolator(mass_vec, limits[n], ROOT::Math::Interpolation::kCSPLINE));
            interps.push_back(interp);
        }
        return interps;
    }
Esempio n. 29
0
int main( int argc, char **argv ) {

  llvm::llvm_shutdown_obj shutdownTrigger;

  //llvm::sys::PrintStackTraceOnErrorSignal();
  //llvm::PrettyStackTraceProgram X(argc, argv);

  // Set up the interpreter
  cling::Interpreter interp(argc, argv);
  if (interp.getOptions().Help) {
    return 0;
  }

  clang::CompilerInstance* CI = interp.getCI();
  interp.AddIncludePath(".");
  
  for (size_t I = 0, N = interp.getOptions().LibsToLoad.size(); I < N; ++I) {
    interp.loadFile(interp.getOptions().LibsToLoad[I]);
  }

   bool ret = true;
   const std::vector<clang::FrontendInputFile>& Inputs
     = CI->getInvocation().getFrontendOpts().Inputs;

   // Interactive means no input (or one input that's "-")
   bool Interactive = Inputs.empty() || (Inputs.size() == 1 
                                         && Inputs[0].File == "-");

   cling::UserInterface ui(interp);
   // If we are not interactive we're supposed to parse files
   if (!Interactive) {
     for (size_t I = 0, N = Inputs.size(); I < N; ++I) {
       ret = ui.getMetaProcessor()->executeFile(Inputs[I].File);
     }
   }
   else {
      cling::UserInterface ui(interp);
      ui.runInteractively(interp.getOptions().NoLogo);
   }

   return ret ? 0 : 1;
}
Esempio n. 30
0
int main(int argc, char** argv) {

	for(int i = 0; i < 32; i++) {
		registers[i] = getV<VW>();
	}
	
	loop_body();
	
	double acc = 0;
	for(int i = 0; i < ROUNDS; i++) {
		for(int j = 0; j < VL; j++) {
			interp();
			acc += registers[ret_val][0];
		}
	}

	printf("Result: %f\n", acc / (ROUNDS * VW * VL));

	return 0;
}