示例#1
0
int main(void) {
	double a, b, c, x;
	
	a = getDouble('a');
	b = getDouble('b');
	c = getDouble('c');
	
	x = quadratic(a, b, c);
	
	printf("One x-value for this equation is %.3f\n", x);
	
	a = getDouble('a');
	b = getDouble('b');
	c = getDouble('c');
	
	x = quadratic(a, b, c);
	
	printf("One x-value for this equation is %.3f\n", x);
	
	a = getDouble('a');
	b = getDouble('b');
	c = getDouble('c');
	
	x = quadratic(a, b, c);
	
	printf("One x-value for this equation is %.3f\n", x);
	
	return 0;
}
示例#2
0
int consecutive_length(int a, int b)
{
    int i = 0;
    
    do
     {
         quadratic(1, a, b, i);
         
         i++;
     }
    while(isPrime(quadratic(1, a, b, i)));
    
    return i;
}
示例#3
0
collision point_collide_edge(vec3 p, vec3 v, vec3 e0, vec3 e1) {

  vec3 x0 = vec3_sub(e0, p);
  vec3 x1 = vec3_sub(e1, p);
  
  vec3 d = vec3_sub(x1, x0);  
  float dlen = vec3_length_sqrd(d);
  float vlen = vec3_length_sqrd(v);
  float xlen = vec3_length_sqrd(x0);
  
  float A = dlen * -vlen + vec3_dot(d, v) * vec3_dot(d, v);
  float B = dlen * 2 * vec3_dot(v, x0) - 2 * vec3_dot(d, v) * vec3_dot(d, x0);
  float C = dlen * - xlen + vec3_dot(d, x0) * vec3_dot(d, x0);
  
  float t0, t1, t;
  if (!quadratic(A, B, C, &t0, &t1)) { return collision_none(); }
  
  if (between_or(t0, 0, 1) && between_or(t1, 0, 1)) { t = min(t0, t1); }
  else if (between_or(t0, 0, 1)) { t = t0; }
  else if (between_or(t1, 0, 1)) { t = t1; } 
  else { return collision_none(); }
  
  float range = (vec3_dot(d, v) * t - vec3_dot(d, x0)) / dlen;
  
  if (!between_or(range, 0, 1)) {
    return collision_none();
  } else {
    vec3 spoint = vec3_add(e0, vec3_mul(d, range));
    return collision_new(t, spoint, vec3_normalize(vec3_sub(p, spoint)));
  }

}
示例#4
0
collision sphere_collide_edge(sphere s, vec3 v, vec3 e0, vec3 e1) {
  
  //Wif (unlikely(!line_outside_sphere(s, e0, e1))) { error("Collision Sphere Inside Mesh Edge!"); }
  
  vec3 x0 = vec3_sub(e0, s.center);
  vec3 x1 = vec3_sub(e1, s.center);
  
  vec3 d = vec3_sub(x1, x0);  
  float dlen = vec3_length_sqrd(d);
  float vlen = vec3_length_sqrd(v);
  float xlen = vec3_length_sqrd(x0);
  
  float A = dlen * -vlen + vec3_dot(d, v) * vec3_dot(d, v);
  float B = dlen * 2 * vec3_dot(v, x0) - 2 * vec3_dot(d, v) * vec3_dot(d, x0);
  float C = dlen * (s.radius * s.radius - xlen) + vec3_dot(d, x0) * vec3_dot(d, x0);
  
  float t0, t1, t;
  if (!quadratic(A, B, C, &t0, &t1)) { return collision_none(); }
  
  if (between_or(t0, 0, 1) && between_or(t1, 0, 1)) { t = min(t0, t1); }
  else if (between_or(t0, 0, 1)) { t = t0; }
  else if (between_or(t1, 0, 1)) { t = t1; } 
  else { return collision_none(); }
  
  float range = (vec3_dot(d, v) * t - vec3_dot(d, x0)) / dlen;
  
  if (!between_or(range, 0, 1)) {
    return collision_none();
  } else {
    vec3 spoint = vec3_add(e0, vec3_mul(d, range));
    return collision_new(t, spoint, vec3_normalize(vec3_sub(s.center, spoint)));
  }
  
}
示例#5
0
文件: twocirc.c 项目: aahud/harvey
static int
twocircles(double m, double p, double p1, double p2, double *x, double *y)
{
	double a;	/* center of meridian circle, a>0 */
	double b;	/* center of parallel circle, b>0 */
	double t,bb;
	if(m > 0) {
		twocircles(-m,p,p1,p2,x,y);
		*x = -*x;
	} else if(p < 0) {
		twocircles(m,-p,p1,-p2,x,y);
		*y = -*y;
	} else if(p < .01) {
		*x = m;
		t = m/p1;
		*y = p + (p2-p)*t*t;
	} else if(m > -.01) {
		*y = p;
		*x = m - m*p*p;
	} else {
		b = p>=1? 1: p>.99? 0.5*(p+1 + p1*p1/(1-p)):
			0.5*(p*p-p1*p1-p2*p2)/(p-p2);
		a = .5*(m - 1/m);
		t = m*m-p*p+2*(b*p-a*m);
		bb = b*b;
		*x = quadratic(1+a*a/bb, -2*a + a*t/bb,
			t*t/(4*bb) - m*m + 2*a*m);
		*y = (*x*a+t/2)/b;
	}
	return 1;
}		
示例#6
0
	int LineArcIntof(const Span& line, const Span& arc, Point& p0, Point& p1, double t[4]) {
		// inters of line arc
		// solving	x = x0 + dx * t			x = y0 + dy * t
		//			x = xc + R * cos(a)		y = yc + R * sin(a)		for t
		// gives :-  t² (dx² + dy²) + 2t(dx*dx0 + dy*dy0) + (x0-xc)² + (y0-yc)² - R² = 0
		int nRoots;
		Vector2d v0(arc.pc, line.p0);
		Vector2d v1(line.p0, line.p1);
		double s = v1.magnitudesqd();

		p0.ok = p1.ok = false;
		if((nRoots = quadratic(s, 2 * (v0 * v1), v0.magnitudesqd() - arc.radius * arc.radius, t[0], t[1])) != 0) {
			double toler = geoff_geometry::TOLERANCE / sqrt(s);							// calc a parametric tolerance
			if(t[0] > -toler && t[0] < 1 + toler) {
				p0 = v1 * t[0] + line.p0;
				p0.ok = arc.OnSpan(p0, &t[2]);
			}
			if(nRoots == 2) {
				if(t[1] > -toler && t[1] < 1 + toler) {
					p1 = v1 * t[1] + line.p0;
					p1.ok = arc.OnSpan(p1, &t[3]);
				}
			}
			if(!p0.ok && p1.ok) {
				p0 = p1;
				p1.ok = false;
			}
			nRoots = (int)p0.ok + (int)p1.ok;
		}
		return nRoots;
	}
