Normal vector by Mankyu Sung

7701583_Ethan_Hernou

ethanhernou — 2024-09-23 05:17:21 UTC

#define GLM_ENABLE_EXPERIMENTAL
    #include 
    #include 
#include 

glm::vec3 CalculateNormal(const glm::vec3 &p1, const glm::vec3 &p2, const glm::vec3 &p3)
{
    glm::vec3 v1 = p2 - p1;
    glm::vec3 v2 = p3 - p1;

    return glm::normalize(glm::cross(v1, v2));
}

int main()
{
    glm::vec3 p1(3.0f, 0.0f ,  0.f);
    glm::vec3 p2(1.5f, 0.86f,  0.f);
    glm::vec3 p3(3.0f, 0.0f , -1.f);

    glm::vec3 normal = CalculateNormal(p1, p2, p3);

    std::cout << "Normal of the triangle : " << glm::to_string(normal) << std::endl;
    return 0;
}

7701567_Enzo_Garnier

bestioslash — 2024-09-23 05:17:31 UTC

#define GLM_ENABLE_EXPERIMENTAL
#include 
#include 
#include 

glm::vec3 CalculateNormal(const glm::vec3& p0, const glm::vec3& p1, const glm::vec3& p2) {
	return glm::normalize(glm::cross(p1 - p0, p2 - p0));
}

int main() {
	glm::vec3 p0(3, 0, 0);
	glm::vec3 p1(1.5f, 0.86f, 0);
	glm::vec3 p2(3, 0, -1);

	glm::vec3 normal = CalculateNormal(p0, p1, p2);
	std::cout << "Normal: " << glm::to_string(normal) << std::endl;

	return 0;
}

7701676_Thomas_Laprie

totolaprie — 2024-09-23 05:20:20 UTC

#define GLM_FORCE_SWIZZLE

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 normal = glm::normalize(glm::cross(v1, v2));

std::cout << "Normal: " << glm::to_string(normal) << std::endl;

}

7701664 Eliot Janvier

2024-09-23 05:20:29 UTC

#define GLM_ENABLE_EXPERIMENTAL
#include 
#include 
#include 
#include 

int main() {
  glm::vec3 p1(3, 0, 0);
  glm::vec3 p2(1.5, 0.86, 0);
  glm::vec3 p3(3, 0, -1);

  glm::vec3 side1 = p2 - p1;
  glm::vec3 side2 = p3 - p1;

  glm::vec3 normal = glm::normalize(glm::cross(side1, side2));
  std::cout << "normal is " << glm::to_string(normal) << std::endl;
}

7701639_Hippolyte_Aubert

2024-09-23 05:21:35 UTC

void calculateTriangleNormal()

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5f, 0.86f, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 normal = glm::normalize(glm::cross(v1, v2));

std::cout << "Normal: " << glm::to_string(normal) << std::endl;

}

int main()

{

calculateTriangleNormal();

return 0;

}

7701520_Adele_de_Premonville

2024-09-23 05:21:42 UTC

#include

# define GLM_ENABLE_EXPERIMENTAL

#include

using namespace std;

int main()

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 c = glm::cross(v1, v2);

glm::vec3 res = glm::normalize(c);

cout << glm::to_string(res) << endl;

return 0;

}

7701618_Yann_Demuyt

yanndemuyt — 2024-09-23 05:21:46 UTC

glm::vec3 calc_triangle_normal(glm::vec3 p1, glm::vec3 p2, glm::vec3 p3) {
    glm::vec3 v1 = p2 - p1;
    glm::vec3 v2 = p3 - p1;

    return glm::normalize(glm::cross(v1, v2));
}


int main() {
    glm::vec3 p1(3, 0, 0);
    glm::vec3 p2(1.5f, 0.86f, 0);
    glm::vec3 p3(3, 0, -1);
    std::cout << glm::to_string(calc_triangle_normal(p1, p2, p3)) << std::endl;   
}

7701539_Clos-manescau_leonore

