double Polynomial_Root(int n,double c[], double a, double b, double eps){
    int newton(double x0, double *r,double c[], double d[], int n, double a, double b, double eps);
    double d[MAXN];
    int i;
    double root = 0.0;

    for (i=n-1; i>=0; i--) {
        d[i] = (i+1)*c[i+1];
    }
    if (a>b) {
        root = a; a = b; b = root;
    }
    double average = 0.0;
    int k = 0;
    int t = newton(a, &root, c, d, n, a, b, eps);
    if (t == 1){
        average += root;
        k++;
    }
    int s = newton(b, &root, c, d, n, a, b, eps);
    if (s == 1){
        average += root;
        k++;
    }
    int u = newton((a+b)*0.5, &root, c, d, n, a, b, eps);
    if (u == 1){
        average += root;
        k++;
    }
    average /= k;

    if (fabs(root)<eps) return fabs(root);
    else return root;
}
Beispiel #2
0
int newton(int n, int k)
{
    if (k == 0 || k == n)
	return 1;
    else
	return newton(n - 1, k - 1) + newton(n - 1, k);
}
Beispiel #3
0
Datei: ex2.c Projekt: k0n1u/lab_c
int newton(int n,int k)
{
	if(k==0 || k==n)
		return 1;
	if(k>0 && k<n)
		return newton(n-1,k-1)+newton(n-1,k);
}
Beispiel #4
0
void main_train(int iter,void* dat,void *vector){
  printf("starting train\n");
  Data data;
  int t;

  //init constant
  do{
    Int* buffer=(Int*)dat;
    dat+=sizeof(Int)*3;
    data.ndata=buffer[0];
    data.cust.n=buffer[1];
    data.movie.n=buffer[2];
    data.ndim=10;
    data.cust.p=(Int*)dat;
    dat+=sizeof(Int)*(data.cust.n+1);
    data.movie.p=(Int*)dat;
    dat+=sizeof(Int)*(data.movie.n+1);
    data.cust.i=(Int*)dat;
    dat+=sizeof(Int)*data.ndata;
    data.movie.i=(Int*)dat;
    dat+=sizeof(Int)*data.ndata;
  }while(0);
  printf("(ndata: %d)(ncust: %d)(nmovie: %d)\n",data.ndata,data.cust.n,data.movie.n);
  //data.ndata=10000000;
  for(t=0;t<10;t++){
    printf("p2[%d]=%d\n",t,data.movie.p[t]);
  }

  if(vector==0){
    int size=(data.cust.n+data.movie.n)*data.ndim;
    vector=malloc(sizeof(Double)*size);
    for(size--;size>=0;size--){
      ((Double*)vector)[size]=((Double)rand()/RAND_MAX-0.5)/10;
    }
  }
  

  //init vector
  Double* v1=(Double*)vector;
  vector+=sizeof(Double)*data.cust.n*data.ndim;
  Double* v2=(Double*)vector;
  vector+=sizeof(Double)*data.cust.n*data.ndim;



  printf("starting iteration\n");
  time_t time0,time1;
  time(&time0);
  int iterleft=iter;
  while(iterleft!=0){
    newton(v1,v2,data,data.cust,data.movie);
    request_judge(v1);
    newton(v2,v1,data,data.movie,data.cust);
    request_judge(v1);
    printf("iterleft: %d\n",iterleft);
    time(&time1);
    printf("time elapsed: %lu\n",time1-time0);
    iterleft--;
  }
}
Beispiel #5
0
int main(void)
{
	double a1 = 0.0, b1 = 1.0;
	double a2 = 1.0, b2 = 3.0;
	double eps = 0.000001;

	double d1 = dichotomy(f1, eps, a1, b1);
	double i1 = iteration(f1_it, eps, a1, b1);
	double n1 = newton(f1, f1_pr, eps, a1, b1);

	double d2 = dichotomy(f2, eps, a2, b2);
	double i2 = iteration(f2_it, eps, a2, b2);
	double n2 = newton(f2, f2_pr, eps, a2, b2);

	printf("Точность: %.6f\n", eps);
	printf("+-----------+----------+---------------+-----------------------+-----------+----------+---------+\n");
	printf("| Уравнение | Отрезок  | Базовый метод | Прибл. значение корня | Дихотомии | Итераций | Ньютона |\n");
	printf("+-----------+----------+---------------+-----------------------+-----------+----------+---------+\n");
	printf("|     1     |  [0, 1]  |    Ньютона    |         0.8814        |%.9f|%.8f|%.7f|\n", d1, i1, n1);
	printf("+-----------+----------+---------------+-----------------------+-----------+----------+---------+\n");
	printf("|     2     |  [1, 3]  |    Дихотомии  |         1.3749        |%.9f|    -     |%.7f|\n", d2, n2);
	printf("+-----------+----------+---------------+-----------------------+-----------+----------+---------+\n");

	return 0;
}
Beispiel #6
0
int newton(int n, int k) {

  if (n == 0 || n == k) {
    return 1;
  }

  if (n > 0 && k > 0 && n > k) {
    return newton(n - 1, k - 1) + newton(n - 1, k);
  }
}
Beispiel #7
0
int newton(int n,int k)
{
  if(k==0 || k==n)
  {
    return 1;
  }
  if(n>k && k>0)
  {
    return newton(n-1,k-1)+newton(n-1,k);
  }
}
Beispiel #8
0
void CtcNewton::contract(IntervalVector& box, ContractContext& context) {
	if (!(box.max_diam()<=ceil)) return;
	else {
		if (!vars)
			newton(f,box,prec,gauss_seidel_ratio);
		else
			newton(f,*vars,box,prec,gauss_seidel_ratio);
	}

	if (box.is_empty()) {
		context.output_flags.add(FIXPOINT);
	}
}
Beispiel #9
0
int main() {
  // Create coarse mesh, set Dirichlet BC, enumerate 
  // basis functions
  Mesh *mesh = new Mesh(A, B, N_elem, P_init, N_eq);
  mesh->set_bc_left_dirichlet(0, Val_dir_left_0);
  mesh->set_bc_right_dirichlet(0, Val_dir_right_0);
  mesh->set_bc_left_dirichlet(1, Val_dir_left_1);
  mesh->set_bc_right_dirichlet(1, Val_dir_right_1);
  printf("N_dof = %d\n", mesh->assign_dofs());

  // Register weak forms
  DiscreteProblem *dp = new DiscreteProblem();
  dp->add_matrix_form(0, 0, jacobian_0_0);
  dp->add_matrix_form(0, 1, jacobian_0_1);
  dp->add_matrix_form(1, 0, jacobian_1_0);
  dp->add_matrix_form(1, 1, jacobian_1_1);
  dp->add_vector_form(0, residual_0);
  dp->add_vector_form(1, residual_1);

  // Newton's loop
  newton(dp, mesh, NULL, NEWTON_TOL, NEWTON_MAXITER);

  // Plot the solution
  Linearizer l(mesh);
  l.plot_solution("solution.gp");

  printf("Done.\n");
  return 1;
}
Beispiel #10
0
int main() {
  // Create coarse mesh, set Dirichlet BC, enumerate 
  // basis functions
  Mesh *mesh = new Mesh(A, B, N_elem, P_init, N_eq);
  printf("N_dof = %d\n", mesh->assign_dofs());

  // Register weak forms
  DiscreteProblem *dp = new DiscreteProblem();
  dp->add_matrix_form(0, 0, jacobian_vol);
  dp->add_vector_form(0, residual_vol);
  dp->add_matrix_form_surf(0, 0, jacobian_surf_left, BOUNDARY_LEFT);
  dp->add_vector_form_surf(0, residual_surf_left, BOUNDARY_LEFT);
  dp->add_matrix_form_surf(0, 0, jacobian_surf_right, BOUNDARY_RIGHT);
  dp->add_vector_form_surf(0, residual_surf_right, BOUNDARY_RIGHT);

  // Newton's loop
  newton(dp, mesh, NULL, NEWTON_TOL, NEWTON_MAXITER);

  // Plot the solution
  Linearizer l(mesh);
  l.plot_solution("solution.gp");

  printf("Done.\n");
  return 1;
}
Beispiel #11
0
void main () {
  double x[2], fx[2], tol;
  int iter, maxIter;

  // INPUT

  cout << "Enter tolerance: ";
  cin >> tol;
  cout << "Enter max iterations: ";
  cin >> maxIter;
  cout << "Enter an initial guess: ";
  cin >> x[0] >> x[1];

  // NEWTON SOLVER

  int state = newton(x, f, df, iter, tol, maxIter);
  f(x,fx);

  // STATUS AND OUTPUT

  switch(state) {
  case SUCCESS:
    cout << "An approximate root is (" << x[0] << ", " << x[1] <<")\n";
    cout << "f(approximate root) is (" << fx[0] << ", " << fx[1] <<")\n";
    cout << "The number of iterations is " << iter << endl;
    break;
  case WONT_STOP:
  default:
    cout << "ERROR: Failed to converge in "<<maxIter<<" iterations!" << endl;
    break;
  }
}
Beispiel #12
0
  void NewtonEqualitySelfTest()
  {
    cout<<"Testing equality-constrained Newton solver..."<<endl;
    Matrix A(2,2);
    Vector b(2);
    Real c;
    A.setIdentity(); A *= -Two;
    b.setZero();
    c=10;
    QuadraticScalarFieldFunction c1(A,b,c); 
    ComponentVectorFieldFunction C;
    C.functions.resize(1); C.functions[0] = &c1;

    Vector p(2);
    p(0) = -1; p(1) = 0;
    Real q=0;
    LinearScalarFieldFunction f(p,q);

    NonlinearProgram nlp(&f,&C);
    nlp.minimize = true;
    nlp.inequalityLess = false;
    NewtonSolver newton(nlp);
    newton.x.resize(2); newton.x(0) = -1; newton.x(1) = -1;

    newton.verbose=1;
    newton.Init();
    int iters=100;
    ConvergenceResult res=newton.Solve(iters);
    cout<<"Result "<<res<<" iters "<<iters<<endl;
    cout<<"x = "<<VectorPrinter(newton.x)<<endl;
    cout<<"done."<<endl;
  }
