C++, Интеграл

[Александр222]

Имеется класс Polynomial. Надо немного дополнить кусок для интегрирования. Вернее, как мне заменить f на конкретный полином?

Polynom.h

double Simpson(double a, double b, int n, double t, double* f );

Polynom.cpp

double Polynomial::Simpson(double a, double b, int n, double t, double* f)
{
	double s = 0, s1 = 0, s2 = 0;
	double x, h;
	int i;

	x = a;
	h = (b - a) / (2 * n);
	for (i = 1; i <= 2 * n - 1; i += 2)
	{
		s1 += f(x + h * i, t);
		s2 += f(x + h * (i + 1), t);
	}
	s2 = 4 * s2;
	s1 = 2 * s1;
	s = s1 + s2 + f(a, t) - f(b, t);
	return (h / 3) * s;

}

[Petros-20]

1 - Напишите функцию вычисления полинома.
2 - В месте вызова Simpson в последнем аргументе указываете указатель на функцию из п.1.

-получаете зачёт

[Black Fregat]

У Вас в этом классе Polynomial, вероятно, есть функция вычисления полинома?

А что за параметр t в этом интеграле?

[Александр222]

Black Fregat,
Petros-20, Прикладываю код целиком.

main. cpp

#include <iostream>
#include "Polinom.h"

using namespace std;

