dot Product Practice by Mankyu Sung

7701564_Arthur_Aillet

arthuraillet — 2024-09-11 00:23:50 UTC

#include 

#define GLM_ENABLE_EXPERIMENTAL

#include 
#include 

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

int main() {
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	float d = glm::dot(v, u);
	float lengths = glm::length(u) * glm::length(v);
	float degree = glm::acos(d / lengths);
	std::cout << "Result 1:" << glm::degrees(degree) << std::endl;
	std::cout << "Result 2:" << degree * DEGREES_TO_RADIANS << std::endl;

	return 0;
}

7701465_Guillaume_CLEMENT--BONNIEL-VEYRON

2024-09-11 00:25:26 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 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

const double v_dot_u = glm::dot(v, u);

const double v_angle_u = glm::acos(v_dot_u / (glm::length(v) glm::length(u))) RAD_TO_DEG;

std::cout << "v angle u: " << v_angle_u << std::endl;

return 0;

}

7701583_Ethan_Hernou

ethanhernou — 2024-09-11 00:25:26 UTC

#define GLM_ENABLE_EXPERIMENTAL
    #include 
    #include 
#include 

float CalculateDegrees(const glm::vec3 &v, const glm::vec3 &u)
{
    float dot     = glm::dot(v, u);
    float lengthV = glm::length(v);
    float lengthU = glm::length(u);

    return glm::degrees(acos(dot / (lengthV * lengthU)));
}

int main()
{
    glm::vec3 v(2.f, -1.f, 1.f);
    glm::vec3 u(1.f,  1.f, 2.f);

    float angle = CalculateDegrees(v, u);

    std::cout << "Angle between v and u : " << angle << std::endl;
    return 0;
}

7701596_Tovy_Ren

2024-09-11 00:26:02 UTC

#include

int main() {

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

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

glm::vec3 v(2,-1,1);

glm::vec3 u(1,1,2);

float deg = (glm::acos(glm::dot(v,u) / (glm::length(v) glm::length(u)))) RADIANS_TO_DEGREES;

std::cout << "Angle between vectors: " << deg << std::endl;

return 0;

}

7701639_Hippolyte_Aubert

2024-09-11 00:26:11 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

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

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

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float dot = glm::dot(v, u);

float angle = glm::acos(dot / (glm::length(v) glm::length(u))) * RADIANS_TO_DEGREES;

std::cout << "Angle between v and u: " << angle << std::endl;

return 0;

}

7701676_Thomas_Laprie

totolaprie — 2024-09-11 00:26:26 UTC

#define GLM_FORCE_SWIZZLE

#define GLM_ENABLE_EXPERIMENTAL

#include

int main()

{

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

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

glm::vec3 v (2, -1, 1);

glm::vec3 u (1, 1, 2);

float dot = glm::dot(v, u);

float result = dot / (glm::length(u) * glm::length(v));

float degrees = glm::acos(result) * RADIANS_TO_DEGREES;

std::cout << degrees << std::endl;

return 0;

}

7701595_Maillot_Denis

d3nxfr — 2024-09-11 00:26:40 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main(void) {

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

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

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float d = glm::dot(v, u);

float c = d / (glm::length(u) * glm::length(v));

float deg = glm::acos(c) * RADIANS_TO_DEGREES;

std::cout << "v: " << glm::to_string(v) << std::endl;

std::cout << "u: " << glm::to_string(u) << std::endl;

std::cout << "d: " << d << std::endl;

std::cout << "c: " << c << std::endl;

std::cout << "deg: " << deg << std::endl;

std::cout << "rad: " << glm::radians(deg) << std::endl;

return 0;

}

7701520_Adèle_de_Premonville

2024-09-11 00:27:04 UTC

#include

# define GLM_ENABLE_EXPERIMENTAL

#include

using namespace std;

int main()

{

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

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

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

const float dot = glm::dot(v, u);

const float cos = dot / (glm::length(v) * glm::length(u));

const float res = glm::acos(cos) * RADIANS_TO_DEGREES;

cout << res << endl;

return 0;

}

7701618_Yann_Demuyt

yanndemuyt — 2024-09-11 00:27:34 UTC

// // src/main.cpp
#define GLM_ENABLE_EXPERIMENTAL
#define GLM_FORCE_SWIZZLE

#include  // Include fmt library
#include 
#include 
#include 

#include 

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


    glm::vec3 v(2,-1,1);
    glm::vec3 u(1,1,2);

    float d = glm::dot(u, v);
    float angle = glm::acos((d / (glm::length(v) * glm::length(u)))) * RADIANS_TO_DEGREES;

    std::cout << "Angle is: " << angle << std::endl;


    return 0;
}