tenshiitv — 2024-09-23 05:22:47 UTC

static void exo5()

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 normalv(0, 0, 0);

glm::vec3 result(0, 0, 0);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

normalv = glm::cross(v1, v2);

normalv = glm::normalize(normalv);

std::cout << "Exo5" << std::endl;

std::cout << glm::to_string(normalv) << std::endl;

}

7701640 HILLION Jovan

2024-09-23 05:22:52 UTC

#include "GameGraphicsCourses.h"

#include

int main()

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 normal = glm::cross(v1, v2);

normal = glm::normalize(normal);

std::cout << "normal = " << glm::to_string(normal) << std::endl;

return 0;

}

7701622_Rayan_Banni

bannirayan — 2024-09-23 05:22:57 UTC

#include 
#include 
#include 

int main() {
    glm::vec3 p1(3, 0, 0);
    glm::vec3 p2(1.5, 0.86, 0);
    glm::vec3 p3(3, 0, -1);

    glm::vec3 v1 = p2 - p1;
    glm::vec3 v2 = p3 - p1;

    glm::vec3 normal = glm::cross(v1, v2);

    glm::vec3 normalizedNormal = glm::normalize(normal);

    std::cout << "(" << normalizedNormal.x << ", " << normalizedNormal.y << ", " << normalizedNormal.z << ")" << std::endl;

    return 0;
}

7701672 Louis Bassagal

2024-09-23 05:23:07 UTC

#include 
#include 
#include 
#include "CMakeProject2.h"
#include 

void main() {
	glm::vec3 p1{ 3, 0, 0 };
	glm::vec3 p2{ 1.5f, 0.86f, 0 };
	glm::vec3 p3{ 3, 0, -1 };

	glm::vec3 v1 = p2 - p1;
	glm::vec3 v2 = p3 - p1;

	std::cout << glm::to_string(glm::normalize(glm::cross(v1, v2))) << std::endl;
}

7701505_Axel_Denis

therabbitlexa271 — 2024-09-23 05:23:42 UTC

#define GLM_ENABLE_EXPERIMENTAL
#include 
#include 
#include 
#include 

int main() {
	glm::vec3 p1(3, 0, 0);
	glm::vec3 p2(1.5, 0.86, 0);
	glm::vec3 p3(3, 0, -1);

	glm::vec3 v1 = p1 - p2;
	glm::vec3 v2 = p1 - p3;

	glm::vec3 normal = glm::normalize(glm::cross(v1, v2));
	std::cout << glm::to_string(normal) << std::endl;
}

7701595 Denis Maillot

d3nxfr — 2024-09-23 05:24:03 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

template

void display(T x, const std::string& prefix = "") {

std::cout << prefix << glm::to_string(x) << std::endl;

}

int main(void) {

glm::vec3 p1(3.f, 0, 0);

glm::vec3 p2(1.5f, 0.86f, 0);

glm::vec3 p3(3.f, 0, -1.f);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p2;

display(glm::normalize(glm::cross(v1, v2)), "normal: ");

return 0;

}

7701564 Arthur Aillet

2024-09-23 05:24:04 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main() {

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 norm = glm::normalize(glm::cross(p2 - p1, p3 - p1));

std::cout << "normal: " << glm::to_string(norm) << std::endl;

return 0;

}

7701504_Alexandre_Franquet

alexandrefranquetty — 2024-09-23 05:24:11 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v32 = p3 - p2;

glm::vec3 v12 = p1 - p2;

glm::vec3 normal = glm::normalize(glm::cross(v32, v12));

std::cout << glm::to_string(normal) << std::endl;

return (0);

}

7701532 Yassin said

2024-09-23 05:24:13 UTC

// CMakeProject2.cpp : définit le point d'entrée de l'application.

#define GLM_ENABLE_EXPERIMENTAL

#define GLM_FORCE_SWIZZLE

#include "glm/gtx/string_cast.hpp"

#include "CMakeProject2.h"

