Esempio n. 1
0
inline double evaluar(double x[10]){
  int r;
  double z;
  llamadas++;
  if ( (r = ia1("0538207", x, &z)) ){
    fprintf(stderr, "hubo un error: %d\n", r);
    exit(EXIT_FAILURE);
  }
  return z;
}
Esempio n. 2
0
int main(int argc, char* argv[])
{
    std::string     filename1, filename2;

    po::options_description hidden("Hidden options");
    hidden.add_options()
        ("input-file1",  po::value<std::string>(&filename1), "The first collection of persistence diagrams")
        ("input-file2",  po::value<std::string>(&filename2), "The second collection of persistence diagrams");

    po::positional_options_description p;
    p.add("input-file1", 1);
    p.add("input-file2", 2);
    
    po::options_description all; all.add(hidden);

    po::variables_map vm;
    po::store(po::command_line_parser(argc, argv).
                  options(all).positional(p).run(), vm);
    po::notify(vm);

    if (!vm.count("input-file1") || !vm.count("input-file2"))
    { 
        std::cout << "Usage: " << argv[0] << " input-file1 input-file2" << std::endl;
        std::cout << hidden << std::endl; 
        return 1; 
    }

    std::ifstream ifs1(filename1.c_str()), ifs2(filename2.c_str());
    boost::archive::binary_iarchive ia1(ifs1), ia2(ifs2);

    std::map<Dimension, PDgm>       dgms1, dgms2;

    ia1 >> dgms1;
    ia2 >> dgms2;

    std::cout << "Distance between dimension 0: " << bottleneck_distance(dgms1[0], dgms2[0]) << std::endl;
    std::cout << "Distance between dimension 1: " << bottleneck_distance(dgms1[1], dgms2[1]) << std::endl;
    std::cout << "Distance between dimension 2: " << bottleneck_distance(dgms1[2], dgms2[2]) << std::endl;
}
Esempio n. 3
0
void testArray2D()
{
	fdk::Array2D<int> ia(2, 3);
	for (size_t y = 0; y < 3; ++y)
	{
		for (size_t x = 0; x < 2; ++x)
		{
			FDK_ASSERT(ia(x, y) == 0);
			ia(x, y) = x+y;
		}
	}
	FDK_ASSERT(ia.is_valid_index(1, 1));
	FDK_ASSERT(ia.is_valid_index(1, 2));
	FDK_ASSERT(ia.is_valid_index(0));
	FDK_ASSERT(ia.is_valid_index(5));
	FDK_ASSERT(!ia.is_valid_index(6));
	FDK_ASSERT(ia.to_index(1, 2) == 5);
	size_t x, y;
	ia.to_index(5, x, y);
	FDK_ASSERT(x == 1 && y == 2);	

	fdk::Array2D<int> ia1(2, 2, 5);
	FDK_ASSERT(ia1.is_valid_index(1, 1));
	FDK_ASSERT(!ia1.is_valid_index(1, 2));
	FDK_ASSERT(ia1(0, 0) == 5);
	FDK_ASSERT(ia1(0, 1) == 5);
	FDK_ASSERT(ia1(1, 0) == 5);
	FDK_ASSERT(ia1(1, 1) == 5);
	ia1(1, 1) = 3;
	FDK_ASSERT(ia1(1, 1) == 3);

	fdk::Array2D<int> ia2(ia);
	for (size_t y = 0; y < ia2.size_y(); ++y)
	{
		for (size_t x = 0; x < ia2.size_x(); ++x)
		{
			FDK_ASSERT(ia2(x, y) == x+y);
		}
	}

	ia1 = ia2;
	for (size_t y = 0; y < ia2.size_y(); ++y)
	{
		for (size_t x = 0; x < ia2.size_x(); ++x)
		{
			FDK_ASSERT(ia1(x, y) == x+y);
		}
	}

	ia1.clear();
	FDK_ASSERT(ia1.empty());
	FDK_ASSERT(ia1.count() == 0);
	FDK_ASSERT(ia1.size_x() == 0);
	FDK_ASSERT(ia1.size_y() == 0);
	FDK_ASSERT(!ia1.raw_data());
	ia1.reset(2, 1, 3);
	for (size_t y = 0; y < ia1.size_y(); ++y)
	{
		for (size_t x = 0; x < ia1.size_x(); ++x)
		{
			FDK_ASSERT(ia1(x, y) == 3);
		}
	}
	ia1.refill(100);
	for (size_t y = 0; y < ia1.size_y(); ++y)
	{
		for (size_t x = 0; x < ia1.size_x(); ++x)
		{
			FDK_ASSERT(ia1(x, y) == 100);
		}
	}

	{
		fdk::Array2D<int*> ar;
		ar.reset(5, 10);
		for (size_t y = 0; y < 10; ++y)
		{
			for (size_t x = 0; x < 5; ++x)
			{
				FDK_ASSERT(ar(x, y) == 0);
			}
		}		
	}
}