Вычисление значения функции разложением в ряд Тейлора

#include "stdafx.h"
#include "iostream"
#include "cmath"
#include "iomanip"
#include "conio.h"
#include <Windows.h>
 
    using namespace std;
 
[COLOR="DarkOrange"]int fact(int n)
{
return n <= 1 ? 1 : n * fact(n-1);
}[/COLOR]
int _tmain(int argc, _TCHAR* argv[])
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
 
    float x,E;
    cout<<"Введите X"<<endl;
    cin>>x;
    cout<<"Введите E"<<endl;
    cin>>E;
    float s, result=0;
    int k=0;
    while (true){
        s = (powf(-1, k) / [COLOR="darkorange"]fact(k)*fact(k+1)[/COLOR]) * powf(x/2,2*k+1);
        if (k) { 
            if (abs(s) < E){
            break;
            }
        }
        result += s;
        k++;
    }
    cout<<result<<endl;
    return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
 
    float x,E;
    cout<<"Введите X"<<endl;
    cin>>x;
    cout<<"Введите E"<<endl;
    cin>>E;
    float s, result=0;
    int f=1;
    int p=1;
    int k=0;
 
    while (true){
        s = (powf(-1, k) /[COLOR="red"] f*p[/COLOR]) * powf(x/2,2*k+1);
        if (k) {
            if (abs(s) < E){
                break;
            }
[COLOR="Red"]           f *= k;
            p *= k+1;[/COLOR]
        }
        result += s;
        k++;
    }
    cout<<result<<endl;
 
    getch();
    return 0;
}

long double fact(int N)
{
    if (N < 0)                           // если пользователь ввел отрицательное число
        return 0;                       // возвращаем ноль
    if (N == 0)                        // если пользователь ввел ноль,
        return 1;                       // возвращаем факториал от нуля - единицу
                          // Вычисляем факториал в цикле
    long double result = 1;
    for (int i = 1; i <= N; i++) {
        result *= i;
    }
    return result;
}

double factorial(size_t n) {
    double res = 1;
    while (n > 0) res *= n--;
    return res;
}

#include <iostream>
 
double factorial(size_t n) {
    double res = 1;
    while (n > 0) res *= n--;
    return res;
}
 
double bin_pow(double a, size_t power) {
    double res = 1;
    while (power) power & 1 ? --power, res *= a : power >>= 1, a *= a;
    return res;
}
 
double f(const size_t &k, const double &x) {
    double k_factorial = factorial(k);
    return (k & 1 ? -1 : 1) * bin_pow(x/2, 2*k+1) / (k_factorial * k_factorial * (k+1));
}
 
int main() {
    double e, x;
    std::cin >> x >> e;
    size_t k = 0;
    double previous = 0, current = f(k, x);
    do {
        previous = current;
        current += f(++k, x);
    } while (current - previous > e);
    std::cout << k << ' ' << current << std::endl;
}

double factorial(size_t n) {  //высчитываем факториал итеративным способом, n обьявляем целочисленным типом size_t, в моем случае занимает 64 бита 
    double res = 1;             // присваиваем переменной нулевое значение
    while (n > 0) res *= n--;   // пока n>0 выполняем выражение res=res*(n-1)
    return res;                 // функция возвращает конечное значнение res                              
}
 
double bin_pow(double a, size_t power) {             //бинарное возведение в степень, для того что бы избежать преобразования типов наверное
    double res = 1;
    while (power) power & 1 ? --power, res *= a : power >>= 1, a *= a; //побитово умножаем power на 00000001 если результат не равен нулю
                                                                       //отнимаем у power единицу, переменной res присваиваем res*a
                                                                     //иначе делим power пополам(делаем сдвиг вправо на 1 бит), a умножаем на a присваиваем a
    return res;
}
 
double f(const size_t &k, const double &x) {           //считаем епсилон. ????????????Для функции f объявляем константы ссылочного типа k и x(тип ссылок на вещественн)
                                                       //
    double k_factorial = factorial(k);  //заранее высчитываем факториал k
    return (k & 1 ? -1 : 1) * bin_pow(x/2, 2*k+1) / (k_factorial * k_factorial * (k+1)); //возвращаем значение формулы
}

#include "stdafx.h"
#include "iostream"
#include "iomanip"
#include "conio.h"
#include <Windows.h>
 
    using namespace std;
 