#include "glm/glm.hpp"

#include

int main()

{

const double DEGREES_TO_RADIANS = glm::pi() / 180.0;

const double RADIANS_TO_DEGREES = 180.0 / glm::pi();

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1(1.5 - 3, 0.86 - 0, 0 - 0);

glm::vec3 v2(3 - 3, 0 - 0, -1 - 0);

glm::vec3 c = glm::cross(glm::normalize(v1), glm::normalize(v2));

std::cout << glm::to_string(c);

return 0;

}

7701663_samuel_florentin

2024-09-23 05:24:15 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include "CMakeProject1.h"

#include

const constexpr float TEST = glm::pi();

int main()

{

glm::vec3 p1{ 3, 0, 0 };

glm::vec3 p2{ 1.5, 0.86, 0 };

glm::vec3 p3{ 3, 0, -1 };

glm::vec3 v1{ p2 - p1 };

glm::vec3 v2{ p3 - p1 };

glm::vec3 cross_product{ glm::cross(v1, v2) };

glm::vec3 normalised{ glm::normalize(cross_product) };

std::cout << "normal vector: " << glm::to_string(normalised) << '\n';

return 0;

}

7701465 Guillaume CLEMENT--BONNIEL-VEYRON

lapuissancedelafunk — 2024-09-23 05:24:17 UTC

#define GLM_FORCE_SWIZZLE

#define GLM_ENABLE_EXPERIMENTAL

#include

const double DEG_TO_RAD = glm::pi() / 180.0;

const double RAD_TO_DEG = 180.0 / glm::pi();

int main()

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 normal = glm::normalize(glm::cross(v1, v2));

std::cout << "Normal: " << glm::to_string(normal) << std::endl;

return 0;

}

7701538_Romain_PANNO

romainpanno — 2024-09-23 05:24:42 UTC

void ex3(void) {

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 n = glm::cross(v1, v2);

n = glm::normalize(n);

std::cout << "n: " << n.x << " " << n.y << " " << n.z << std::endl;

}

int main(void) {

ex3();

return 0;

}

7701473_Ulysse_Decottignies

odycepro — 2024-09-23 05:25:08 UTC

#define GLM_FORCE_SWIZZLE

#define GLM_ENABLE_EXPERIMENTAL

#include

static void normVec() {

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 N = glm::normalize(glm::cross(v1, v2));

std::cout << to_string(N) << std::endl;

}

int main() {

normVec();

return 0;

}

7701650_LHUILLIER_leo

leolhulhuillierleoillier — 2024-09-23 05:25:10 UTC

glm::vec3 PointSub(glm::vec3 b, glm::vec3 a) {

return (b - a);

}

glm::vec3 GetNormal(glm::vec3 p1, glm::vec3 p2, glm::vec3 p3) {

glm::vec3 v1 = PointSub(p1, p2);

glm::vec3 v2 = PointSub(p3, p2);

glm::vec3 normal = glm::normalize(glm::cross(v1, v2));

return normal;

}

int main() {

std::cout << glm::to_string(GetNormal(glm::vec3(1.5, 0.86, 0), glm::vec3(3, 0, 1), glm::vec3(3, 0, 0)));

return 0;

}

7701669_EWEN_BRIAND

2024-09-23 05:25:41 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main(void)

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 normal = glm::normalize(glm::cross(v1, v2));

std::cout << glm::to_string(normal) << std::endl;

}

7701674 - BOUSCH Laetitia

2024-09-23 05:25:53 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

void main()

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

//p2 -> p3 -> p1

glm::vec3 v1F = p3 - p2;

glm::vec3 v2F = p1 - p2;

glm::vec3 normalF = glm::cross(v1F, v2F);

glm::vec3 n = glm::normalize(normalF);

std::cout << "Result for p2->p3->p1: " << glm::to_string(n) << std::endl;

//p3 -> p1 -> p2

glm::vec3 v1S = p1 - p3;

glm::vec3 v2S = p2 - p3;