int main(){

	int d1, d2;
	Polynomial Answer;

	std::cout << "Enter degree of first polynom p: "; std::cin >> d1;
	double* arr = new double[d1 + 1];

	for (int i = d1; i >= 0; i--) {
		std::cout << "Enter coef of x^" << i << ": "; std::cin >> arr[i];
	}

	Polynomial p(arr, d1 + 1);
	p.DisplayPoly();

	std::cout << "\n______________________________________________________________________________\n " << std::endl;

	std::cout << "Enter degree of seconf polynom q: "; std::cin >> d2;
	double* arr2 = new double[d2 + 1];

	for (int i = d2; i >= 0; i--) {
		std::cout << "Enter coef of x^" << i << ": "; std::cin >> arr2[i];
	}

	Polynomial q(arr2, d2 + 1);
	q.DisplayPoly();

	std::cout << "\n______________________________________________________________________________\n " << std::endl;

	std::cout << "Value of p for X: \n" << p.At(0);
	std::cout << "Value of q for X: \n" << q.At(0);

	Answer = p.Add(q);
	std::cout << "Add: "; Answer.DisplayPoly();

	Answer = p.Sub(q);
	std::cout << "\nSub: ";	Answer.DisplayPoly();

	Answer = p.Mul(q);
	std::cout << "\nMul: ";	Answer.DisplayPoly();

	std::cout << "\nDerivative of p: "; p.Derivative();
	p.DisplayPoly();

    std::cout << "\nDerivative of q: "; q.Derivative();
	q.DisplayPoly();

	std::cout << "\n______________________________________________________________________________\n " << std::endl;

Polynom.h

#include <iostream>

class Polynomial
{
private:
	double* CoefArr;
	int ArrSize;

public:
	Polynomial();
	Polynomial(int Degree);
	Polynomial(double* CoefficiantArray, int CoefficiantCount);
	Polynomial(Polynomial& other);

	Polynomial Add(Polynomial& other);
	Polynomial Sub(Polynomial& other);
	Polynomial Mul(Polynomial& other);

	int Degree();
	double At(double value);
	void Derivative();
	void DisplayPoly();
	Polynomial Simpson(Polynomial& other);

};

Polynom.cpp

#include <iostream>
#include "Polinom.h"

Polynomial::Polynomial(){
	ArrSize = 1;
	CoefArr = new double[1];	
	CoefArr[0] = 0;
}

Polynomial::Polynomial(int Degree){
	ArrSize = Degree + 1;
	CoefArr = new double[ArrSize];
	for (int i = 0; i < ArrSize; i++){
		CoefArr[i] = 0;
	}
}

Polynomial::Polynomial(double* CoefficiantArray, int CoefficiantCount){
	ArrSize = CoefficiantCount;
	CoefArr = new double[CoefficiantCount];
	for (int i = 0; i < CoefficiantCount; i++){
		CoefArr[i] = CoefficiantArray[i];
	}
}

Polynomial::Polynomial(Polynomial& other){
	ArrSize = other.ArrSize;
	CoefArr = new double[ArrSize];
	for (int i = 0; i < ArrSize; i++){
		CoefArr[i] = other.CoefArr[i];
	}
}

Polynomial Polynomial::Add(Polynomial& other){
	int SizeOfAnswer = (ArrSize >= other.ArrSize) ? ArrSize : other.ArrSize;
	Polynomial Answer(SizeOfAnswer - 1);
	if (ArrSize >= other.ArrSize){
		for (int i = 0; i < other.ArrSize; i++){
			Answer.CoefArr[i] = CoefArr[i] + other.CoefArr[i];
		}
		for (int i = other.ArrSize; i < ArrSize; i++){
			Answer.CoefArr[i] = CoefArr[i];
		}
	}
	else{
		for (int i = 0; i < ArrSize; i++){
			Answer.CoefArr[i] = CoefArr[i] + other.CoefArr[i];
		}
		for (int i = ArrSize; i < other.ArrSize; i++){
			Answer.CoefArr[i] = other.CoefArr[i];
		}
	}
	return Answer;
}

Polynomial Polynomial::Sub(Polynomial& other){
	int SizeOfAnswer = (ArrSize >= other.ArrSize) ? ArrSize : other.ArrSize;
	Polynomial Answer(SizeOfAnswer - 1);
	if (ArrSize >= other.ArrSize){
		for (int i = 0; i < other.ArrSize; i++){
			Answer.CoefArr[i] = CoefArr[i] - other.CoefArr[i];
		}
		for (int i = other.ArrSize; i < ArrSize; i++){
			Answer.CoefArr[i] = CoefArr[i];
		}
	}
	else{
		for (int i = 0; i < ArrSize; i++){
			Answer.CoefArr[i] = CoefArr[i] - other.CoefArr[i];
		}
		for (int i = ArrSize; i < other.ArrSize; i++){
			Answer.CoefArr[i] = other.CoefArr[i];
		}
	}
	return Answer;
}

Polynomial Polynomial::Mul(Polynomial& other){
	int DegreeOfAnswer = ArrSize + other.ArrSize - 2;
	Polynomial Answer(DegreeOfAnswer);

	for (int i = 0; i < ArrSize; i++){
		for (int j = 0; j < other.ArrSize; j++){
			Answer.CoefArr[i + j] += (CoefArr[i] * other.CoefArr[j]);
		}
		for (int i = other.ArrSize; i < ArrSize; i++){
			Answer.CoefArr[i] = CoefArr[i];
		}
	}
	return Answer;
}

int Polynomial::Degree() { return ArrSize - 1; }

double Polynomial::At(double xpos){
	double Answer = 0;
	if (ArrSize == 1) Answer = CoefArr[0];
	else{
		Answer = CoefArr[ArrSize - 1];
		for (int i = ArrSize - 2; i >= 0; i--)
			Answer = Answer * xpos + CoefArr[i];
	}
	return Answer;
}

void Polynomial::Derivative() {
	for (int i = 0; i < ArrSize; i++) {
		CoefArr[i] = CoefArr[i + 1] * (i + 1);
	}
	 ArrSize--;
	 return;
}

void Polynomial::DisplayPoly(){

	std::cout << CoefArr[ArrSize - 1] << "x^" << ArrSize - 1;
	
	for (int i = ArrSize - 2; i >= 0; i--)
		std::cout << " + " << CoefArr[i] << "x^" << i;
	return;
}

Polynomial Polynomial::Simpson(Polynomial& other)
{
	double s = 0, s1 = 0, s2 = 0;
	double x, h;
	int i, a, b, n, t;

	x = a;
	h = (b - a) / (2 * n);
	for (i = 1; i <= 2 * n - 1; i += 2)
	{
		s1 += (x + h * i, t);
		s2 += (x + h * (i + 1), t);
	}
	s2 = 4 * s2;
	s1 = 2 * s1;
	s = s1 + s2 + (a, t) - (b, t);
	return (h / 3) * s;

}

[Black Fregat]

Не надо там other..

double Polynomial::Simpson(double a, double b, int n)
{
  double s = 0, s1 = 0, s2 = 0;
  double x, h;
  int i;

  x = a;
  h = (b - a) / (2 * n);
  for (i = 1; i <= 2 * n - 1; i += 2)
  {
    s1 += At(x + h * i);
    s2 += At(x + h * (i + 1));
  }
  s2 = 4 * s2;
  s1 = 2 * s1;
  s = s1 + s2 + At(a) + At(b);
  return (h / 3) * s;
}

PS. Но интегрировать полином численно - извращение по-моему. Он же аналитически на ура

[Александр222]

Black Fregat, Спасибо!

[BDA]

Александр222, используйте для оформления кода кнопочку CODE, а не цитату.