示例#1
0
/* Copy one vector into another */
void vec_copy(vec_t dest, vec_t src) {
    int i;
    
    if (dest.d != src.d) {
	printf("[vec_copy] Mismatch in vector sizes\n");
	return;
    }

    for (i = 0; i < dest.d; i++) {
	Vn(dest, i) = Vn(src, i);
    }
}
示例#2
0
vec_t vec_new_set(int d, double val) {
    vec_t v = vec_new(d);
    int i;

    for (i = 0; i < d; i++)
        Vn(v, i) = val;
    
    return v;
}
示例#3
0
/*
 * Run the whole workload.
 */
static
void
runit(unsigned numthinkers, unsigned numgrinders,
      unsigned numponggroups, unsigned ponggroupsize)
{
	pid_t pids[numponggroups + 2];
	time_t startsecs;
	unsigned long startnsecs;
	char buf[32];
	unsigned i;

	tprintf("Running with %u thinkers, %u grinders, and %u pong groups "
	       "of size %u each.\n", numthinkers, numgrinders, numponggroups,
	       ponggroupsize);

	usem_init(&startsem, STARTSEM);
	createresultsfile();
	forkem(numthinkers, nop, think, nop, 0, &pids[0]);
	forkem(numgrinders, nop, grind, nop, 1, &pids[1]);
	for (i=0; i<numponggroups; i++) {
		forkem(ponggroupsize, pong_prep, pong, pong_cleanup, i+2,
		       &pids[i+2]);
	}
	usem_open(&startsem);
	tprintf("Forking done; starting the workload.\n");
	__time(&startsecs, &startnsecs);
	Vn(&startsem, numthinkers + numgrinders +
	   numponggroups * ponggroupsize);
	waitall(pids, numponggroups + 2);
	usem_close(&startsem);
	usem_cleanup(&startsem);

	openresultsfile(O_RDONLY);

	tprintf("--- Timings ---\n");
	if (numthinkers > 0) {
		calcresult(0, startsecs, startnsecs, buf, sizeof(buf));
		tprintf("Thinkers: %s\n", buf);
	}

	if (numgrinders > 0) {
		calcresult(1, startsecs, startnsecs, buf, sizeof(buf));
		tprintf("Grinders: %s\n", buf);
	}

	for (i=0; i<numponggroups; i++) {
		calcresult(i+2, startsecs, startnsecs, buf, sizeof(buf));
		tprintf("Pong group %u: %s\n", i, buf);
	}

	closeresultsfile();
	destroyresultsfile();
}
示例#4
0
文件: mesh.cpp 项目: ipa-nhg/kukadu
/** @brief calculate the normals of all triangles (Tn) and the average
  normals of the vertices (N); average normals are averaged over
  all adjacent triangles that are in the triangle list or member of
  a strip */
void Mesh::computeNormals() {
  uint i;
  Vector a, b, c;
  Tn.resize(T.d0, 3);
  Tn.setZero();
  Vn.resize(V.d0, 3);
  Vn.setZero();
  //triangle normals and contributions
  for(i=0; i<T.d0; i++) {
    a.set(&V(T(i, 0), 0));
    b.set(&V(T(i, 1), 0));
    c.set(&V(T(i, 2), 0));

    b-=a; c-=a; a=b^c; a.normalize();
    Tn(i, 0)=a.x;  Tn(i, 1)=a.y;  Tn(i, 2)=a.z;
    Vn(T(i, 0), 0)+=a.x;  Vn(T(i, 0), 1)+=a.y;  Vn(T(i, 0), 2)+=a.z;
    Vn(T(i, 1), 0)+=a.x;  Vn(T(i, 1), 1)+=a.y;  Vn(T(i, 1), 2)+=a.z;
    Vn(T(i, 2), 0)+=a.x;  Vn(T(i, 2), 1)+=a.y;  Vn(T(i, 2), 2)+=a.z;
  }
  Vector d;
  for(i=0; i<Vn.d0; i++) { d.set(&Vn(i, 0)); Vn[i]()/=d.length(); }
}
示例#5
0
/*
--------------------------------------------------------------------------------------------------
- check collision with stairs
--------------------------------------------------------------------------------------------------
*/
bool PlanesPhysicHandler::ColisionWithStair(const AABB & actorBB, const VECTOR &Speed, VECTOR &ModifiedSpeed)
{
    float moveX = Speed.x;
    float moveZ = Speed.z;

    // calculate norm of speed
    VECTOR speedNorm = Speed.unit();

    float startX = (actorBB.P.x+actorBB.E.x)/2.0f;
    float startZ = (actorBB.P.z+actorBB.E.z)/2.0f;

    std::vector<StairPlane>::const_iterator it = _stairs.begin();
    std::vector<StairPlane>::const_iterator end = _stairs.end();

    // for each stairs
    for(int i=0; it != end; ++it, ++i)
    {
        // project point to plane and check if we cross it
        float DotProduct=speedNorm.dot(it->Normal);

        // Determine If Ray Parallel To Plane
        if (abs(DotProduct) > 0.000001f)
        {
            // Find Distance To Collision Point
            float l2=(it->Normal.dot(it->C1-VECTOR(startX, actorBB.P.y, startZ)))/DotProduct;

            // Test If Collision Behind Start or after end
            if (l2 > 0 && l2 < Speed.length())
            {
                float collionsX = startX + (speedNorm.x * l2);
                float collionsZ = startZ + (speedNorm.z * l2);

                if((collionsX >= it->minX) && (collionsX <= it->maxX))
                {
                    if((collionsZ >= it->minZ) && (collionsZ <= it->maxZ))
                    {
                        VECTOR spmY(Speed.x, 0, Speed.z);
                        VECTOR Vt(it->Normal.dot(spmY)*it->Normal);
                        VECTOR Vn(spmY - Vt);
                        ModifiedSpeed = Vn;
                        return true;
                    }
                }
            }
        }
    }

    return false;
}
示例#6
0
/* Scale the given vector with the given scalar (changing the
 * given vector) */
void vec_scale_inplace(double c, vec_t v) {
    int i;
    
    for (i = 0; i < v.d; i++)
	Vn(v, i) *= c;
}