示例#7
0
void Transform::lerp(const Transform& transform, float t, int spin)
{
    if(transform.curve_type == "quadratic") {
        t = quadratic(0, c1, 1, t);
    } else if(transform.curve_type == "cubic") {
        t = cubic(0, c1, c2, 1, t);
    } else if(transform.curve_type == "quartic") {
        t = quartic(0, c1, c2, c3, 1, t);
    } else if(transform.curve_type == "quintic") {
        t = quintic(0, c1, c2, c3, c4, 1, t);
    }
    
    x = lerp(x, transform.x, t);
    y = lerp(y, transform.y, t);
    alpha = lerp(alpha, transform.alpha, t);
    
    // 'spin' is based on what you are coming from (key1)
    if(spin != 0)
    {
        if(spin > 0 && angle > transform.angle)
            angle = lerp(angle, transform.angle + 360, t);
        else if(spin < 0 && angle < transform.angle)
            angle = lerp(angle, transform.angle - 360, t);
        else
            angle = lerp(angle, transform.angle, t);
    }
    if(angle > 360) {
        angle = angle - 360;
    }
    
    scale_x = lerp(scale_x, transform.scale_x, t);
    scale_y = lerp(scale_y, transform.scale_y, t);
}
示例#8
0
void main(int argc, char *argv[])
{
  gq_args param;
  macopt_args a ;
  double *x ;
  int n , status ;
  double epsilon=0.001 ;

  /* Load up the parameters of the function that you want to optimize */
  printf("============================================================\n");
  printf("= Demonstration program for macoptIIc                      =\n");
  printf("= Solves A x = b by minimizing the function 1/2 xAx - bx   =\n");
  printf("= A must be positive definite (e.g. 2 1 1 2)               =\n");
  printf("\n  Dimension of A (eg 2)?\n");
  inputi(&(param.n));
  n=param.n; 
  param.A=dmatrix(1,n,1,n);
  param.b=dvector(1,n);
  /* the metric! : */
  a.m=dvector(1,n);
  x=dvector(1,n);
  typeindmatrix(param.A,1,n,1,n);
  printf("  b vector?\n");
  typeindvector(param.b,1,n);
  printf("  Initial condition x?\n");
  typeindvector(x,1,n);
  printf("  Metric m?\n");
  typeindvector(a.m,1,n);

  /* Check that the gradient_function is the gradient of the function  */
  /* You don't have to do this, but it is a good idea when debugging ! */
  maccheckgrad (  x , param.n , epsilon , 
		quadratic , (void *)(&param) , 
		vgrad_quadratic , (void *)(&param) , 
		0
		) ;

  /* initialize the arguments of the optimizer */
  macopt_defaults ( &a ) ; 

  /* modify macopt parameters from their default values */
  a.do_newitfunc = 1 ; /* this means that I want to have an auxiliary
			  subroutine executed each iteration of the 
			  optimization */
  a.newitfunc = &state_printer ; /* setting the function to be performed to
				  T_return */
  a.newitfuncarg = (void *)(&param) ;
  a.metric = 1 ; /* we have put in the metric and want to use it */
  a.verbose = 2 ; /* verbosity */
  a.rich = 0 ; /* verbosity */
  
  /* Do an optimization */
  status = macoptIIc ( x , param.n , 
	    vgrad_quadratic , (void *)(&param) , &a
	    ) ;

  printf("(%d) Solution:\n", status);
  quadratic(x,&param);
}
示例#9
0
int main(void)
{
	double x = 2.0, y = -3.0, z = 1.0;

	double result = quadratic(x, y, z);

	print_number(result);
}
示例#10
0
/*
====================
Tube::intersect
	Computes intersection between the Tube and the ray, and returns itself if 
	it is hit or NULL if it is not along with the point of intersection
====================
*/
SceneObject* Tube::intersect(Ray* r, Point &intersect) {
	Vector dist = this->origin - r->start;

	//norm(dist);
	//norm(r->dir);

	//double a = dot3(r->dir,r->dir);
	//double b = 2 * dot3(r->start - this->origin,r->dir);
	//double c = dot3(r->start - this->origin,r->start - this->origin) - this->radius * this->radius;

	//double disc = discrim(a,b,c);

	////Parallel to tube, does not intersect
	//if(dot3(r->dir,this->up) == 0) return false;
	//else if(disc >= 0) { //Find closest intersection
	//	double discSqrt = sqrt(disc);
	//	double quad;
	//	if (b < 0)	quad = (-b - discSqrt)/2.f;
	//	else quad = (-b + discSqrt)/2.f;

	//	double t0 = quad/a;
	//	double t1 = c/quad;
	//	if(t0 > t1) swap(t0,t1);

	//	double t;
	//	if(t0 < 0 && t1 < 0) return false;
	//	if(t0 < 0) t = t1;
	//	else t = t0;

	//	intersect = r->start + t * r->dir;
	//	return this;
	//}
	//return NULL;
	
	/* 
	Ray: O + V * t
	Cylinder: [this->origin,this->up,this->radius]
	A = this->origin
	O = r->start
	V = r->dir
	*/

	Vector AB = this->up;
	Vector AO = r->start - this->origin;
	Vector AOxAB = AO.cross(AB);
	Vector VxAB = r->dir.cross(AB);
	double ab2 = AB.dot(AB);

	double a = VxAB.dot(VxAB);
	double b = 2 * VxAB.dot(AOxAB);
	double c = AOxAB.dot(AOxAB) - this->radius*this->radius * ab2;

	double t = quadratic(a,b,c);
	if(t < 0) return NULL;

	intersect = r->start + t * r->dir;
	return this;
}
示例#11
0
文件: test2.cpp 项目: nateware/cpp
int doit(void) {
  float a=1.0, b=-6.0, c=8.0, r1, r2;
  if (quadratic(a, b, c, &r1, &r2)) {
    printf("The two roots are %f and %f\n", r1, r2);
  }
  else {
    printf("No real roots exist");
  }
  return 0;
}
示例#12
0
int main()
{
    const int n = 3;
    double coefficients_equation[n];
    double root_equation[n];
    printf("Enter values a, b, c\n");
    scanf( "%lg%lg%lg" , &coefficients_equation[2], &coefficients_equation[1], &coefficients_equation[0] );
    quadratic(coefficients_equation, root_equation);
    print_roots(coefficients_equation, root_equation);
    return 0;
}
示例#13
0
int main (int argc, char *argv[]){
    if(argc == 2){
        int argi = atoi(argv[1]);
        printf("\n%d\n", quadratic(argi));
        return 0;
    }
    else{
        printf("\nUsage: quadratic <integer>\n");
        return 1;
    }
}
示例#14
0
文件: quadt.c 项目: vni/programming
int main() {
	double a, b, c, root1, root2;

	printf("Enter a, b, c: ");
	scanf("%lf %lf %lf", &a, &b, &c);

	if (quadratic(a, b, c, &root1, &root2))
		printf("roots: %.10g %.10g\n", root1, root2);
	else
		printf("No real roots\n");
	return 0;
}
示例#15
0
文件: complx.cpp 项目: Quna/mspdev
int main () {
    
    dcomplex a(2, 3);
    dcomplex b(4, 5);
    dcomplex c(6, 7);
    
    std::pair<dcomplex, dcomplex> ans = quadratic(a, b, c);

    std::cout << "Roots are " << ans.first << " and "
              << ans.second   << std::endl;

    return 0;
}
示例#16
0
int main()
{
	double a=0,b=5,c=4,x1,x2;
	int check;
	check=quadratic(a,b,c,&x1,&x2);
	if(check==0)
		printf("Error\n");
	else if(check==1)
		printf("1 answer: %.6lf (DBG %.6lf)\n",x1,x2);
	else
		printf("2 answers: %.6lf and %.6lf\n",x1,x2);
	return 0;
}
示例#17
0
bool Sphere::intersect_p(const Ray& r) const
{
	// Transform Ray to object space
	Ray ray;
	(*world_to_object)(r, &ray);

	// Compute quadratic sphere coefficients
	float phi;
	Point phit;
	float A = ray.d.x * ray.d.x + ray.d.y * ray.d.y + ray.d.z * ray.d.z;
	float B = 2 * (ray.d.x * ray.o.x + ray.d.y * ray.o.y + ray.d.z * ray.o.z);
	float C = ray.o.x*ray.o.x + ray.o.y*ray.o.y + ray.o.z*ray.o.z - _radius*_radius;

	// Solve quadratic equation for t values
	float t0, t1;
	if (!quadratic(A, B, C, &t0, &t1))
		return false;

	// Compute intersection distance along ray
	if (t0 > ray.maxt || t1 < ray.mint)
		return false;
	float thit = t0;
	if (t0 < ray.mint) {
		thit = t1;
		if (thit > ray.maxt) return false;
	}

	// Compute sphere hit position and phi
	phit = ray(thit);
	if (phit.x == 0.f && phit.y == 0.f) phit.x = 1e-5f * _radius;
	phi = atan2f(phit.y, phit.x);
	if (phi < 0.) phi += 2.f * M_PI;

	// Test sphere intersection against clipping parameters
	if ((_z_min > -_radius && phit.z < _z_min) ||
		(_z_max <  _radius && phit.z > _z_max) || phi > _phi_max) { // clip t0(t1)
		if (thit == t1) return false;
		if (t1 > ray.maxt) return false;
		thit = t1;
		// Compute sphere hit position and phi
		phit = ray(thit);
		if (phit.x == 0.f && phit.y == 0.f) phit.x = 1e-5f * _radius;
		phi = atan2f(phit.y, phit.x);
		if (phi < 0.) phi += 2.f * M_PI;
		if ((_z_min > -_radius && phit.z < _z_min) ||
			(_z_max <  _radius && phit.z > _z_max) || phi > _phi_max)	// clip t1
			return false;
	}

	return true;
}
示例#18
0
int main()
{
	int max_so_far = 0;
	for(int a=-999; a < 1000; a++) {
		for(int b=-999; b < 1000; b++) {
			int n = 0;
			for(; is_prime_cache(quadratic(a,b,n)); n++);
			if (n > max_so_far) {
				std::cout << a << ", " << b << ", " << n << std::endl;
				max_so_far = n;
			}
		}
	}
	std::cout << max_so_far << std::endl;
	return 0;
}
示例#19
0
文件: ambcomp.c 项目: NREL/Radiance
/* Compute anisotropic radii and eigenvector directions */
static void
eigenvectors(FVECT uv[2], float ra[2], FVECT hessian[3])
{
	double	hess2[2][2];
	FVECT	a, b;
	double	evalue[2], slope1, xmag1;
	int	i;
					/* project Hessian to sample plane */
	for (i = 3; i--; ) {
		a[i] = DOT(hessian[i], uv[0]);
		b[i] = DOT(hessian[i], uv[1]);
	}
	hess2[0][0] = DOT(uv[0], a);
	hess2[0][1] = DOT(uv[0], b);
	hess2[1][0] = DOT(uv[1], a);
	hess2[1][1] = DOT(uv[1], b);
					/* compute eigenvalue(s) */
	i = quadratic(evalue, 1.0, -hess2[0][0]-hess2[1][1],
			hess2[0][0]*hess2[1][1]-hess2[0][1]*hess2[1][0]);
	if (i == 1)			/* double-root (circle) */
		evalue[1] = evalue[0];
	if (!i || ((evalue[0] = fabs(evalue[0])) <= FTINY*FTINY) |
			((evalue[1] = fabs(evalue[1])) <= FTINY*FTINY) ) {
		ra[0] = ra[1] = maxarad;
		return;
	}
	if (evalue[0] > evalue[1]) {
		ra[0] = sqrt(sqrt(4.0/evalue[0]));
		ra[1] = sqrt(sqrt(4.0/evalue[1]));
		slope1 = evalue[1];
	} else {
		ra[0] = sqrt(sqrt(4.0/evalue[1]));
		ra[1] = sqrt(sqrt(4.0/evalue[0]));
		slope1 = evalue[0];
	}
					/* compute unit eigenvectors */
	if (fabs(hess2[0][1]) <= FTINY)
		return;			/* uv OK as is */
	slope1 = (slope1 - hess2[0][0]) / hess2[0][1];
	xmag1 = sqrt(1.0/(1.0 + slope1*slope1));
	for (i = 3; i--; ) {
		b[i] = xmag1*uv[0][i] + slope1*xmag1*uv[1][i];
		a[i] = slope1*xmag1*uv[0][i] - xmag1*uv[1][i];
	}
	VCOPY(uv[0], a);
	VCOPY(uv[1], b);
}
示例#20
0
int
Flash_verify(unsigned char *data, int length, unsigned char signature[37], Flash_Complete_Key PK)
{
	int i;
	unsigned char in[26];
	unsigned char out[26];
	format_message2(data, length, in);
	quadratic(out,signature,PK->Q,PK->L,PK->C,PK->M);	
	for(i=0;i<26;i++)
	{
		if(in[i]!=out[i])
		{
			return 0;
		}
	}
	return 1;
}
示例#21
0
collision point_collide_sphere(vec3 p, vec3 v, sphere s) {
  
  vec3  o = vec3_sub(p, s.center);
  float A = vec3_dot(v, v);
  float B = 2 * vec3_dot(v, o);
  float C = vec3_dot(o, o) - (s.radius * s.radius);
  
  float t0, t1, t;
  if (!quadratic(A, B, C, &t0, &t1)) { return collision_none(); }
  
  if (between_or(t0, 0, 1) && between_or(t1, 0, 1)) { t = min(t0, t1); }
  else if (between_or(t0, 0, 1)) { t = t0; }
  else if (between_or(t1, 0, 1)) { t = t1; } 
  else { return collision_none(); }
  
  return collision_new(t, p, vec3_normalize(vec3_sub(p, s.center)));
  
}
示例#22
0
collision sphere_collide_point(sphere s, vec3 v, vec3 p) {

  //if (unlikely(!point_outside_sphere(s, p))) { error("Collision Sphere Inside Mesh Vertex!"); }

  vec3  o = vec3_sub(s.center, p);
  float A = vec3_dot(v, v);
  float B = 2 * vec3_dot(v, o);
  float C = vec3_dot(o, o) - (s.radius * s.radius);
  
  float t0, t1, t;
  if (!quadratic(A, B, C, &t0, &t1)) { return collision_none(); }
  
  if (between_or(t0, 0, 1) && between_or(t1, 0, 1)) { t = min(t0, t1); }
  else if (between_or(t0, 0, 1)) { t = t0; }
  else if (between_or(t1, 0, 1)) { t = t1; } 
  else { return collision_none(); }
  
  return collision_new(t, p, vec3_normalize(vec3_sub(s.center, p)));
  
}
int main (void)
{
	int a, b, c;

	float quadratic (int a, int b, int c);

	printf ("This is a quadratic equation\n");
	printf ("ax^2 + bx + c = 0\n");
	printf ("What is the value of a? \n");
	scanf ("%i", &a);
	printf ("What is the value of b? \n");
	scanf ("%i", &b);
	printf ("What is the value of c? \n");
	scanf ("%i", &c);

	quadratic (a,b,c);

	printf ("x1 = %f\n", gX1);
	printf ("x2 = %f\n", gX2);

	return 0;
}
示例#24
0
int main()
{

    double a = POISON, b = POISON, c = POISON;
    double x1 = POISON, x2 = POISON;

    printf("This program solves quadratic equation.");
    printf("Write coefficients of quadratic equation(e.g a = 123 b = 321 c = 0.1)\n");

    while (!scanf("a = %lg b = %lg c = %lg", &a, &b, &c))
    {

        while (getchar() != '\n');
        printf("Write correct!\n");
    }


    int count_roots = quadratic(a, b, c, &x1, &x2);

    switch(count_roots)
    {

        case INF_ROOTS:
            printf("All real numbers");
            break;
        case 0:
            printf("No roots");
            break;
        case 1:
            printf("Count of roots: %d\nx = %lg", count_roots, x1);
            break;
        case 2:
            printf("Count of roots: %d\nx1 = %lg x2 = %lg", count_roots, x1, x2);
            break;

    }

    return 0;
}
示例#25
0
roots intersection_with_ray(sphere s, ray r)
{
	// We need r in sphere-coordinates

	ray r_sphere_coordinates;
	matrix s_transform_inverse = inverse_of_matrix(s.transform);
	r_sphere_coordinates.point     = transform_point(s_transform_inverse, r.point);
	r_sphere_coordinates.direction = transform_ray(s_transform_inverse, r.direction);

	vector point_minus_center = subtract_vectors(r_sphere_coordinates.point, s.center);

	float polynomials[3];

	polynomials[2] = square_of_magnitude_of_vector(r_sphere_coordinates.direction);
	polynomials[1] = 2 * dot_product(point_minus_center, r_sphere_coordinates.direction);
	polynomials[0] = square_of_magnitude_of_vector(point_minus_center) - s.radius * s.radius;

	roots quad_roots;

	quad_roots = quadratic(polynomials[2], polynomials[1], polynomials[0]);

	return quad_roots;
}
示例#26
0
collision sphere_collide_sphere(sphere s, vec3 v, sphere s0) {

  //if (unlikely(!sphere_outside_sphere(s, s0))) { error("Collision Sphere Inside Sphere!"); }

  vec3  o = vec3_sub(s.center, s0.center);
  float A = vec3_dot(v, v);
  float B = 2 * vec3_dot(v, o);
  float C = vec3_dot(o, o) - ((s.radius + s0.radius) * (s.radius + s0.radius));
  
  float t0, t1, t;
  if (!quadratic(A, B, C, &t0, &t1)) { return collision_none(); }
  
  if (between_or(t0, 0, 1) && between_or(t1, 0, 1)) { t = min(t0, t1); }
  else if (between_or(t0, 0, 1)) { t = t0; }
  else if (between_or(t1, 0, 1)) { t = t1; } 
  else { return collision_none(); }
  
  vec3 proj = vec3_add(s.center, vec3_mul(v, t));
  vec3 twrd = vec3_normalize(vec3_sub(s0.center, proj));
  vec3 p = vec3_add(proj, vec3_mul(twrd, s.radius));
  
  return collision_new(t, p, vec3_normalize(vec3_sub(s.center, p)));

}
示例#27
0
void estimate(const size_t order, const Points &X, const HistogramY &Y,
              const size_t i_min, const size_t i_max, const size_t p_min,
              const size_t p_max, bool haveGap, double &out_bg0,
              double &out_bg1, double &out_bg2, double &out_chisq_red) {
  // Validate input
  if (order > 2)
    throw std::runtime_error("can only estimate up to order=2");
  if (i_min >= i_max) {
    std::stringstream err;
    err << "i_min (" << i_min << ")cannot be larger or equal to i_max ("
        << i_max << ")";
    throw std::runtime_error(err.str());
  }
  if (i_max > X.size()) {
    std::stringstream err;
    err << "i_max  (" << i_max << ") cannot be larger or equal to size of X "
        << X.size() << ")";
    throw std::runtime_error(err.str());
  }
  if (haveGap && p_min >= p_max)
    throw std::runtime_error("p_min cannot larger or equal to p_max");
  // ignore when p-range is outside of i-range

  // set all output parameters to zero
  out_bg0 = 0.;
  out_bg1 = 0.;
  out_bg2 = 0.;
  out_chisq_red = INVALID_CHISQ;

  // accumulate sum
  double sum = 0.0;
  double sumX = 0.0;
  double sumY = 0.0;
  double sumX2 = 0.0;
  double sumXY = 0.0;
  double sumX2Y = 0.0;
  double sumX3 = 0.0;
  double sumX4 = 0.0;
  for (size_t i = i_min; i < i_max; ++i) {
    if (haveGap && i >= p_min && i < p_max)
      continue;
    sum += 1.0;
    sumX += X[i];
    sumX2 += X[i] * X[i];
    sumY += Y[i];
    sumXY += X[i] * Y[i];
    sumX2Y += X[i] * X[i] * Y[i];
    sumX3 += X[i] * X[i] * X[i];
    sumX4 += X[i] * X[i] * X[i] * X[i];
  }

  if (sum == 0.) {
    return;
  }

  // Estimate flat
  double bg0_flat = 0.;
  calcFlatParameters(sum, sumY, bg0_flat);

  // Estimate linear
  double bg0_linear = 0.;
  double bg1_linear = 0.;
  calcLinearParameters(sum, sumX, sumY, sumXY, sumX2, bg0_linear, bg1_linear);

  // Estimate quadratic
  double bg0_quadratic = 0.;
  double bg1_quadratic = 0.;
  double bg2_quadratic = 0.;
  calcQuadraticParameters(sum, sumX, sumY, sumXY, sumX2, sumX2Y, sumX3, sumX4,
                          bg0_quadratic, bg1_quadratic, bg2_quadratic);

  // Setup to calculate the residuals
  double chisq_flat = 0.;
  double chisq_linear = 0.;
  double chisq_quadratic = 0.;
  auto residual_flat = constant(bg0_flat);
  auto residual_linear = linear(bg0_linear, bg1_linear);
  auto residual_quadratic =
      quadratic(bg0_quadratic, bg1_quadratic, bg2_quadratic);
  double num_points = 0.;

  // calculate the chisq - not normalized by the number of points
  for (size_t i = i_min; i < i_max; ++i) {
    if (haveGap && i >= p_min && i < p_max)
      continue;

    num_points += 1.;
    chisq_flat += residual_flat(X[i], Y[i]);
    chisq_linear += residual_linear(X[i], Y[i]);
    chisq_quadratic += residual_quadratic(X[i], Y[i]);
  }

  // convert to <reduced chisq> = chisq / (<number points> - <number
  // parameters>)
  chisq_flat = chisq_flat / (num_points - 1.);
  chisq_linear = chisq_linear / (num_points - 2.);
  chisq_quadratic = chisq_quadratic / (num_points - 3.);

  if (order < 2) {
    chisq_quadratic = BAD_CHISQ;
    if (order < 1) {
      chisq_linear = BAD_CHISQ;
    }
  }

  // choose the right background function to return
  // this is written that lower order polynomial wins in the case of a tie
  if ((chisq_flat <= chisq_linear) && (chisq_flat <= chisq_quadratic)) {
    out_bg0 = bg0_flat;
    out_chisq_red = chisq_flat;
  } else if ((chisq_linear <= chisq_flat) &&
             (chisq_linear <= chisq_quadratic)) {
    out_bg0 = bg0_linear;
    out_bg1 = bg1_linear;
    out_chisq_red = chisq_linear;
  } else {
    out_bg0 = bg0_quadratic;
    out_bg1 = bg1_quadratic;
    out_bg2 = bg2_quadratic;
    out_chisq_red = chisq_quadratic;
  }
}
示例#28
0
    void TestRead()
    {
        // WRITE VECTOR
        // create a 10 element petsc vector
        unsigned vec_size = 10u;
        Vec vec=PetscTools::CreateVec(vec_size);
        // calculate the range
        PetscInt petsc_lo, petsc_hi;
        VecGetOwnershipRange(vec, &petsc_lo, &petsc_hi);
        unsigned lo=(unsigned)petsc_lo;
        unsigned hi=(unsigned)petsc_hi;
        // create 20 element petsc vector
        Vec striped;
        VecCreateMPI(PETSC_COMM_WORLD, 2*(hi-lo) , 2*vec_size, &striped);
        // write some values
        double* p_vec;
        VecGetArray(vec, &p_vec);
        double* p_striped;
        VecGetArray(striped, &p_striped);
        for (unsigned global_index=lo; global_index<hi; global_index++)
        {
            unsigned local_index = global_index - lo;
            p_vec[local_index] = local_index*global_index;
            p_striped[2*local_index  ] = local_index;
            p_striped[2*local_index+1] = global_index*global_index;
        }
        VecRestoreArray(vec, &p_vec);
        VecAssemblyBegin(vec);
        VecAssemblyEnd(vec);
        VecRestoreArray(striped, &p_striped);
        VecAssemblyBegin(striped);
        VecAssemblyEnd(striped);

        // READ VECTOR
        DistributedVectorFactory factory(vec);
        DistributedVector distributed_vector = factory.CreateDistributedVector(vec);
        DistributedVector distributed_vector2 = factory.CreateDistributedVector(striped);
        DistributedVector::Stripe linear(distributed_vector2,0);
        DistributedVector::Stripe quadratic(distributed_vector2,1);
        // check the range
        TS_ASSERT_EQUALS(factory.GetProblemSize(), vec_size);
        TS_ASSERT_EQUALS(distributed_vector.Begin().Global,lo);
        TS_ASSERT_EQUALS(distributed_vector.End().Global,hi);
        // read some values
        for (DistributedVector::Iterator index = distributed_vector.Begin();
             index!= distributed_vector.End();
             ++index)
        {
            TS_ASSERT_EQUALS(distributed_vector[index], index.Local*index.Global);
            TS_ASSERT_EQUALS(linear[index], index.Local);
            TS_ASSERT_EQUALS(quadratic[index], index.Global * index.Global);
        }

        // read the 2nd element of the first vector
        if (lo<=2 && 2<hi)
        {
            TS_ASSERT(distributed_vector.IsGlobalIndexLocal(2));
            TS_ASSERT_EQUALS(distributed_vector[2],2*(2-lo));
        }
        else
        {
            TS_ASSERT(!distributed_vector.IsGlobalIndexLocal(2));
            TS_ASSERT_THROWS(distributed_vector[2],DistributedVectorException);
        }

        //read the 3rd element of the other vectors
        if (lo<=3 && 3<hi)
        {
            TS_ASSERT(distributed_vector.IsGlobalIndexLocal(3));
            TS_ASSERT_EQUALS(linear[3],(3-lo));
            TS_ASSERT_EQUALS(quadratic[3],3*3);
        }
        else
        {
            TS_ASSERT(!distributed_vector.IsGlobalIndexLocal(3));
            TS_ASSERT_THROWS(linear[3],DistributedVectorException);
            TS_ASSERT_THROWS(quadratic[3],DistributedVectorException);
        }

        PetscTools::Destroy(vec);
        PetscTools::Destroy(striped);
    }