7701669_Briand_Ewen

2024-09-11 00:27:36 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

int main(void)

{

glm::vec3 v1(2, -1, 1);

glm::vec3 v2(1, 1, 2);

float dot = glm::dot(v1, v2);

float len = glm::length(v1) * glm::length(v2);

float r1 = dot / len;

float r2 = glm::degrees(glm::acos(r1));

std::cout << r2 << std::endl;

}

7701504_Alexandre_Franquet

alexandrefranquetty — 2024-09-11 00:27:48 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include 

#include 
#include 

float ex1()
{
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);
	float d = glm::dot(v, u);
	float c = d / (glm::length(u) * glm::length(v));
	return glm::degrees(glm::acos(c));
}

int main()
{
	std::cout << "Ex 1: " << ex1() << std::endl;
	return (0);
}

7701622_Rayan_Banni

bannirayan — 2024-09-11 00:27:51 UTC

#include 
#include 

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

int main(void) {
    glm::vec3 v(2, -1, 1);
    glm::vec3 u(1, 1, 2);

    float dot = glm::dot(v, u);

    float cos = dot / (glm::length(v) * glm::length(u));
    float deg = glm::acos(cos) * RADIANS_TO_DEGREES;

    std::cout << "Angle between vectors: " << deg << " degrees" << std::endl;
}

7701567_Enzo_Garnier

bestioslash — 2024-09-11 00:28:33 UTC

#include 
#include 
#include 

int main() {
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	float d = glm::dot(v, u);
	float c = d / (glm::length(u) * glm::length(v));
	float deg = glm::acos(c) * glm::degrees(1.0f);

	std::cout << "The angle between the vectors is " << deg << " degrees." << std::endl;

	return 0;
}

7701664 Eliot Janvier

2024-09-11 00:28:36 UTC

#define GLM_ENABLE_EXPERIMENTAL
#include 
#include 
#include 
#include 

int main() {
  glm::vec3 u(2, -1, 1);
  glm::vec3 v(1, 1, 2);

  float lu = glm::length(u);
  float lv = glm::length(v);

  if (lu == 0 or lv == 0) {
    throw std::runtime_error("div by zero");
  }
  float angleUV = glm::acos(glm::dot(u, v) / (lu * lv));

  std::cout << "angle is " << glm::degrees(angleUV) << " degrees" << std::endl;
  return 0;
}

7701663_Samuel_Florentin

2024-09-11 00:28:41 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include "CMakeProject1.h"

#include

int main()

{

glm::vec3 v{ 2, -1, 1 };

glm::vec3 u{ 1, 1, 2 };

float angle{glm::acos((glm::dot(v, u) / (glm::length(v) * glm::length(u))))};

float final{ glm::degrees(angle) };

std::cout << final << '\n';

return 0;

}

7701576_Turpin_Raphaël

raphaelturpin20 — 2024-09-11 00:29:20 UTC


#include 

#include 
#include 
#include 
#include 

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

int main(void) {
    glm::vec3 v(2,-1,1);
    glm::vec3 u(1,1,2);
    float d = glm::dot(v, u);
    float c = d / (glm::length(u) * glm::length(v));
    float deg = glm::acos(c)*RADIANS_TO_DEGREES;

    std::cout << "Dot product: " << d << std::endl;
    std::cout << "Cosine: " << c << std::endl;
    std::cout << "Angle: " << deg << std::endl;

    return 0;
}

7701505_Axel_Denis

therabbitlexa271 — 2024-09-11 00:29:23 UTC

#include 
#include 
#include 

int main() {
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	const float result_deg = glm::acos(glm::dot(v, u) / (glm::length(v) * glm::length(u)));
	std::cout << glm::degrees(result_deg) << std::endl;
}

7701473_Ulysse_Decottignies

odycepro — 2024-09-11 00:30:09 UTC

#define GLM_FORCE_SWIZZLE

#define GLM_ENABLE_EXPERIMENTAL

#include

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

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

static void dotTrain() {

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float dp = glm::dot(v, u);

float a = glm::acos(dp / (glm::length(v) * glm::length(u)));

std::cout << a * RADIANS_TO_DEGREES << std::endl;

}

int main() {

dotTrain();

return 0;

}

7701539_Leonore_clos-manescau

tenshiitv — 2024-09-11 00:30:11 UTC

#include "class3.h"

#include

int main()

{

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

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

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float d = glm::dot(v, u);

float c = d / (glm::length(u) * glm::length(v));

float deg = glm::acos(c) * RADIANS_TO_DEGREES;

std::cout << deg << std::endl;

return 0;

}

