示例#1
0
	vector<double> JointUniversal::getViolation()
	{
		vector<double> out;
		MatNxN s3 = getConstraintViolationS3();
		MatNxN n11 = getConstraintViolationN11a();

		out.push_back(s3(0,0));
		out.push_back(s3(1,0));
		out.push_back(s3(2,0));
		out.push_back(n11(0,0));

		return out;
	}
示例#2
0
int main()
{
	ListNode n6(10);
	ListNode n7(3);
	ListNode n8(45);
	ListNode n9(1);
	ListNode n10(38);
	ListNode n11(89);

	n6.next = &n7;
	n7.next = &n8;
	n8.next = &n9;
	n9.next = &n10;
	n10.next = &n11;

	ListNode* n = reverseList(&n6);

	while(n)
	{
		printf("%d->", n->val);
		n = n->next;
	}
    return 0;
}
bool dgCollisionConvexHull::RemoveCoplanarEdge (dgPolyhedra& polyhedra, const dgBigVector* const hullVertexArray) const
{
	bool removeEdge = false;
	// remove coplanar edges
	dgInt32 mark = polyhedra.IncLRU();
	dgPolyhedra::Iterator iter (polyhedra);
	for (iter.Begin(); iter; ) {
		dgEdge* edge0 = &(*iter);
		iter ++;

		if (edge0->m_incidentFace != -1) {

			if (edge0->m_mark < mark) {
				edge0->m_mark = mark;
				edge0->m_twin->m_mark = mark;
				dgBigVector normal0 (FaceNormal (edge0, &hullVertexArray[0]));
				dgBigVector normal1 (FaceNormal (edge0->m_twin, &hullVertexArray[0]));

				dgFloat64 test = normal0.DotProduct(normal1).GetScalar();
				if (test > dgFloat64 (0.99995f)) {

					if ((edge0->m_twin->m_next->m_twin->m_next != edge0) && (edge0->m_next->m_twin->m_next != edge0->m_twin)) {
						#define DG_MAX_EDGE_ANGLE dgFloat32 (1.0e-3f)

						if (edge0->m_twin == &(*iter)) {
							if (iter) {
								iter ++;
							}
						}

						dgBigVector e1 (hullVertexArray[edge0->m_twin->m_next->m_next->m_incidentVertex] - hullVertexArray[edge0->m_incidentVertex]);
						dgBigVector e0 (hullVertexArray[edge0->m_incidentVertex] - hullVertexArray[edge0->m_prev->m_incidentVertex]);

						dgAssert(e0.m_w == dgFloat64(0.0f));
						dgAssert(e1.m_w == dgFloat64(0.0f));
						dgAssert (e0.DotProduct(e0).GetScalar() >= dgFloat64 (0.0f));
						dgAssert (e1.DotProduct(e1).GetScalar() >= dgFloat64 (0.0f));

						e0 = e0.Scale (dgFloat64 (1.0f) / sqrt (e0.DotProduct(e0).GetScalar()));
						e1 = e1.Scale (dgFloat64 (1.0f) / sqrt (e1.DotProduct(e1).GetScalar()));
						dgBigVector n1 (e0.CrossProduct(e1));

						dgFloat64 projection = n1.DotProduct(normal0).GetScalar();
						if (projection >= DG_MAX_EDGE_ANGLE) {

							dgBigVector e11 (hullVertexArray[edge0->m_next->m_next->m_incidentVertex] - hullVertexArray[edge0->m_twin->m_incidentVertex]);
							dgBigVector e00 (hullVertexArray[edge0->m_twin->m_incidentVertex] - hullVertexArray[edge0->m_twin->m_prev->m_incidentVertex]);
							dgAssert (e00.m_w == dgFloat64 (0.0f));
							dgAssert (e11.m_w == dgFloat64 (0.0f));
							dgAssert (e00.DotProduct(e00).GetScalar() >= dgFloat64 (0.0f));
							dgAssert (e11.DotProduct(e11).GetScalar() >= dgFloat64 (0.0f));
							e00 = e00.Scale(dgFloat64(1.0f) / sqrt(e00.DotProduct(e00).GetScalar()));
							e11 = e11.Scale(dgFloat64(1.0f) / sqrt(e11.DotProduct(e11).GetScalar()));

							dgBigVector n11 (e00.CrossProduct(e11));
							projection = n11.DotProduct(normal0).GetScalar();
							if (projection >= DG_MAX_EDGE_ANGLE) {
								dgAssert (&(*iter) != edge0);
								dgAssert (&(*iter) != edge0->m_twin);
								polyhedra.DeleteEdge(edge0);
								removeEdge = true;
							}
						}

					} else {
						dgEdge* next = edge0->m_next;
						dgEdge* prev = edge0->m_prev;
						polyhedra.DeleteEdge(edge0);
						for (edge0 = next; edge0->m_prev->m_twin == edge0; edge0 = next) {
							next = edge0->m_next;
							polyhedra.DeleteEdge(edge0);
						}

						for (edge0 = prev; edge0->m_next->m_twin == edge0; edge0 = prev) {
							prev = edge0->m_prev;
							polyhedra.DeleteEdge(edge0);
						}
						iter.Begin(); 
						removeEdge = true;
					}
				}
			}
		}
	}

	return removeEdge;
}
示例#4
0
文件: Cone.cpp 项目: zxwglzi/libcgt
void Cone::tesselate( int nTheta, int nHeight,
	std::vector< Vector4f >& positions,
	std::vector< Vector3f >& normals )
{
	positions.clear();
	normals.clear();

	positions.reserve( 6 * nTheta * nHeight );
	normals.reserve( 6 * nTheta * nHeight );

	float dt = MathUtils::TWO_PI / nTheta;
	float dh = height / nHeight;

	Vector4f bc( baseCenter, 0 );

	for( int t = 0; t < nTheta; ++t )
	{
		float t0 = t * dt;
		float t1 = t0 + dt;

		for( int h = 0; h < nHeight; ++h )
		{
			float h0 = h * dh;
			float h1 = h0 + dh;

			float r0 = baseRadius * ( 1 - h0 / height );
			float r1 = baseRadius * ( 1 - h1 / height );

			float x00 = r0 * cosf( t0 );
			float y00 = r0 * sinf( t0 );
			float x10 = r0 * cosf( t1 );
			float y10 = r0 * sinf( t1 );
			float x01 = r1 * cosf( t0 );
			float y01 = r1 * sinf( t0 );
			float x11 = r1 * cosf( t1 );
			float y11 = r1 * sinf( t1 );

			Vector4f v00 = bc + Vector4f( x00, y00, h0, 1 );
			Vector3f n00( x00, y00, r0 / sqrtf( r0 * r0 + h0 * h0 ) );
			n00.normalize();

			Vector4f v10 = bc + Vector4f( x10, y10, h0, 1 );
			Vector3f n10( x10, y10, r0 / sqrtf( r0 * r0 + h0 * h0 ) );
			n10.normalize();

			Vector4f v01 = bc + Vector4f( x01, y01, h1, 1 );
			Vector3f n01( x01, y01, r1 / sqrtf( r1 * r1 + h1 * h1 ) );
			n01.normalize();

			Vector4f v11 = bc + Vector4f( x11, y11, h1, 1 );
			Vector3f n11( x11, y11, r1 / sqrtf( r1 * r1 + h1 * h1 ) );
			n11.normalize();

			positions.push_back( v00 );
			normals.push_back( n00 );
			positions.push_back( v10 );
			normals.push_back( n10 );
			positions.push_back( v01 );
			normals.push_back( n01 );

			positions.push_back( v01 );
			normals.push_back( n01 );
			positions.push_back( v10 );
			normals.push_back( n10 );
			positions.push_back( v11 );
			normals.push_back( n11 );
		}
	}
}
示例#5
0
void Sphere::tesselate( int nTheta, int nPhi,
	std::vector< Vector4f >& positions,
	std::vector< Vector3f >& normals )
{
	positions.clear();
	normals.clear();

	positions.reserve( 6 * nTheta * nPhi );
	normals.reserve( 6 * nTheta * nPhi );

	float dt = MathUtils::TWO_PI / nTheta;
	float dp = MathUtils::PI / nPhi;

	Vector4f c( center, 0 );

	for( int t = 0; t < nTheta; ++t )
	{
		float t0 = t * dt;
		float t1 = t0 + dt;

		for( int p = 0; p < nPhi; ++p )
		{
			float p0 = p * dp;
			float p1 = p0 + dp;

			float x00 = cosf( t0 ) * sinf( p0 );
			float y00 = sinf( t0 ) * sinf( p0 );
			float z00 = cosf( p0 );
			float x10 = cosf( t1 ) * sinf( p0 );
			float y10 = sinf( t1 ) * sinf( p0 );
			float z10 = cosf( p0 );
			float x01 = cosf( t0 ) * sinf( p1 );
			float y01 = sinf( t0 ) * sinf( p1 );
			float z01 = cosf( p1 );
			float x11 = cosf( t1 ) * sinf( p1 );
			float y11 = sinf( t1 ) * sinf( p1 );
			float z11 = cosf( p1 );

			Vector4f v00 = c + Vector4f( radius * x00, radius * y00, radius * z00, 1 );
			Vector3f n00( x00, y00, z00 );
			Vector4f v10 = c + Vector4f( radius * x10, radius * y10, radius * z10, 1 );
			Vector3f n10( x10, y10, z10 );
			Vector4f v01 = c + Vector4f( radius * x01, radius * y01, radius * z01, 1 );
			Vector3f n01( x01, y01, z01 );
			Vector4f v11 = c + Vector4f( radius * x11, radius * y11, radius * z11, 1 );
			Vector3f n11( x11, y11, z11 );

			positions.push_back( v00 );
			normals.push_back( n00 );
			positions.push_back( v10 );
			normals.push_back( n10 );
			positions.push_back( v01 );
			normals.push_back( n01 );

			positions.push_back( v01 );
			normals.push_back( n01 );
			positions.push_back( v10 );
			normals.push_back( n10 );
			positions.push_back( v11 );
			normals.push_back( n11 );
		}
	}
}
示例#6
0
文件: NeuronTest.cpp 项目: kn65op/SSN
TEST(learnWithBPTest, XOR100)
{
  Entry<double> a;
  Entry<double> b;
  Bias<double> bias1(1);
  Bias<double> bias2(1);
  Neuron<double, LinearActivationFunction<double >> n11(0.1);
  Neuron<double, LinearActivationFunction<double >> n12(0.1);
  Neuron<double, LinearActivationFunction<double >> n22(0.1);
  Exit<double> exit;
  std::vector < Link<double >> links(10);
  //wejścia do 1 neuronu
  a.setLinkOut(&links[0]);
  b.setLinkOut(&links[1]);
  bias1.setLinkOut(&links[2]);
  n11.setLinkIn(&links[2]);
  n11.setLinkIn(&links[0]);
  n11.setLinkIn(&links[1]);
  //wejścia do drugiego neuronu
  a.setLinkOut(&links[3]);
  b.setLinkOut(&links[4]);
  bias1.setLinkOut(&links[5]);
  n12.setLinkIn(&links[5]);
  n12.setLinkIn(&links[3]);
  n12.setLinkIn(&links[4]);
  //połączenia międzyneuronowe
  n11.setLinkOut(&links[6]);
  n12.setLinkOut(&links[7]);
  bias2.setLinkOut(&links[8]);
  n22.setLinkIn(&links[8]);
  n22.setLinkIn(&links[6]);
  n22.setLinkIn(&links[7]);
  //do wyjścia
  n22.setLinkOut(&links[9]);
  bias1.sendBiasToLinks();
  bias2.sendBiasToLinks();
  //n.printWages();
  exit.setLinkIn(&links[9]);

  //uczenie
  for (int i = 0; i < 5000; i++)
  {
    a.setEntry(0);
    b.setEntry(0);
    n11.calculateOutput();
    n12.calculateOutput();
    n22.calculateOutput();
    exit.learn(0);
    n22.propagateAnswer();
    n22.learnDelta();
    n11.learnBP();
    n12.learnBP();
    
    // Qstd::cout<< "0,0: " << exit.getExit() << "\n";
    
    a.setEntry(1);
    b.setEntry(0);
    n11.calculateOutput();
    n12.calculateOutput();
    n22.calculateOutput();
    exit.learn(1);
    n22.propagateAnswer();
    n22.learnDelta();
    n11.learnBP();
    n12.learnBP();
    
    // Qstd::cout<< " 1,0: " << exit.getExit() << "\n";
    
    a.setEntry(0);
    b.setEntry(1);
    n11.calculateOutput();
    n12.calculateOutput();
    n22.calculateOutput();
    exit.learn(1);
    n22.propagateAnswer();
    n22.learnDelta();
    n11.learnBP();
    n12.learnBP();
    
    // Qstd::cout<< " 0,1: " << exit.getExit() << "\n";
    
    a.setEntry(1);
    b.setEntry(1);
    n11.calculateOutput();
    n12.calculateOutput();
    n22.calculateOutput();
    exit.learn(0);
    n22.propagateAnswer();
    n22.learnDelta();
    n11.learnBP();
    n12.learnBP();
    
    // Qstd::cout<< " 1,1: " << exit.getExit() << "\n";
//    for (auto l : links)
//    {
//      // Qstd::cout<< " " << l.getValue();
//    }
//    // Qstd::cout<< "\n";
    
  //n11.printWages();
  //n12.printWages();
  //n22.printWages();
  }
  n11.printWages();
  n12.printWages();
  n22.printWages();
  a.setEntry(0);
  b.setEntry(0);
  n11.calculateOutput();
  n12.calculateOutput();
  n22.calculateOutput();
  ASSERT_GT(0.1, exit.getExit());
  a.setEntry(1);
  b.setEntry(0);
  n11.calculateOutput();
  n12.calculateOutput();
  n22.calculateOutput();
  ASSERT_LT(0.9, exit.getExit());
  a.setEntry(0);
  b.setEntry(1);
  n11.calculateOutput();
  n12.calculateOutput();
  n22.calculateOutput();
  ASSERT_LT(0.9, exit.getExit());
  a.setEntry(1);
  b.setEntry(1);
  n11.calculateOutput();
  n12.calculateOutput();
  n22.calculateOutput();
  ASSERT_GT(0.1, exit.getExit());
}