glm::vec3 normalS = glm::cross(v1S, v2S);

glm::vec3 d = glm::normalize(normalS);

std::cout << "Result for p3->p1->p2: " << glm::to_string(d) << std::endl;

}

7701596_Tovy_REN

2024-09-23 05:26:32 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main() {

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 normal = glm::normalize(glm::cross(p2 - p1, p3 - p1));

std::cout << "Normal: " << glm::to_string(normal) << std::endl;

return 0;

}

7701516 SOIDIKI Léo

2024-09-23 05:26:33 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

static void triangleNormal()

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 normal = glm::normalize(glm::cross(v1, v2));

std::cout << "normal = " << glm::to_string(normal);

}

int main()

{

triangleNormal();

return 0;

}

7701587 Apolline Fontaine

2024-09-23 05:27:04 UTC


int main() {
    glm::vec3 p1(3, 0, 0);
    glm::vec3 p2(1.5, 0.86, 0);
    glm::vec3 p3(3, 0, -1);

    glm::vec3 v1 = (p2-p1);
    glm::vec3 v2 = (p3-p1);

    std::cout << "normal  " << glm::to_string(glm::normalize(glm::cross(v1,v2))) << std::endl;

    return 0;
}

7701613 - Tom Daniel

2024-09-23 05:27:12 UTC

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 n = glm::cross(v1, v2);

n = glm::normalize(n);

std::cout << glm::to_string(n) << std::endl;

7701625_Ludovic_de_Chavagnac

ludovicdechavagnac — 2024-09-23 05:27:12 UTC

#define GLM_ENABLE_EXPERIMENTAL
#include 
#include 
#include 
#include 

glm::vec3 normalize(glm::vec3 p1, glm::vec3 p2, glm::vec3 p3) {
	glm::vec3 v1 = p2 - p1;
	glm::vec3 v2 = p3 - p1;
	return glm::normalize(glm::cross(v1, v2));
}

int main() {
	glm::vec3 p1(3, 0, 0);
	glm::vec3 p2(1.5, 0.86, 0);
	glm::vec3 p3(3, 0, -1);

	std::cout << "The normal is: " << glm::to_string(normalize(p1, p2, p3)) << std::endl;
	return 0;
}

7701542_MARQUES_Mathieu

2024-09-23 05:27:13 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include 
#include 
#include 

glm::vec3 calculateNormal(glm::vec3 p1, glm::vec3 p2, glm::vec3 p3)
{
	glm::vec3 v1 = p2 - p1;
	glm::vec3 v2 = p3 - p1;

	glm::vec3 normal = glm::cross(v1, v2);
	return glm::normalize(normal);
}

int main()
{
	glm::vec3 p1(3, 0, 0);
	glm::vec3 p2(1.5, 0.86, 0);
	glm::vec3 p3(3, 0, -1);

	glm::vec3 res = calculateNormal(p1, p2, p3);

	std::cout << glm::to_string(res) << std::endl;

	return 0;
}

7701546_Clément_Lagier

clementlagier — 2024-09-23 05:27:38 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main(void)

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

std::cout << "Result: " << glm::to_string(glm::normalize(glm::cross(v1, v2))) << std::endl;

return 0;

}

7701550_Aldric_Jourdain

2024-09-23 05:27:44 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include 

#include 
#include 
#include 

int main() {

	glm::vec3 p1(3, 0, 0);
	glm::vec3 p2(1.5f, 0.86f, 0);
	glm::vec3 p3(3, 0, -1);

	glm::vec3 v1 = p2 - p1;
	glm::vec3 v2 = p3 - p1;
	glm::vec3 normal = glm::normalize(glm::cross(v1, v2));
	std::cout << "Normal: " << glm::to_string(normal) << std::endl;
	return 0;
}

7701604 Sacha TOPALOFF

2024-09-23 05:27:56 UTC

#include 
#include 

#include 
#include 

#define GLM_