7701538_Romain_PANNO

romainpanno — 2024-09-11 00:30:26 UTC

#include "Source.h"

#include

int ex_dot_product_practice()

{

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

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

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float d = glm::dot(v, u);

float c = d / (glm::length(u) * glm::length(v));

float deg = glm::acos(c) * RADIANS_TO_DEGREES;

std::cout << "result: " << deg << std::endl;

return 0;

}

7701565_Axel_HUMEAU

axelhumeau — 2024-09-11 00:30:51 UTC

#define GLM_ENABLE_EXPERIMENTAL
#include 
#include 
#include 
#include 
#include 

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

int main()
{
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	float dotResult = glm::dot(u, v);
	float cosResult = dotResult / (glm::length(u) * glm::length(v));
	float angle = glm::acos(cosResult) * RADIANS_TO_DEGREES;
	std::cout << "Angle: " << angle << std::endl;
}

7701650_Leo_LHUILLIER

2024-09-11 00:31:23 UTC

int main() {

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float DP = glm::dot(v, u);

float cosD = DP / (glm::length(v) * glm::length(u));

float R = glm::acos(cosD);

float D = glm::degrees(R);

std::cout << "degree = " << D << std::endl;

return 0;

}

7701613_Tom_Daniel

tagemania — 2024-09-11 00:31:23 UTC

int main()
{
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);


	float d = glm::dot(v, u);
	float c = d / (glm::length(u) * glm::length(v));
	float deg = glm::acos(c) * RADIANS_TO_DEGREES;

	cout << "degrees: " << deg << endl;
	return 0;
}

7701581_Hugo_MARTINS_GANDRA

2024-09-11 00:31:38 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 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float d = glm::dot(v, u);

cout << "Result 1: " << glm::degrees(acos(d / (glm::length(v) * glm::length(u)))) << endl;

return 0;

}

7701587 Apolline Fontaine

apollinefontaine — 2024-09-11 00:31:56 UTC

#include 
#include // vec3, bvec3, dvec3, ivec3 and uvec3
#include 

#define GLM_ENABLE_EXPERIMENTAL
#include 

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

int main() {

    glm::vec3 v(2,-1,1);
    glm::vec3 u(1,1,2);

    float dotRes = glm::dot(v, u);
    float cos = dotRes / (glm::length(u) * glm::length(v));
    float deg = glm::degrees(glm::acos(cos));

    std::cout << "deg of ang = " << deg << std::endl;
    return 0;
}

7701640_Hillion_Jovan

2024-09-11 00:32:24 UTC

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float scalar = glm::dot(v, u);

float radiant = scalar / (glm::length(u) * glm::length(v));

float angle = glm::degrees(glm::acos(radiant));

std::cout << angle << std::endl;

7701546_Clément_Lagier

clementlagier — 2024-09-11 00:32:45 UTC

#include

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

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

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

int main(void)

{

float dot = glm::dot(u, v);

float formula = dot / (glm::length(u) * glm::length(v));

float result = glm::acos(formula) * RADIANS_TO_DEGREES;

std::cout << "Result: " << result << std::endl;

return 0;

}

7701532 Yassin SAID

2024-09-11 00:33:00 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

using namespace std;

int main()

{

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

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

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float res = glm::acos(glm::dot(v, u) / (glm::length(v) glm::length(u))) RADIANS_TO_DEGREES;

std::cout << res;

return 0;

}

7701672_Louis_Bassagal

2024-09-11 00:33:51 UTC

#include

#include

#include

#include "CMakeProject2.h"

#include

const float DEGREES_TO_RADIANTS = glm::pi() / 180.0f;

const float RADIANTS_TO_DEGREES = 180.0f / glm::pi();

