Jeck_coursework

// Kyrsach.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include<iostream>
#include<iomanip>
#include<cstdlib>
#include <ctime>
#include <thread>
#include <chrono>

using namespace std;
template <typename T>

float float_type(T a, T b,T cmp)
{
    auto start = std::chrono::high_resolution_clock::now();
    auto stop = start;

    _asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fsub b
        fstp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(subtraction)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(subtraction)\n";
    start = std::chrono::high_resolution_clock::now();

    _asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fadd b
        fstp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(addition)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(addition)\n";
    start = std::chrono::high_resolution_clock::now();

    _asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fmul b
        fstp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(multiplication)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(multiplication)\n";
    start = std::chrono::high_resolution_clock::now();

    _asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fdiv b
        fstp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(division)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(division)\n";
    start = std::chrono::high_resolution_clock::now();


    return EXIT_SUCCESS;
}

template <typename T>
int int_type(T a, T b, T cmp)
{

    auto start = std::chrono::high_resolution_clock::now();
    auto stop = start;
    __asm{
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fild a
        fisub b
        fistp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(subtraction)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(subtraction)\n";
    start = std::chrono::high_resolution_clock::now();

    __asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fild a
        fiadd b
        fistp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(addition)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(addition)\n";
    start = std::chrono::high_resolution_clock::now();

    __asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fild a
        fimul b
        fistp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(multiplication)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(multiplication)\n";
    start = std::chrono::high_resolution_clock::now();

    __asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fild a
        fidiv b
        fistp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(division)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(division)\n";

    return EXIT_SUCCESS;

}

template <typename T>
double double_float(double a, T b, double cmp)
{
    auto start = std::chrono::high_resolution_clock::now();
    auto stop = start;

    _asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fsub b
        fstp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(subtraction)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(subtraction)\n";
    start = std::chrono::high_resolution_clock::now();

    _asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fadd b
        fstp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(addition)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(addition)\n";
    start = std::chrono::high_resolution_clock::now();

    _asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fmul b
        fstp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(multiplication)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(multiplication)\n";
    start = std::chrono::high_resolution_clock::now();

    _asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fdiv b
        fstp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(division)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(division)\n";
    start = std::chrono::high_resolution_clock::now();


    return EXIT_SUCCESS;
}

template <typename T>
long float long_float(long float a, T b, long float cmp)
{
    auto start = std::chrono::high_resolution_clock::now();
    auto stop = start;

    _asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fsub b
        fstp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(subtraction)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(subtraction)\n";
    start = std::chrono::high_resolution_clock::now();

    _asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fadd b
        fstp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(addition)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(addition)\n";
    start = std::chrono::high_resolution_clock::now();

    _asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fmul b
        fstp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(multiplication)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(multiplication)\n";
    start = std::chrono::high_resolution_clock::now();

    _asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fdiv b
        fstp cmp
    }
    stop = std::chrono::high_resolution_clock::now();
    std::cout << "Cmp=" << cmp << std::endl;
    std::cout << "\nTime: " << std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() << " nanoseconds(division)\n";
    std::cout << "\nTime of one math operation: " << std::chrono::duration_cast<std::chrono::nanoseconds>((stop - start) / numb_of_operation).count() << " nanoseconds(division)\n";
    start = std::chrono::high_resolution_clock::now();


    return EXIT_SUCCESS;
}


auto start = std::chrono::high_resolution_clock::now();
auto stop = start;
int cmp, res, numb_of_operation = 8; float cmp_;
double cmp__;
long float fcmp;


/*int multiplication (int, int, int);
int division (int, int, int);
int subtraction (int, int, int);
int addition (int, int, int);
float addition_f (float, float,float,float);
float subtraction_f(float, float, float, float);*/


int main()
{
    int a=0, b=0, ch=10;
    float a_=0, b_=0;
    double a__=0;
    long float fa = 0;
    while (ch != 0)
    {
        std::cout << "Choose 1) Working with floating type" << std::endl << std::setw(31) << right <<
            "2) Working with integer " << std::endl << std::setw(36) << right <<
            "3) Working with double-float " << std::endl << std::setw(34) << right <<
            "4) Working with long-float " << std::endl << std::setw(15) << right <<
            "0) EXIT " << std::endl;
        std::cin >> ch;

        switch (ch)
        {
        case 1:
        {
            std::cout << "Enter A,B" << std::endl;
            std::cin >> a_ >> b_;
            float_type(a_, b_, cmp_);
            break;
        }
        case 2:
        {
            std::cout << "Enter A,B" << std::endl;
            std::cin >> a >> b;
            cmp = 0;
            int_type(a, b, cmp);
            break;
        }
        case 3:
        {
            std::cout << "Enter A,B" << std::endl;
            std::cin >> a__ >> b_;
            cmp = 0;
            double_float(a__, b_, cmp__);
            break; }
        case 4:
        {
            std::cout << "Enter A,B" << std::endl;
            std::cin >> fa >> b_;
            cmp = 0;
            long_float(fa, b_, fcmp);
            break;
        }
        }
    }

    /*multiplication(a,b,cmp);
    division(a, b, cmp);
    subtraction(a, b, cmp);
    addition(a, b, cmp);
    addition_f(d,f,h,cmp_);*/
    return 0;
}

/*
int multiplication(int a, int b, int cmp)
{
    init = clock();
    __asm {
        mov ebx, a
        mov eax, b
        mul ebx
        mov cmp, eax
    }
    final = clock(); //- init;
    std::cout << "Cmp=" << cmp << std::endl<<"Time="<< ((double)final-init) / ((double)CLOCKS_PER_SEC)<<endl;
    return EXIT_SUCCESS;
}
int division(int a, int b, int cmp) {
    __asm {
        mov ebx, a
        mov eax, b
        cwd
        div ebx
        mov cmp, eax
    }
    std::cout << "Cmp=" << cmp << std::endl;
    return EXIT_SUCCESS;
}
int subtraction(int a, int b, int cmp) {
    __asm {
        mov ebx, a
        mov eax, b
        sub eax,ebx
        mov cmp, eax
    }
    std::cout << "Cmp=" << cmp << std::endl;
    return EXIT_SUCCESS;
}

int addition(int a, int b, int cmp) {
    __asm {
        mov ebx, a
        mov eax, b
        add eax,ebx
        mov cmp, eax
    }
    std::cout << "Cmp=" << cmp << std::endl;
    return EXIT_SUCCESS;
}
float addition_f(float a, float b, float c, float cmp) {
    __asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fadd b
        fstp cmp
    }
    std::cout << "Cmp=" << cmp << std::endl;
    __asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fadd c
        fstp cmp
    }
    std::cout << "Cmp=" << cmp << std::endl;
    return EXIT_SUCCESS;
}

float subtraction_f(float a, float b, float c, float cmp) {
    __asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld a
        fsub b
        fstp cmp
    }
    std::cout << "Cmp=" << cmp << std::endl;
    __asm {
        xor eax, eax
        xor ebx, ebx
        xor ecx, ecx
        xor edx, edx
        finit
        fld c
        fsub a
        fstp cmp
    }
    std::cout << "Cmp=" << cmp << std::endl;
    return EXIT_SUCCESS;
}
*/