Beispiel #13
0
    void OGProjection<Scalar>::project_internal(Hermes::vector<Space<Scalar>*> spaces, WeakForm<Scalar>* wf,
      Scalar* target_vec, Hermes::MatrixSolverType matrix_solver_type)
    {
      _F_;
      // Instantiate a class with global functions.
      Global<Scalar> hermes2d;

      unsigned int n = spaces.size();

      // sanity checks
      if (n <= 0 || n > 10) error("Wrong number of projected functions in project_internal().");
      for (unsigned int i = 0; i < n; i++) if(spaces[i] == NULL) error("this->spaces[%d] == NULL in project_internal().", i);
      if (spaces.size() != n) error("Number of spaces must match number of projected functions in project_internal().");

      // this is needed since spaces may have their DOFs enumerated only locally.
      int ndof = Space<Scalar>::assign_dofs(spaces);

      // Initialize DiscreteProblem.
      DiscreteProblem<Scalar> dp(wf, spaces);

      // Initial coefficient vector for the Newton's method.  
      Scalar* coeff_vec = new Scalar[ndof];
      memset(coeff_vec, 0, ndof*sizeof(Scalar));

      // Perform Newton's iteration.
      NewtonSolver<Scalar> newton(&dp, matrix_solver_type);
      if (!newton.solve(coeff_vec)) 
        error("Newton's iteration failed.");

      delete [] coeff_vec;

      if (target_vec != NULL)
        for (int i = 0; i < ndof; i++) 
          target_vec[i] = newton.get_sln_vector()[i];
    }