int main()
{
	glm::vec3 p1(3, 0, 0);
	glm::vec3 p2(1.5f, 0.86f, 0);
	glm::vec3 p3(3, 0, -1);


	glm::vec3 normal = glm::normalize(glm::cross((p1 - p3), (p2 - p3)));

	std::cout << "Normal vector: " << glm::to_string(normal) << std::endl;
}

7701576_Turpin_Raphaël

raphaelturpin20 — 2024-09-23 05:28:18 UTC


#include 

#define GLM_ENABLE_EXPERIMENTAL

#include 
#include 

int main(void) {
    glm::vec3 p1(3, 0, 0);
    glm::vec3 p2(1.5, 0.86, 0);
    glm::vec3 p3(3, 0, -1);

    glm::vec3 n = glm::normalize(glm::cross((p2 - p1), (p3 - p1)));

    std::cout << glm::to_string(n) << std::endl;

    return 0;
}

7701592_Nathan_HOAREAU

2024-09-23 05:28:26 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

#include "glm/glm.hpp"

#include "glm/gtc/constants.hpp"

#include "glm/gtx/string_cast.hpp"

int main()

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p3 - p2;

glm::vec3 v2 = p1 - p2; // p2 -> p3 -> p1

glm::vec3 normal = glm::normalize(glm::cross(v1, v2));

std::cout << "Normal = " << glm::to_string(normal) << std::endl;

return 0;

}

7701581 MARTINS GANDRA Hugo

2024-09-23 05:28:45 UTC

#define GLM_FORCE_SWIZZLE

#define GLM_ENABLE_EXPERIMENTAL

#include "CMakeProject1.h"

#include

using namespace std;

int main()

{

const float DEGREES_TO_RADIANS = glm::pi() / 180.0;

const float RADIANS_TO_DEGREES = 180.0 / glm::pi();

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 normal = glm::normalize(glm::cross(v1, v2));

std::cout << "Normal: " << glm::to_string(normal) << std::endl;

return 0;

}

7701521_DESOUSA_Brice

2024-09-23 05:29:57 UTC

int main()

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5f, 0.86f, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 norm = glm::cross(glm::normalize(v1), glm::normalize(v2));

std::cout << "Result : " << glm::to_string(norm) << std::endl;

return 0;

}

7701562 Julian Scott

2024-09-23 05:30:41 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include "CMakeProject1.h"

#include "iostream"
#include "glm/gtc/constants.hpp"
#include "glm/vec3.hpp"
#include "glm/glm.hpp"
#include "glm/gtx/string_cast.hpp"

using namespace std;


int main()
{
	constexpr double RADIANS_TO_DEGREES = 180.0 / glm::pi();

	const glm::vec3 p1(3, 0, 0);
	const glm::vec3 p2(1.5, 0.86, 0);
	const glm::vec3 p3(3, 0, -1);

	const auto a = p2 - p1;
	const auto b = p3 - p1;
	
	const auto n = glm::normalize(glm::cross(a, b));

	std::cout << "normal = " << glm::to_string(n) << std::endl;

	return 0;
}

7701565 Axel HUMEAU

axelhumeau — 2024-09-23 05:31:02 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 n = glm::normalize(glm::cross(v1, v2));

std::cout << "The normal vector is " << glm::to_string(n) << std::endl;

return 0;

}

5854324_PHANXUANTU

jctudolahoi123 — 2024-09-23 05:47:26 UTC

#include

int main() {

glm::vec3 p1(3, 0, 0);

glm::vec3 p2(1.5, 0.86, 0);

glm::vec3 p3(3, 0, -1);

glm::vec3 v1 = p2 - p1;

glm::vec3 v2 = p3 - p1;

glm::vec3 normal = glm::cross(v1, v2);

glm::vec3 normalizedNormal = glm::normalize(normal);

std::cout << "(" << normalizedNormal.x << "," << normalizedNormal.y << "," << normalizedNormal.z << ")" << std::endl;

return 0;

}