<repo_name>yaolya/exam<file_sep>/include/Hp.h
#pragma once
#include <iostream>
#include "storage.h"
#include "error.h"

class Hp {
private:
	Storage<int> m_n; //нормальный вектор
	Storage<int> m_x0; //точка,через которую проходит гиперплоскость	
	int m_size;
public:
	Hp(Storage<int>& n, Storage<int>& x0, int razm);

	double distance(Storage<int>& point);

	void position(Storage<int>& point);

	bool operator==(Hp& hp2);

	int getSizeofHp() { return --m_size; }
};
<file_sep>/src/main.cpp
#include <iostream>
#include "Hp.h"

/*3. Реализовать класс "гиперплоскость в n-мерном пространстве", с
возможностями проверки совпадения двух гиперплоскостей, а также
проверки для заданной точки нахождения на гиперплоскости, или в
положительном (отрицательном) полупространстве относительно нее.*/

void testCreation() {
	Storage<int> nv1;
	Storage<int> point;
	int n = 2;
	//std::cin >> n;
	/*std::cout << "Normalny vector" << std::endl;
	for (int i = 0; i < n - 1; ++i) {
		std::cin >> nv[i];
	}
	std::cout << "Tochka" << std::endl;
	for (int i = 0; i < n - 1; ++i) {
		std::cin >> p[i];
	}*/
	nv1.add(1);
	nv1.add(2);
	point.add(2);
	point.add(4);

	Hp hp1(nv1, point, n);

	std::cout << hp1.getSizeofHp() << std::endl;
}

void testEqual() {
	Storage<int> nv1;
	Storage<int> nv2;
	Storage<int> nv3;
	Storage<int> p;
	Storage<int> point;
	int n = 2;
	nv1.add(1);
	nv1.add(2);
	nv2.add(2);
	nv2.add(4);
	nv3.add(2);
	nv3.add(7);
	p.add(2);
	p.add(4);
	point.add(2);
	point.add(4);

	Hp hp1(nv1, p, n);
	Hp hp2(nv2, p, n);
	Hp hp3(nv3, p, n);
	std::cout << "Equal? " << (hp1 == hp2) << std::endl;
	std::cout << "Equal? " << (hp1 == hp3) << std::endl;
}

void testDistance() {
	Storage<int> nv;
	Storage<int> p;
	Storage<int> point;
	Storage<int> point2;
	int n = 2;
	nv.add(1);
	nv.add(2);
	p.add(2);
	p.add(4);
	point.add(2);
	point.add(4);
	point2.add(3);
	point2.add(8);

	Hp hp(nv, p, n);

	std::cout << "Distance " << hp.distance(point) << std::endl;
	std::cout << "Distance " << hp.distance(point2) << std::endl;
}

void testPosition() {
	Storage<int> nv;
	Storage<int> p;
	Storage<int> point;
	Storage<int> point2;
	int n = 2;
	nv.add(1);
	nv.add(2);
	p.add(2);
	p.add(4);
	point.add(2);
	point.add(4);
	point2.add(3);
	point2.add(8);

	Hp hp(nv, p, n);

	hp.position(point);
	hp.position(point2);
}

int main() {

	testCreation();
	testDistance();
	testEqual();
	testPosition();

	return 0;
}
<file_sep>/include/error.h
#pragma once

class Error
{
public:
	Error()
	{

	}
};

class BadArgument
{
public:
	BadArgument()
	{

	}
};<file_sep>/src/Hp.cpp
#include "Hp.h"

	Hp::Hp(Storage<int>& n, Storage<int>& x0, int razm) {
		m_n = n;
		m_x0 = x0;
		m_size = razm;
	}

	double Hp::distance(Storage<int>& point) {
		if (point.size() != m_size) throw Error();
		int sum = 0;
		for (int i = 0; i < m_size; ++i) {
			sum += (point[i] - m_x0[i]) * m_n[i];
		}
		int lengthp_x0 = sum;
		sum = 0;
		for (int i = 0; i < m_size; ++i) {
			sum += pow(m_n[i], 2);
		}
		int lengthn = sqrt(sum);
		return lengthp_x0 / lengthn;
	}

	bool Hp::operator==(Hp& hp2) {
		bool b = true;
		if (m_size == hp2.m_size) {
			for (int i = 0; i < m_size; ++i) {
				if (!(m_x0[i] == hp2.m_x0[i] && ((m_n[i] % hp2.m_n[i]) == 0 || (hp2.m_n[i] % m_n[i]) == 0))) b = false;
			}
		}
		else {
			int min_size = 0;
			(m_size < hp2.m_size) ? min_size = m_size : min_size = hp2.m_size;
			for (int i = 0; i < min_size; ++i) {
				if (!(m_x0[i] == hp2.m_x0[i] && (m_n[i] % hp2.m_n[i] == 0 || hp2.m_n[i] % m_n[i] == 0))) b = false;
			}
		}
		return b;
	}

	void Hp::position(Storage<int>& point) {
		int sum = 0;
		for (int i = 0; i < m_size; ++i) {
			sum += (point[i] - m_x0[i]) * m_n[i];
		}
		if (sum > 0) std::cout << "point is situated in +" << std::endl;
		if (sum < 0) std::cout << "point is situated in -" << std::endl;
		if (sum == 0) std::cout << "point belongs" << std::endl;
	}
<file_sep>/README.md
# exam
георгин
exam in computer programming