double factorial(size_t n) {  //высчитываем факториал итеративным способом, n обьявляем целочисленным типом size_t, в моем случае занимает 64 бита 
    double res = 1;             // присваиваем переменной нулевое значение
    while (n > 0) res *= n--;   // пока n>0 выполняем выражение res=res*(n-1)
    return res;                 // функция возвращает конечное значнение res                              
}
 
double bin_pow(double a, size_t power) {             //бинарное возведение в степень, для того что бы избежать преобразования типов... 
    double res = 1;
    while (power) power & 1 ? --power, res *= a : power >>= 1, a *= a; //побитово умножаем power на 00000001 если результат не равен нулю(или это проверка
                                                                       //на четное нечетное?) отнимаем у power единицу, переменной res присваиваем res*a
                                                                     //иначе делим power пополам(делаем сдвиг вправо на 1 бит), a умножаем на a присваиваем a
    return res;
}
 
double f(const size_t &k, const double &x) {           //считаем епсилон. Для функции f обьявляем константы ссылочного типа k и x
    double k_factorial = factorial(k);
    return (k & 1 ? -1 : 1) * bin_pow(x/2, 2*k+1) / (k_factorial * k_factorial * (k+1));//если k нечетное то -1 иначе 1 * на возведение в степень и тд.
}
 
int _tmain(int argc, _TCHAR* argv[])
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
 
    double e, x;
    cout<<"Введите x"<<endl;
    cin >> x;
 
    double previous, current;
    double sum;
    size_t k = 0;
    e=bin_pow(10,0.1);//задаем сложность
 
    int i;
    cout << setw( 12 ) << "E" << setw( 16 ) << "SUMM" << setw( 5 )<<  "N" << endl; //за N берем значение k
    for (i=1;i<=10;i++) {   //высчитываем 10 сложностей
        sum=0;             //на каждой итерации обнуляем значения, иначе беруться те что были высчитаны ранее  
        current=0;
        k=0;
        e/=10;                //увеличиваем сложность
        current = f(k, x); //считаем первый член
        sum+=current;
        k++;
 
        do {                    //считаем сумму
            previous = current; 
            current = f(k, x);
            sum+=current;
            k++;
        } while (abs(current - previous) > e);
        cout << setw( 12 ) << e << setw( 16 ) << sum << setw( 5 )<<  k << endl;
    }
    getch();
    return 0;
}

#include <iostream>
#include <iomanip>
 
double factorial(size_t n);
double bin_pow(double a, size_t power);
// Находит значение k-ого члена последовательности
double f(const size_t &k, const double &x);
// Находит и выводит сумму при заданных e & x
void print_sum(const double &e, const double &x);
 
int main(int argc, char *argv[])
{
    double x;
    std::cout << "Введите x" << std::endl;
    std::cin >> x;
    
    // Пробелы забрал чтобы влезло по ширине
    std::cout<<std::setw(12)<<"E"<<std::setw(16)<<"SUMM"<<std::setw(5)<<"N"<<std::endl;
    for (size_t power = 1; power <= 10; ++power) 
        print_sum(bin_pow(0.1, power), x);
    std::cin.get();
}
 
double factorial(size_t n) {
    double res = 1;
    while (n > 0) res *= n--;
    return res;
}
 
double bin_pow(double a, size_t power) {
    double res = 1;
    // В развернутой форме лучше комментировать код
    while (power) 
        if (power & 1) {
            --power; 
            res *= a;
        } else {
            power >>= 1; 
            a *= a;
        }
    return res;
}
 
double f(const size_t &k, const double &x) {
    // Сохраняем фаркториал чтобы не вычислять его дважды
    const double k_factorial = factorial(k),
        // числитель
        numerator = (k & 1 ? -1 : 1) * bin_pow(x / 2, 2 * k + 1),
        // знаменатель
        denominator = k_factorial * k_factorial * (k + 1);
    return numerator / denominator;
}
 
void print_sum(const double &e, const double &x) {
    size_t k = 0;
    // Так как нам нужно знать на сколько изменилась сумма при разном количестве членов,
    // запоминаем текущее и предыдущее значения суммы (при n=[0,k] & n=[0,k-1] соответсвенно)
    double previous, current = f(k, x), diff;
    std::cout << "E: " << e << std::endl;
    do {
        previous = current;
        current += f(++k, x);
        diff = current - previous;
    // Проверяем без abs() чтобы избежать ошибок с действительными числами
    } while (diff > e || diff < -e);
    std::cout << std::setw(12) << e << std::setw(16) << current << std::setw(5) << k << std::endl;
}