C++ (Cpp) vector3d::dot Examples

Programming Language: C++ (Cpp)

Class/Type: vector3d

Method/Function: dot

Examples at hotexamples.com: 2

Vector3d is a class that represents a three-dimensional vector in C++. It is often used in graphics and physics simulations to represent position, velocity, and acceleration. It has three components: x, y, and z.

Here are some code examples using Vector3d dot:

Example 1: Calculating the dot product of two vectors

#include 
#include 

int main() {
    Eigen::Vector3d v1(1, 2, 3);
    Eigen::Vector3d v2(4, 5, 6);
    double dot_product = v1.dot(v2);

    std::cout << "Dot product: " << dot_product << std::endl;

    return 0;
}

This program creates two Vector3d objects, v1 and v2, and calculates their dot product using the dot() method. The output of this program will be:

Dot product: 32

Eigen is a C++ library for linear algebra operations, including vectors and matrices.

Example 2: Calculating the angle between two vectors

#include 
#include 
#include 

int main() {
    Eigen::Vector3d v1(1, 2, 3);
    Eigen::Vector3d v2(4, 5, 6);
    double angle = std::acos(v1.dot(v2) / (v1.norm() * v2.norm()));

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

    return 0;
}

This program creates two Vector3d objects, v1 and v2, and calculates the angle between them using the dot() and norm() methods. The output of this program will be:

Angle: 0.225726

Again, this program uses the Eigen library for linear algebra operations. In conclusion, Vector3d dot is a method for calculating the dot product of two three-dimensional vectors in C++. It is most commonly used in graphics and physics simulations. The code examples shown here use the Eigen library for linear algebra operations.

C++ (Cpp) vector3d::dot - 2 examples found. These are the top rated real world C++ (Cpp) examples of vector3d::dot extracted from open source projects. You can rate examples to help us improve the quality of examples.

Frequently Used Methods

Show Hide

Length(24)

Dot(22)

Normalized(9)

Cross(7)

NormalizedSafe(5)

LengthSqr(4)

normsquared(3)

x(2)

norm(2)

getz(2)

gety(2)

getx(2)

dot(2)

y(2)

cross(1)

_norm1(1)

_norm(1)

getX(1)

getY(1)

getZ(1)

_dotprod(1)

_crossprod(1)

Z(1)

mag_nosqr(1)

Y(1)

norma(1)

X(1)

size(1)

Mag(1)

dist_sqr(1)

Example #1

Show file

File: polyhedra.cpp Project: droundy/deft

bool overlap(const polyhedron &a, const polyhedron &b, const double periodic[3], double dr) {
  const vector3d ab = periodic_diff(a.pos, b.pos, periodic);
  if (ab.normsquared() > sqr(a.R + b.R + 2*dr))
    return false;
  // construct axes from a
  // project a and b to each axis
  for (int i=0; i<a.mypoly->nfaces; i++) {
    const vector3d axis = a.rot.rotate_vector(a.mypoly->faces[i]);
    double projection = axis.dot(a.rot.rotate_vector((a.mypoly->vertices[0])*(a.R+dr)));
    double mina = projection, maxa = projection;
    for (int j=1; j<a.mypoly->nvertices; j++) {
      projection = axis.dot(a.rot.rotate_vector(a.mypoly->vertices[j]*(a.R+dr)));
      if (projection < mina) mina = projection;
      else if (projection > maxa) maxa = projection;
    }
    projection = axis.dot(b.rot.rotate_vector(b.mypoly->vertices[0]*(b.R+dr)) + ab);
    double minb = projection, maxb = projection;
    for (int j=1; j<b.mypoly->nvertices; j++) {
      projection = axis.dot(b.rot.rotate_vector(b.mypoly->vertices[j]*(b.R+dr)) + ab);
      if (projection < minb) minb = projection;
      else if (projection > maxb) maxb = projection;
    }
    if (mina > maxb || minb > maxa) {
      return false;
    }
  }
  // construct axes from b
  // project a and b to each axis
  for (int i=0; i<b.mypoly->nfaces; i++) {
    const vector3d axis = b.rot.rotate_vector(b.mypoly->faces[i]);
    double projection = axis.dot(a.rot.rotate_vector(a.mypoly->vertices[0]*(a.R+dr)));
    double mina = projection, maxa = projection;
    for (int j=1; j<a.mypoly->nvertices; j++) {
      projection = axis.dot(a.rot.rotate_vector(a.mypoly->vertices[j]*(a.R+dr)));
      if (projection < mina) mina = projection;
      else if (projection > maxa) maxa = projection;
    }
    projection = axis.dot(b.rot.rotate_vector(b.mypoly->vertices[0]*(b.R+dr)) + ab);
    double minb = projection, maxb = projection;
    for (int j=1; j<b.mypoly->nvertices; j++) {
      projection = axis.dot(b.rot.rotate_vector(b.mypoly->vertices[j]*(b.R+dr)) + ab);
      if (projection < minb) minb = projection;
      else if (projection > maxb) maxb = projection;
    }
    if (mina > maxb || minb > maxa) {
      return false;
    }
  }
  return true;
}