Beispiel #14
0
int main() {
  double a, b, e;
  int status; 
  char chce_podac_x[2];
  do {
    printf("Podaj a: ");
    scanf("%lf", &a);
    printf("Podaj b: ");
    scanf("%lf", &b);
    if(a < b) {
      if (f(a) * f(b) < 0) {
        do {
          printf("Podaj przybliżenie: ");
          status = scanf("%lf", &e);
          if(e > 0 && e < 1) {
            bisection(a, b, e);
            newton(a, e);
          }
          do {
            printf("Chcesz podać kolejne przybliżenie? (tak/nie): ");
            scanf("%s", chce_podac_x);
            if(strcmp(chce_podac_x, "tak") == 0 || strcmp(chce_podac_x, "nie") == 0) break;
          } while(1);
        } while (strcmp(chce_podac_x, "tak") == 0);	
      } else {
        printf("błąd: f(a) i f(b) muszą mieć różny znak\n");
      }	
    } else {
      printf("błąd: a musi być mniejsze od b\n");
    }
  } while(a >= b || f(a) * f(b) >= 0);

  return 0;
}
Beispiel #15
0
int main()
{
  printf("\n   Dla  równania  f(x) = 0,  gdzie  f(x) = 3x + 2 - e^x,  wczytać  a, b  należące");
  printf("\n   do zbioru liczb rzeczywistych takie, by a < b oraz f(a) * f(b) < 0. Następnie,");
  printf("\n   dopóki  \"użytownik się nie znudzi\",  wczytywać  wartości  0 < E < 1  i  metodą");
  printf("\n   połowienia  na  [a, b]  przybliżyc z dokładnością E rozwiązanie tego równania.");
  printf("\n   Rozwiązanie to przybliżyc również metodą Newtona  z  x_0 = a,  przy czym,  x_k");
  printf("\n   będzie  dobrym   przybliżeniem,  gdy  |x_k - x_(k - 1)| <= E.  Porównać  ilość");
  printf("\n   kroków wykonanych metodą połowienia i metodą Newtona.\n");

  double a, b;

  printf("\n   Podaj a należące do zbioru liczb rzeczywistych:\n   a = ");
  scanf("%lf", &a);

  b = a;

  while(a >= b || equation(a) * equation(b) >= 0)
  {
    printf("\n   Podaj b należące do zbioru liczb rzeczywistych,\n   takie by b > a oraz f(b) * f(a) < 0\n   b = ");
    scanf("%lf", &b);
  }

  double epsilon, rB, rN;
  int choice;

  while (1)
  {
    printf("\n   1 - Przybliż rozwiązanie równania z dokładnością E metodą połowienia i Newtona");
    printf("\n   2 - Zakoncz program");
    printf("\n   Twoj wybor: ");
    scanf("%i", &choice);

    switch (choice)
    {
      case 1:
        epsilon = 0;

        while (epsilon <= 0 || epsilon >= 1)
        {
          printf("\n   Podaj E, takie by 0 < E < 1:\n   E = ");
          scanf("%lf", &epsilon);
        }

        rB = bisection(a, b, epsilon);
        rN = newton(a, epsilon);

        printf("\n   Metoda połowienia:\n   %lf - przybliżone rozwiązanie\n   %i - ilość kroków\n", rB, iB);
        printf("\n   Metoda Newtona:\n   %lf - przybliżone rozwiązanie\n   %i - ilość kroków\n", rN, iN);

        iB = iN = 0;

        break;

      case 2:
        printf("\n");
        return 0;
    }
  }
}
Beispiel #16
0
int main() {
   double x_0;       /* Initial guess                */
   double x;         /* Approximate solution         */
   double tol;       /* Maximum error                */
   int    max_iters; /* Maximum number of iterations */
   int    iters;     /* Actual number of iterations  */
   int    converged; /* Whether iteration converged  */

   printf("Enter x_0, tol, and max_iters\n");
      scanf("%lf %lf %d", &x_0, &tol, &max_iters);
	  
	     x = newton(x_0, tol, max_iters, &iters, &converged);
		 
		  if (converged) {
			    printf("Newton algorithm converged after %d steps.\n", 
					         iters);
				    printf("The approximate solution is %19.16e\n", x);
					    printf("f(%19.16e) = %19.16e\n", x, f(x));
						   } else {
						       printf("Newton algorithm didn't converge after %d steps.\n", 
								             iters);
							       printf("The final estimate was %19.16e\n", x);
								       printf("f(%19.16e) = %19.16e\n", x, f(x));
									     }
			
			   return 0;
}  /* main */
Beispiel #17
0
int main()
{
	newton();

//--gnuplotによるグラフ作成--//
	FILE *gp;
	gp=popen("gnuplot -persist","w");

	fprintf(gp, "set title 'df(x)=-1/x^2+1/x'\n");
	fprintf(gp, "set size ratio 1.0\n");
	fprintf(gp, "set border lw 2.5\n");
	fprintf(gp, "set mxtics 5\n");
	fprintf(gp, "set mytics 5\n");
	fprintf(gp, "set nokey\n");
	fprintf(gp, "set xl 'x' font 'Arial'\n");
	fprintf(gp, "set yl 'df(x)' font 'Arial'\n");
	fprintf(gp, "set parametric\n");
	fprintf(gp, "const=0\n");
	fprintf(gp, "set trange[-5:5]\n");
	fprintf(gp, "set xr [0:5]\n");
	fprintf(gp, "set yr [-5:1]\n");
	fprintf(gp, "plot const+1.5,t dt(5,5) lw 2.5 lt 1 lc rgb 'black'\n");
	fprintf(gp, "replot t,const dt(5,5) lw 2.5 lt 1 lc rgb 'black'\n");
	fprintf(gp, "replot t,t*4/27 dt(5,5) lw 2.5 lt 1 lc rgb 'navy'\n");
	fprintf(gp, "replot t,-1/(t*t)+1/t  w l lw 3 lt 1 lc rgb 'red'\n");

	pclose(gp);
 //--gnuplot終了--//	

        return 0;
}
void CtcNewton::contract(IntervalVector& box) {
	if (!(box.max_diam()<=ceil)) return;
	else newton(f,box,prec,gauss_seidel_ratio);

	if (box.is_empty()) {
		set_flag(FIXPOINT);
	}
}
Beispiel #19
0
int main(void){
  double x;
  double eps=pow(2.0,-30.0);
  printf("Please input x0:");
  scanf("%lf",&x);
  newton(x,eps);
  return 0;
}
Beispiel #20
0
int inexact_newton(int , char **)
{
    typedef double value_type;
    typedef std::string key_type;
    typedef std::map<key_type,std::vector<value_type> > stats_type;

    stats_type stats;
    const int size = 2;
    InexactNewtonMethod<value_type,1000,100> newton(size);
    function_type<2> F;
    value_type x[size] = {1,1};
    newton ( F,x,1e-16f,1e-13f, &stats );

    display_stats(stats);
    return 0;
    
}
Beispiel #21
0
Datei: ex2.c Projekt: k0n1u/lab_c
int main()
{
	
	printf("%d\n",newton(15,8));



}
Beispiel #22
0
int main()
{
	mpc mycase = loadcase();
	//mycase.print();

	newton(mycase);

	return 0;
}
Beispiel #23
0
    bool PicardSolver<Scalar>::solve(double tol, int max_iter)
    {
      int it = 0;
      NewtonSolver<Scalar> newton(static_cast<DiscreteProblem<Scalar>*>(this->dp), 
          this->matrix_solver_type);
      while (true)
      {
        // Delete the old solution vector, if there is any.
        if(this->sln_vector != NULL)
        {
          delete [] this->sln_vector;
          this->sln_vector = NULL;
        }

        // Project the previous solution in order to get a vector of coefficient.
        this->sln_vector = new Scalar[static_cast<DiscreteProblem<Scalar>*>(this->dp)->get_space(0)->get_num_dofs()];
        memset(this->sln_vector, 0, static_cast<DiscreteProblem<Scalar>*>(this->dp)->get_space(0)->get_num_dofs() * sizeof(Scalar));

        // Perform Newton's iteration to solve the linear problem.
        // Translate the resulting coefficient vector into the Solution sln_new.
        
        Solution<Scalar> sln_new;
        if (!newton.solve(this->sln_vector, tol, max_iter))
	      {
          warn("Newton's iteration in the Picard's method failed.");
          return false;
        }
        else
          Solution<Scalar>::vector_to_solution(newton.get_sln_vector(),
            static_cast<DiscreteProblem<Scalar>*>(this->dp)->get_space(0), &sln_new);

        double rel_error = Global<Scalar>::calc_rel_error(sln_prev_iter, &sln_new, 
                           HERMES_L2_NORM);

        if (this->verbose_output) 
          info("---- Picard iter %d, ndof %d, rel. error %g%%", 
               it+1, static_cast<DiscreteProblem<Scalar>*>(this->dp)->get_space(0)->get_num_dofs(), 
               rel_error);

        // Stopping criterion.
        if (rel_error < tol)
        {
          for (int i = 0; i < static_cast<DiscreteProblem<Scalar>*>(this->dp)->get_space(0)->get_num_dofs(); i++)
            this->sln_vector[i] = newton.get_sln_vector()[i];
          return true;
        }
        if (it++ >= max_iter)
        {
          if (this->verbose_output) 
            info("Maximum allowed number of Picard iterations exceeded, returning false.");
          return false;
        }

        // Copy the solution into the previous iteration.
        sln_prev_iter->copy(&sln_new);
      }
    }