示例#29
0
void MonotonicAccelInterpolate(const vector<Vector>& pts,vector<GeneralizedCubicBezierCurve>& paths,CSpace* space,GeodesicManifold* manifold)
{
  Assert(pts.size() >= 2);
  
  vector<Vector> tangents(pts.size()),inslopes(pts.size()-1),outslopes(pts.size()-1);
  paths.resize(pts.size()-1);
  for(size_t i=0;i<paths.size();i++) {
    paths[i].x0 = pts[i];
    paths[i].x3 = pts[i+1];
    paths[i].space = space;
    paths[i].manifold = manifold;
  }
  paths[0].x0 = pts[0];
  paths[0].x3 = pts[1];
  if(pts.size() == 2) {
    paths[0].SetSmoothTangents(NULL,NULL);
    return;
  }
  paths[0].SetSmoothTangents(NULL,&pts[2]);
  paths[0].Deriv(0,tangents[0]);
  paths.back().x0 = pts[pts.size()-2];
  paths.back().x3 = pts[pts.size()-1];
  paths.back().SetSmoothTangents(&pts[pts.size()-3],NULL);
  paths.back().Deriv(1,tangents.back());
  for(size_t i=1;i<pts.size();i++) {
    if(!manifold) {
      inslopes[i-1] = pts[i]-pts[i-1];
      outslopes[i-1].setRef(inslopes[i-1]);
    }
    else {
      manifold->InterpolateDeriv(pts[i-1],pts[i],0,inslopes[i-1]);
      manifold->InterpolateDeriv(pts[i],pts[i-1],0,outslopes[i-1]);
      outslopes[i-1].inplaceNegative();
    }
    if(i+1<pts.size()) {
      if(!manifold)
	tangents[i] = (pts[i+1]-pts[i-1])*0.5;
      else {
	Vector n,p;
	manifold->InterpolateDeriv(pts[i],pts[i+1],0,n);
	manifold->InterpolateDeriv(pts[i],pts[i-1],0,p);
	tangents[i] = (n-p)*0.5;
      }
    }
  }
  int n=pts[0].n;
  for(size_t i=0;i<pts.size();i++) {
    if(tangents[i].n != n) printf("%d / %d\n",i,tangents.size());
    Assert(tangents[i].n == n);
  }
  for(size_t i=0;i+1<pts.size();i++) {
    if(i == 1)
      cout<<"Orig tangent 2: "<<tangents[i+1]<<endl;
    for(int j=0;j<n;j++) {
      if(j==0) {
	printf("Segment %d: accel in %g, out %g\n",i,3.0*inslopes[i][j] - tangents[i+1][j]-2*tangents[i][j],2*tangents[i+1][j]+tangents[i][j] - 3.0*outslopes[i][j]);
      }
      if(Sign(3.0*inslopes[i][j] - tangents[i+1][j] - 2*tangents[i][j]) != Sign(2*tangents[i+1][j]+tangents[i][j] - 3.0*outslopes[i][j])) {
	//(3.0*mi - x - 2*t0)*(2*x+t0 - 3.0*mo) = 0
	//(- x + 3.0*mi - 2*t0)*(2*x+t0 - 3.0*mo) = 
	//    -2x^2 + x*(-t0+3mo+6mi-4t0) + (3mi-2t0)(t0-3mo) = 0
	//solve quadratic to set tangents[i+1][j] so one accel becomes
	//nullified
	Real a = -2.0;
	Real b = 6*inslopes[i][j] + 3*outslopes[i][j]-5*tangents[i][j];
	Real c = (3*inslopes[i][j]-2*tangents[i][j])*(tangents[i][j]-3*outslopes[i][j]);
	Real t1,t2;
	int res=quadratic(a,b,c,t1,t2);
	if(res == 0) {
	  if(j==0) 
	    printf("No solution to quadratic %g %g %g\n",a,b,c);
	}
	else {
	  assert(res > 0);
	  if(res == 2) {
	    //pick the closer one to the existing tangent
	    if(Abs(t1 - tangents[i+1][j]) > Abs(t2 - tangents[i+1][j]))
	      t1 = t2;
	  }
	  tangents[i+1][j] = t1;
	  if(j==0) {
	    printf("New accel in %g, out %g\n",3.0*inslopes[i][j] - tangents[i+1][j]-2*tangents[i][j],2*tangents[i+1][j]+tangents[i][j] - 3.0*outslopes[i][j]);
	  }
	}
      }
    }
    if(i == 1)
      cout<<"New tangent 2: "<<tangents[i+1]<<endl;
  }
  for(size_t i=0;i+1<pts.size();i++) {
    paths[i].SetNaturalTangents(tangents[i],tangents[i+1]);
    Vector temp,temp2;
    paths[i].Accel(0,temp);
    paths[i].Accel(1,temp2);
    cout<<"in "<<temp[0]<<" out "<<temp2[0]<<endl;
  }
}
示例#30
0
    void TestWrite()
    {
        // WRITE VECTOR

        // Create a 10 element petsc vector
        DistributedVectorFactory factory(10);
        Vec striped = factory.CreateVec(2);
        Vec chunked = factory.CreateVec(2);
        Vec petsc_vec = factory.CreateVec();

        DistributedVector distributed_vector = factory.CreateDistributedVector(petsc_vec);
        DistributedVector distributed_vector_striped = factory.CreateDistributedVector(striped);
        DistributedVector distributed_vector_chunked = factory.CreateDistributedVector(chunked);
        DistributedVector::Stripe linear(distributed_vector_striped, 0);
        DistributedVector::Stripe quadratic(distributed_vector_striped, 1);
        DistributedVector::Chunk linear_chunk(distributed_vector_chunked, 0);
        DistributedVector::Chunk quadratic_chunk(distributed_vector_chunked, 1);

        // Write some values
        for (DistributedVector::Iterator index = distributed_vector.Begin();
             index!= distributed_vector.End();
             ++index)
        {
            distributed_vector[index] =  -(double)(index.Local*index.Global);
            linear[index] =  -1;
            quadratic[index] =  index.Local+1;
            linear_chunk[index] = -1;
            quadratic_chunk[index] =  index.Global+1;
        }

        distributed_vector.Restore();
        distributed_vector_striped.Restore();
        distributed_vector_chunked.Restore();

        // READ VECTOR

        // Calculate my range
        PetscInt petsc_lo, petsc_hi;
        VecGetOwnershipRange(petsc_vec,&petsc_lo,&petsc_hi);
        unsigned lo = (unsigned)petsc_lo;
        unsigned hi = (unsigned)petsc_hi;

        // Read some values
        double* p_striped;
        VecGetArray(striped, &p_striped);
        double* p_chunked;
        VecGetArray(chunked, &p_chunked);
        double* p_vec;
        VecGetArray(petsc_vec, &p_vec);
        for (unsigned global_index=lo; global_index<hi; global_index++)
        {
            unsigned local_index = global_index - lo;
            TS_ASSERT_EQUALS(p_vec[local_index], -(double)local_index*global_index);
            TS_ASSERT_EQUALS(p_striped[2*local_index], -1.0);
            TS_ASSERT_EQUALS(p_striped[2*local_index+1], local_index+1);

            TS_ASSERT_EQUALS(linear[global_index], -1.0);
            TS_ASSERT_EQUALS(quadratic[global_index], local_index+1);

            TS_ASSERT_EQUALS(p_chunked[local_index], -1.0);
            TS_ASSERT_EQUALS(p_chunked[ (hi - lo) + local_index], global_index+1);

            TS_ASSERT_EQUALS(linear_chunk[global_index], -1.0);
            TS_ASSERT_EQUALS(quadratic_chunk[global_index], global_index+1);
        }

        // Read item 2 from the distributed vectors (for coverage)
        if (lo<=2 && 2<hi)
        {
            TS_ASSERT(distributed_vector.IsGlobalIndexLocal(2));
            TS_ASSERT_EQUALS(linear[2], -1.0);
            TS_ASSERT_EQUALS(quadratic[2], 3.0 - lo);
            TS_ASSERT_EQUALS(linear_chunk[2], -1.0);
            TS_ASSERT_EQUALS(quadratic_chunk[2], 3.0);
        }
        else
        {
            TS_ASSERT(!distributed_vector.IsGlobalIndexLocal(2));
            TS_ASSERT_THROWS(linear[2],DistributedVectorException);
            TS_ASSERT_THROWS(linear_chunk[2],DistributedVectorException);
        }

        PetscTools::Destroy(petsc_vec);
        PetscTools::Destroy(striped);
        PetscTools::Destroy(chunked);
    }