library polynoms

/
// Created by Sailein on 18.04.2018.
//

#ifndef DOKKAEBI_SNAKE_H
#define DOKKAEBI_SNAKE_H
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <mm_malloc.h>
#include <math.h>
typedef struct Polynom
{
    int max; // макс степень многочлена
    size_t size; // размер элемента в байтах
    void* content; // сам элемент
} PM;
// >>>technical solutions<<< //
PM* Create (int, size_t); //создание целочмсленного массива
void Enter (PM*, void*, int); //запись элемента в массив
void Get (PM*, int, void*); // считывание элемента из массива
void Free (PM*); // освобождение памяти
void Sum_int (void*, void*, void*); // сумма интовых числел - без привязки к массиву
void Sum_float (void*, void*, void*); // сумма флоутовых числел - без привязки к массиву
void Mul_int (void*, void*, void*); //произведение интовых числел - без привязки к массиву
void Mul_float (void*, void*, void*); //произведение флоутовых числел - без привязки к массиву
void Sum (void (*sum) (void* , void* , void* ), PM*, PM*, PM*, int); //сумма коэффициентов массива
void Smart (void (*sum) (void*, void*, void*), PM*, void*, int); // прибавление к элементу массива числа в помощь умножению
PM* Max (PM* , PM*); // макс из 2х элементов
PM* Min (PM* , PM* ); // мин из 2х элементов
// >>>operations<<< //
PM* Summa (void (*sum)(void*, void*, void*) ,PM*, PM*, PM*); //сумма многочленов
PM* Mul (void (*mul) (void*, void*, void*), void(*sum) (void*, void*, void*), PM* p1, PM* p2, PM* p3); // произведение многочленов
PM* Skalar (void (*mul) (void*, void*, void*), PM* p, void* A); // умножение на скаляр
void* Subst (void (*mul) (void*, void*, void*), void(*sum) (void*, void*, void*), PM*, void*, void*); // подстановка х, на выходе некое число нужного типа
PM* Composition (void (*mul) (void*, void*, void*), void(*sum) (void*, void*, void*), PM*, PM*, PM*);
// >>>interface<<< //
void Printer (PM* , void(*f)(PM*, int));
void Scanner (PM* , void(*f)(PM*, int), size_t);
void Scan_int(PM* , int );
void Scan_float(PM* , int );
void Print_int(PM* , int );
void Print_float(PM* , int );
#endif //DOKKAEBI_SNAKE_H


#include "Snake.h"


PM* Create (int n, size_t size) // n - макс степень многочлена, ф-ция создания нулевого массива
{
    PM* p = (PM*) malloc (sizeof(PM));
    p -> max = n;
    p -> size = size; // всегда 4
    p -> content = calloc ((size_t) p->max, p->size);
    return p;
}
void Enter (PM* array, void* el, int k) //это наш set, array - массив, el - вводимый с клавы элемент, k - степень х при коэффициенте
{
    memcpy (array -> content + k * array -> size, el, array -> size); // char - 1 байт
}
void Get (PM* p1, int k, void* el)
{
    memcpy (el, p1 ->content + k * p1 -> size, p1 -> size);
}
void Free (PM* array) // освобождение памяти
{
    free(array->content);
    free(array);
}
void Sum_int (void* first, void* second, void* third) // сумма интовых числел - без привязки к массиву
{
    *((int*) third) = *((int*) first) + *((int*) second);
}
void Sum_float (void* first, void* second, void* third) //сумма флоутовых чисел без привязки к массиву
{
    *((float*) third) = *((float*) first) + *((float*) second);
}
void Mul_int (void* first, void* second, void* third) //произведение интовых числел - без привязки к массиву
{
    *((int*)first) = *((int*)second) * (*((int*)third));
}
void Mul_float (void* first, void* second, void* third) //произведение флоутовых числел - без привязки к массиву
{
    *((float*)first) = *((float*)second) * (*((float*)third));
}
void Sum (void (*sum) (void* , void* , void* ), PM* p1, PM* p2, PM* p3, int i) //сумма коэффициентов массива
{
    void* c1 = malloc(p1 -> size);
    void* c2 = malloc(p2 -> size);
    void* cr = malloc(p3 ->size);
    Get (p1, i, c1); //вытащили 1 коэффициент
    Get (p2, i, c2); //вытащили второй
    // Get (p3, i, cr); //вытащили 0 из третьего массива
    sum (c1, c2, cr); // сложили их некой функцией с таким синтаксисом, которую мы в интерфейсе конткретно дадим
    Enter (p3, cr, i); // записали результатин
    free(c1);
    free(c2);
    free(cr);
}
void Smart (void (*sum) (void*, void*, void*), PM* array, void* el, int k) // array - массив (мешки с картохой), el - элемент который надо добавить (картоха новая), k - степень (номер мешка)
{
    void* coeff = malloc(array -> size); //конкретный мешок
    Get(array, k, coeff); //взяли мешок с номером k
    sum (coeff, el , coeff);
    Enter(array, coeff, k); //поставили мешок на место k
    free(coeff);
}
PM* Max (PM* p1, PM* p2) // многочлен макс степени
{
    if (p1 -> max > p2 -> max)
    {
        return p1;
    }
    else
    {
        return p2;
    }
}

