25/03

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
struct Interval{
    unsigned long vec;// 0 - инверсия 1 - без инверсии
    unsigned long dnc; //  '-'. ЧЕрточка - 1
};



// Функция IsEqual проверяет два интервала на равенство, если они равны, то функция возвращает true, игаче false
// Расммотрим пример
// два интервала u и v
// u = 0-1-110-         v = 1-1-0100
// dnc=01010001         dnc=01010000
// vec=00101100         vec=10100100
//     01111101  не равен   11110100 Следовательно возвращаем false

bool IsEqual(struct Interval u, struct Interval v) {
    if(u.vec | u.dnc == v.vec | v.dnc) return true;
    return false;
}


// Функция IsOrthogonal Проверяет два интервала на ортогональность
// Получает на вход struct Interval u, struct Interval v
// На выходе получаем int = 1 - если два интервала ортогональны
// int = 0 - если два интервала неортогональны
// Расммотрим пример
// два интервала u и v
// u = 0-1-110-         v = 1-1-0100
// dnc=01010001         dnc=01010000
// vec=00101100         vec=10100100
// v.dnc = 01010000 * выполняем лог.сложенте
// u.dnc = 01010001
// tmpUV = 01010001
//  Вектор tmpUV - маска компонент, на которые нам не нужно обращать
// Накладываем маску на векторы
// v.vec = 10100100 * выполняем лог.сложенте
// tmpUV = 01010001
// tmpV  = 11110101
//
// u.vec = 00101100 * выполняем лог.сложенте
// tmpUV = 01010001
// tmpU  = 01111101
//
// Делаем сумму по модулю между tmpU u tmpV
//
// tmpU  = 01111101
// tmpV  = 11110101
//  Otvet =10001000  != 0  Следовательно интервалы ортогональны
// Если посмотреть на эти интервалы, то действительно - они ортогональны
int IsOrthogonal(struct Interval u, struct Interval v) {
    unsigned long tmpUV, tmpU, tmpV;
    tmpUV = v.dnc | u.dnc;
    tmpU = u.vec | tmpUV;
    tmpV = v.vec | tmpUV;

    if ((tmpU ^ tmpV) != 0) return 1;
    return 0;
}
// Функция, которая проверяет на пересечение два интервала "u" и "v"
// Расммотрим пример
// два интервала u и v
// u = 0-1-110-         v = 1-1-0100
// dnc=01010001         dnc=01010000
// vec=00101100         vec=10100100
//tmpU=01111101        tmpV=11110100
// Пересечение
// tmpU=01111101
// tmpV=11110100
//Otvet=01110100 != 0 следовательно интервалы пересекаются => int = 1;

int Cross(struct Interval u, struct Interval v){
    unsigned long tmpU, tmpV;
    tmpU = u.vec | u.dnc; // Накладываем dnc и vec, интервала для поиска пересечения двух интервалов
    tmpV = v.vec | v.dnc;
    if(tmpU & tmpV) return 1; // Если пересечение двух массок не равно 0, то интервалы пересекаются
    return 0; // Если tmpU & tmpV == NULL , то интервалы не пересекаются
}


// Функция Merging которая ищет пересечение двух интервалов и записывает по адресу S
// Функция аналогична фун-ии Cross, только нужно полученные данные преобразовать в новый интервал
// Расммотрим пример
// два интервала u и v
// u = 0-1-110-         v = 1-1-0100
// dnc=01010001         dnc=01010000
// vec=00101100         vec=10100100
//tmpU=01111101        tmpV=11110100
// Пересечение
// tmpU=01111101
// tmpV=11110100
//tmpUV=01110100
// Ищем dnc нового вектора
//
// u.dnc | v.dnc = 01010001 | 01010000 = 01010001 &
//                                 tmpUV=01110100
//                              (*S).dnc=01010000
// Совершаем сумму по модулю, чтобы найти Vec
// (*S).dnc=01010000
//    tmpUV=01110100
// (*S).vec=00100100
void Merging(struct Interval u, struct Interval v, struct Interval *S){
    unsigned long tmpUV, tmpU, tmpV;
    tmpU= u.dnc | u.vec;
    tmpV= v.dnc | v.vec;
    tmpUV= tmpU & tmpV;
    (*S).dnc= tmpUV & (u.dnc | v.dnc);
    (*S).vec=  (*S).dnc ^ tmpUV;
    return;
}



// Функция IsOneOrthogonal Проверяет два интервала на ортогональность по одной переменной
// Получает на вход struct Interval u, struct Interval v
// На выходе получаем int = 1 - если два интервала ортогональны
// int = 0 - если два интервала неортогональны или ортогональны, но больше, чем по одной переменной.
// Действия и логика аналогичные функции IsOrthogonal, только в конце функции мы совершаем подсчет компонент =1
// И если кол-во компонент равных единицы равно 1, то интервалы ортогональны по одной переменной. Возвращаем int = 1 - Правда
// Иначе возвращаем 0 - ложь
// Расммотрим пример
// два интервала u и v
// u = 0-1-110-         v = 1-1-0100
// dnc=01010001         dnc=01010000
// vec=00101100         vec=10100100
// v.dnc = 01010000 * выполняем лог.сложенте
// u.dnc = 01010001
// tmpUV = 01010001
//  Вектор tmpUV - маска компонент, на которые нам не нужно обращать
// Накладываем маску на векторы
// v.vec = 10100100 * выполняем лог.сложенте
// tmpUV = 01010001
// tmpV  = 11110101
//
// u.vec = 00101100 * выполняем лог.сложенте
// tmpUV = 01010001
// tmpU  = 01111101
//
// Делаем сумму по модулю между tmpU u tmpV
//
// tmpU  = 01111101
// tmpV  = 11110101
//    x =  10001000
// После подсчета битов x = 2 Следовательно вернем int = 0;
int IsOneOrthogonal(struct Interval u, struct Interval v) {
    unsigned long tmpUV, tmpU, tmpV,x;
    tmpUV = v.dnc | u.dnc;
    tmpU = u.vec | tmpUV;
    tmpV = v.vec | tmpUV;
    x= tmpU ^ tmpV;
    x = x * 0x08040201; // Создаются 4 копии
    x = x >> 3; // Удаление соответствующих битов
    x = x & 0x11111111; // Каждый 4-й бит
    x = x * 0x11111111; // Сумма цифр (0 или 1)
    x = x >> 28; // Положение результата
    if(x==1) return 1;
    return 0;
}
// Функция IsAbsorb проверяет интервалы на поглощение
// Если поглощает то функция возвращает true
// Иначе false
// Расммотрим пример
// два интервала u и v
// u = 0-1-110-         v = 1-1-0100
// dnc=01010001 |       dnc=01010000 |
// vec=00101100         vec=10100100
//tmpU=01111101        tmpV=11110100 | 01010001 = 11110101
// tmpU != tmpV Следовательно поглащения нет
bool IsAbsorb(struct Interval u, struct Interval v) {
    unsigned long tmpUV, tmpU, tmpV;
    tmpU = u.vec | u.dnc;
    tmpV = v.vec | v.dnc | u.dnc;
    if (tmpU == tmpV)
    return true;
    return false;
}


int main(int argc, char *argv[]) {
    struct Interval S;
    struct Interval u;
        u.vec=44;
        u.dnc=81;
    struct Interval v;
        v.vec=164;
        v.dnc=80;
    // -1-000-0
    Merging(u,v,&S);

    //printf("%d\n",IsOneOrthogonal(u,v));
    //Cross(u,v,p_S);
    printf("%d \n %d \n",S.vec,S.dnc);
    return 0;
}