Example #2

Show file

File: polyhedra.cpp Project: droundy/deft

int overlaps_with_any(const polyhedron &a, const polyhedron *bs,
                      const double periodic[3], bool count, double dr) {
  // construct axes from a and a's projection onto them
  vector3d *aaxes = new vector3d[a.mypoly->nfaces];
  double amins[a.mypoly->nfaces], amaxes[a.mypoly->nfaces];
  for (int i=0; i<a.mypoly->nfaces; i++) {
    aaxes[i] = a.rot.rotate_vector(a.mypoly->faces[i]);
    double projection = aaxes[i].dot(a.rot.rotate_vector(a.mypoly->vertices[0]*(a.R+dr)));
    amins[i] = projection, amaxes[i] = projection;
    for (int j=1; j< a.mypoly->nvertices; j++) {
      projection = aaxes[i].dot(a.rot.rotate_vector(a.mypoly->vertices[j]*(a.R+dr)));
      amins[i] = min(projection, amins[i]);
      amaxes[i] = max(projection, amaxes[i]);
    }
  }
  int num_overlaps = 0;
  for (int l=0; l<a.num_neighbors; l++) {
    const int k = a.neighbors[l];
    const vector3d ab = periodic_diff(a.pos, bs[k].pos, periodic);
    if (ab.normsquared() < sqr(a.R + bs[k].R + 2*dr)) {
      bool overlap = true; // assume overlap until we prove otherwise or fail to.
      // check projection of b against a's axes
      for (int i=0; i<a.mypoly->nfaces; i++) {
        double projection = aaxes[i].dot
          (bs[k].rot.rotate_vector(bs[k].mypoly->vertices[0]*(bs[k].R+dr)) + ab);
        double bmin = projection, bmax = projection;
        for (int j=1; j<bs[k].mypoly->nvertices; j++) {
          projection = aaxes[i].dot
            (bs[k].rot.rotate_vector(bs[k].mypoly->vertices[j]*(bs[k].R+dr)) + ab);
          bmin = min(projection, bmin);
          bmax = max(projection, bmax);
        }
        if (amins[i] > bmax || bmin > amaxes[i]) {
          overlap = false;
          i = a.mypoly->nfaces; // no overlap, move on to next
        }
      }
      if (overlap) { // still need to check against b's axes
        for (int i=0; i<bs[k].mypoly->nfaces; i++) {
          const vector3d axis = bs[k].rot.rotate_vector(bs[k].mypoly->faces[i]);
          double projection = axis.dot(a.rot.rotate_vector(a.mypoly->vertices[0]*(a.R+dr)));
          double amin = projection, amax = projection;
          for (int j=1; j<a.mypoly->nvertices; j++) {
            projection = axis.dot(a.rot.rotate_vector(a.mypoly->vertices[j]*(a.R+dr)));
            amin = min(projection, amin);
            amax = max(projection, amax);
          }
          projection = axis.dot
            (bs[k].rot.rotate_vector(bs[k].mypoly->vertices[0]*(bs[k].R+dr)) + ab);
          double bmin = projection, bmax = projection;
          for (int j=1; j<bs[k].mypoly->nvertices; j++) {
            projection = axis.dot
              (bs[k].rot.rotate_vector(bs[k].mypoly->vertices[j]*(bs[k].R+dr)) + ab);
            bmin = min(projection, bmin);
            bmax = max(projection, bmax);

          }
          if (amin > bmax || bmin > amax) {
            overlap = false;
            i = bs[k].mypoly->nfaces; //no overlap, move on to next
          }
        }
      }
      if (overlap) {
        if(!count) {
          delete[] aaxes;
          return 1;
        }
        num_overlaps ++;
      }
    }
  }
  delete[] aaxes;
  return num_overlaps;
}