PM* Min (PM* p1, PM* p2) // многочлен мин степени
{
    if (p1-> max > p2 -> max)
    {
        return p2;
    }
    else
    {
        return p1;
    }
}
PM* Summa (void (*sum)(void*, void*, void*) ,PM* p1, PM* p2, PM* p3) // сумма  многочленов
{
    PM* lion = Max(p1, p2);
    PM* finka = Min(p1, p2);
    int power = lion -> max;
    int lower = finka ->max;
    for (int i = 0; i <= lower; ++i) // сумма коэффициентов до меньшей степени
    {
        Sum (sum, p1, p2, p3, i);
    }
    for (int i = lower + 1; i <= power; ++i) // проверить тестами min ,не ясно брать + 1 или +2
    {
        Sum (sum, lion, p3, p3, i);
    }
    return p3;
}
PM* Mul (void (*mul) (void*, void*, void*), void(*sum) (void*, void*, void*), PM* p1, PM* p2, PM* p3) // произведение многочленов
{
    void* c1 = malloc(p1->size);
    void* c2 = malloc(p2 ->size);
    void* mcr = malloc(p3 ->size);
    for (int j = 0; j <= p1->max; ++j) // меньше или меньше/равно? тесты?
    {
        Get(p1, j, c1);
        for (int i = 0; i <= p2->max; ++i)
        {
            Get(p2, i, c2);
            mul (c1, c2, mcr);
            int m = i + j;
            Smart (sum, p3, mcr, m);
        }
    }
    free(c1);
    free(c2);
    free(mcr);
    return p3;
}
PM* Skalar (void (*mul) (void*, void*, void*), PM* p, void* A) // умножение на скаляр
{
    void* coeff = malloc(p ->size);
    for (int i = 0; i <= p->max; ++i)
    {
        Get(p, i, coeff);
        mul (coeff, A, coeff);
        Enter(p, &coeff, i);
    }
    free(coeff);
    return p;
}
void* Subst (void (*mul) (void*, void*, void*), void(*sum) (void*, void*, void*), PM* p, void* x, void* res) // подстановка х, на выходе некое число нужного типа
{
    void* coeff = malloc(p->size);
    res = calloc ((size_t) p->max, p->size);
    for (int i = 0; i <= p->max; ++i)
    {
        Get(p, i, coeff);
        for (int j = 1; j <= i; ++j) // для 0 степени цикла нэ будэт
        {
            mul (coeff, coeff , coeff);
        }
        sum(res, coeff, res);
    }
    free(coeff);
    return res;
}
PM* Composition (void (*mul) (void*, void*, void*), void(*sum) (void*, void*, void*), PM* p1, PM* p2, PM* p3) // подстановка р2 в р1
{
    void* coeff  = malloc(p3 ->size);
    void* first = malloc(p1->size);
    void* second = malloc(p2->size);
    int f1= 0;
    Get(p1, f1, first); // 0 степень мы обработали вручную, просто вписали коэффициент в результат
    Smart(sum, p3, first, f1); // вписали коэфф в ответ
    Get(p1, f1 + 1, second); // взяли второй коэфф-т
    Summa(sum, p3, Skalar(mul,p2, second), p3); // сложили ответ с р2 умнож. на второй коэфф-т
    for (int j = 2; j <= p1->max; ++j) // с первого многочлена берем степень и коэффициент
    {
        Get(p1, j, coeff); //взяли коэффициент
        PM* p = Create(j, sizeof(p3->size)); // выделяю и чищу на одном уровне вложенности
        Summa(sum, p, p2, p); //это задет начальное значение p = p2. а дальше мы его уже множим.
        for (int i = 2; i <= j; ++i) // возведение многочлена p2 в текущую степень j, начиная со второй степени
        {
            Mul(mul, sum, p, p2, p); // в цикле умножаем многочлен изначально равный р2 i раз
        }
        Skalar(mul, p, coeff); // умножим возведенный в степень j многочлен на текущий коэффициент;
        p3 = Summa (sum, p, p3, p3); //сложим умноженный и возведнный р2 с финальным
        Free(p);
    }
    free(coeff);
    free(first);
    free(second);
    return p3;
}
void Printer (PM* p, void(*f)(PM*, int)) //общий вывод на экран
{
    int i;
    for (i = p->max; i >= 0; --i)
    {
        f(p, i);
        if (i != 0)
            printf(" + ");
    }
    printf("\n");
}
void Scanner (PM* p, void(*f)(PM*, int), size_t memory) // общий считыватель
{
    printf("Максимальная степень многочлена : ");
    scanf("%d", &p->max);
    Create(p ->max, sizeof(memory));
    while (p->max < 0)
    {
        printf("ошибка\n");
        scanf("%d", &p->max);
    }
    p->size = memory;
    p->content = malloc(p->size*(p->max + 1)); // how to free it?
    printf("Коэффициенты :\n");
    for (int i = 0; i <= p->max; i++)
    {
        printf("x^%d  ", i);
        f(p, i);
    }
}
void Scan_int(PM* p, int i) // запись i-го элемента в массив
{
    scanf("%d", (int*) p->content);
    Enter(p, p->content, i);
}
void Scan_float(PM* p, int i) // запись i-го элемента в массив
{
    scanf("%f", (float*)p->content);
    Enter(p, p->content , i);
}
void Print_int(PM* p, int i) //считываение i-го элемента из массива
{
    printf("%d*x^%d", *(int*)p->content, i);
    Get(p,i,p->content);
}
void Print_float(PM* p, int i) //считываение i-го элемента из массива
{
    printf("%f*x^%d", *(float*)p->content, i);
    Get(p,i,p->content);
}