int main() {

	glm::vec3 v1{2, -1, 1};

	glm::vec3 v2{1, 1, 2};

	float dot = glm::dot(v1, v2);

	float angle = glm::acos(dot / (glm::length(v1) * glm::length(v2)));

	float degree_angle = RADIANTS_TO_DEGREES * angle;

	std::cout << "Radiant : " << angle << "\nDegrees : " << degree_angle << std::endl;

	return 0;

7701625_Ludovic_de_Chavagnac

ludovicdechavagnac — 2024-09-11 00:34:19 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include 
#include 
#include 
#include 

int main() {
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	const float lu = glm::length(u);
	const float lv = glm::length(v);
	if (lu == 0 || lv == 0) {
		std::cerr << "length of u or v can't be 0" << std::endl;
		return 1;
	}
	const float radAngle = glm::dot(u, v) / (lu * lv);
	std::cout << "Result: " << glm::degrees(glm::acos(radAngle));
	return 0;
}

7701592 HOAREAU Nathan

2024-09-11 00:34:22 UTC

#include

#include "glm/glm.hpp"

#include "glm/gtc/constants.hpp"

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

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

int main()

{

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float dot = glm::dot(v, u);

float cos = dot / (glm::length(u) * glm::length(v));

float degrees = glm::acos(cos) * RADIANS_TO_DEGREES;

std::cout << "Angle = " << degrees << std::endl;

return 0;

}

7701604_Sacha TOPALOFF

2024-09-11 00:34:27 UTC

#include 
#include 

#include 

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

int main()
{
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	float dotProduct = glm::dot(v, u);
    float angle = glm::acos(dotProduct / (glm::length(u) * glm::length(v)));
    float angleDeg = glm::degrees(angle);

    std::cout << "Angle between u and v: " << angleDeg << " degrees" << std::endl;
	return 0;
}

7701516 Soidiki Léo

2024-09-11 00:36:04 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include

float getAngleFromVector(glm::vec3 v, glm::vec3 u)

{

float d = glm::dot(v, u);

float a = glm::length(u) * glm::length(v);

float res = d / a;

return glm::degrees(glm::acos(res));

}

int main()

{

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float d = glm::dot(v, u);

float a = glm::length(u) * glm::length(v);

float res = d / a;

std::cout << "vector v = " << glm::to_string(v) << " vector u = " << glm::to_string(v) << std::endl;

std::cout << "radian = " << glm::acos(res) << std::endl;

std::cout << "Degre = " << getAngleFromVector(v, u) << std::endl;

return 0;

}

7701542_MARQUES_Mathieu

2024-09-11 00:36:09 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include 
#include 
#include 
#include 
#include "dotProduct.h"

static void dotProduct()
{
	glm::vec3  v(2, -1, 1);
	glm::vec3 u(1, 1, 2);

	float dot = glm::dot(v, u);
	float c = dot / (glm::length(u) * glm::length(v));
	float angle = glm::degrees(glm::acos(c));

	std::cout << angle << " degrees" << std::endl;
}

int main()
{
	dotProduct();
	return 0;
}

7701562_Scott_Julian_Leo

2024-09-11 00:36:31 UTC

// CMakeProject1.cpp : Defines the entry point for the application.
//

#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()
{
	const double RADIANS_TO_DEGREES = 180.0 / glm::pi();
	const glm::vec3 v(2, -1, 1);
	const glm::vec3 u(1, 1, 2);

	const auto dot = glm::dot(u, v) / (glm::length(u) * glm::length(v));

	const auto θ = std::acos(dot);

	const auto θdegress = RADIANS_TO_DEGREES * θ;

	std::cout << θdegress << std::endl;

	return 0;
}

7701550 JOURDAIN Aldric

2024-09-11 00:37:17 UTC

#define GLM_ENABLE_EXPERIMENTAL

#include 

#include 
#include 
#include 

int main() {
	glm::vec3 v(2, -1, 1);
	glm::vec3 u(1, 1, 2);
	float dotProduct = glm::dot(v, u);
	float angle = dotProduct / (glm::length(v) * glm::length(u));
	float deg = glm::degrees(glm::acos(angle));
	std::cout << "Angle between vectors v(2, -1, 1) and u(1, 1, 2): " << deg << std::endl;
	return 0;
}

7701521_Brice_DESOUSA

2024-09-11 00:37:51 UTC

#include

float dotProduct()

{

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

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

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float d = glm::dot(v, u);

float c = d / (glm::length(u) * glm::length(v));

float deg = glm::acos(c) * RADIANS_TO_DEGREES;

return deg;

}

int main()

{

std::cout << "Result : " << dotProduct() << std::endl;;

return 0;

}

7701477_Hugo_Raygade

2024-09-11 00:39:12 UTC

#include

int main() {

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

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

float oe = glm::dot(u, v) / (glm::length(v) * glm::length(u));

float degrees = glm::acos(oe) * RADIANT_TO_DEGREE;

std::cout << "Result : " << degrees << " degrees" << std::endl;

return 0;

}

7701674_BOUSCH_Laetitia

2024-09-11 01:07:48 UTC

void Degree()

{

glm::vec3 v(2, -1, 1);

glm::vec3 u(1, 1, 2);

double result = (glm::dot(v, u)) / (glm::length(v) * glm::length(u));

double resultDegree = glm::acos(result) * RADIANS_TO_DEGREES;

std::cout << "Degree result: " << resultDegree << std::endl;

}

int main()

{

Degree();

return 0;

}