Beispiel #24
0
inline long long int solve(const long long int &n, const long long int &k)
{
    long long int result = 0;
    std::sort(number, number + numbers);
    for(long long int i = 1; i <= n - k + 1; ++ i)
        result = (result + number[numbers - i] * newton(n - i, k - 1)) % MOD;

    return result;
}
int main() {
    /*
     * Вычисляем ширину эпсилон.
     */
    int epswidth = ceil(-log10(REAL_EPSILON));
    
    printf(
        "target_1 = 0, x = %.*f; dichotomy,  x ∈ [%f, %f]\n", 
        epswidth, 
        dichotomy(target_1, TARGET_1_A, TARGET_1_B),
        TARGET_1_A, TARGET_1_B
    );
    printf(
        "target_1 = 0, x = %.*f; iterations, x ∈ [%f, %f]\n", 
        epswidth, 
        iterations(target_1_xfx, TARGET_1_A, TARGET_1_B),
        TARGET_1_A, TARGET_1_B
    );
    printf(
        "target_1 = 0, x = %.*f; newton,     x ∈ [%f, %f]\n", 
        epswidth, 
        newton(target_1, target_1_derivative, TARGET_1_A, TARGET_1_B),
        TARGET_1_A, TARGET_1_B
    );
    printf(
        "target_2 = 0, x = %.*f; dichotomy,  x ∈ [%f, %f]\n",
        epswidth, 
        dichotomy(target_2, TARGET_2_A, TARGET_2_B),
        TARGET_2_A, TARGET_2_B
    );
    printf(
        "target_2 = 0, x = %.*f; iterations, x ∈ [%f, %f]\n",  
        epswidth, 
        iterations(target_2_xfx,  TARGET_2_A, TARGET_2_B),
        TARGET_2_A, TARGET_2_B
    );
    printf(
        "target_2 = 0, x = %.*f; newton,     x ∈ [%f, %f]\n", 
        epswidth, 
        newton(target_2, target_2_derivative, TARGET_2_A, TARGET_2_B),
        TARGET_2_A, TARGET_2_B
    );
    return (0);
}
Beispiel #26
0
main()
{
	double user_number;
	printf("Please enter the number you want the square root of\r\n");
	scanf("%lf",&user_number);
	
	//squareroot(user_number);
	newton(user_number);
	
}
int main() {
    double x;
    double a = 0.0;
    for (int i=0; i<100000; i++) {
        x = newton(i % 10);
        a += x;
        // cout << x << endl;
    }
    printf("%g\n", a);
}
Beispiel #28
0
int
main() {
    FILE *file = fopen("result/newtonDROB.txt", "w+");
  for (i=0; i < 5; i++) {
  printf("Iteration %d with e = %lf\n", i+1, e[i]);
  newton(file);
}
fclose (file);
return 0;
}
Beispiel #29
0
int main() {
  int n, k, out;

  printf("Podaj wartość n: ");
  scanf("%d", &n);
  printf("Podaj wartość k: ");
  scanf("%d", &k);
  wynik = newton(n, k);
  printf("%d\n", out);
}
Beispiel #30
0
int main(void)
{
    int x, y;

    printf("Podaj  liczbe x: ");
    scanf("%d", &x);
    printf("Podaj liczbe y: ");
    scanf("%d", &y);
    printf("%d \n", newton(x, y));
    return 0;
}