Esempio n. 1
0
int readGraph(){
    int startVertex = 0 ;
    int n = 0 ;
    scanf("%d",&startVertex);
    scanf("%d",&n);

    int ** matrix = readIn(n);
    printMatrix(matrix,n);

    struct queue* q = (struct queue*)malloc(sizeof(struct queue));
    init(q);
    struct stack stk;
    initialize(&stk);
    int * visited = (int *) malloc(sizeof(int)*n);
    int i = 0 ;
    for ( i = 0 ; i < n ; i++ ) visited[i] = 0 ;

    printf("\nBreadth First: ");
    breadthFirst(matrix,startVertex,n,q);


    printf("\nDepth First: ");
    depthFirst(matrix,startVertex,n,stk);
    printf("\nDepth First: ");
    depthCaller(matrix,n);
    printf("\n");

    free(q);
    free(visited);
    free(matrix);

    return 0 ;
}
Esempio n. 2
0
File: main.cpp Progetto: CCJY/coliru
/*
bool operator<(const food & lhs, const food & rhs) {
	return std::get<0>(lhs) < std::get<0>(rhs)
		|| (std::get<0>(lhs) == std::get<0>(rhs)
			&& (std::get<1>(lhs) < std::get<1>(rhs)
			|| (std::get<1>(lhs) == std::get<1>(rhs)
				&& std::get<2>(lhs) < std::get<2>(rhs))));
}
*/
bool depthFirst(const food & totalFood, const food & accum, const std::vector<food> & foods) {
	if (accum >= totalFood) {
//		if (accum == totalFood) {
//			std::cout << foods;
//		}
		return accum == totalFood;
	}
	for (std::size_t i = 0; i < foods.size(); ++i) {
		auto newFood = foods;
		const auto newAccum = accum + foods[i];
		newFood.erase(std::begin(newFood) + i);
		if (depthFirst(totalFood, newAccum, newFood)) {
			return true;
		}
	}
	return false;
}
Esempio n. 3
0
/**
 * Run multiple test.
 * @param transaction_list List of itemset and expression value.
 * @param trans4lcm File name for argument of LCM program. This file is made in this method.
 * @param threshold The statistical significance threshold.
 * @param set_method The procedure name for calibration p-value (fisher/u_test).
 * @param max_comb The maximum arity limit.
 * @param outlog File name for logging.
 * @param alternative hypothesis, 1 -> greater, 0 -> two sided, -1 -> less
 * @param max_lambda Return value of maximum lambda.
 * @return 
 */
int LampCore::runMultTest(const std::vector<Transaction*>& transaction_list, std::string& trans4lcm,
		double threshold, std::string& set_method, int max_comb,
		std::ostream& outlog, int alternative, double max_lambda) {
	int lam_star = 1;
	double k = -1;
	try {
		if (set_method.compare("fisher") == 0) {
			func_f = new Functions4fisher(transaction_list, std::abs(alternative));
		}
		else if (set_method.compare("u_test") == 0) {
			func_f = new Functions4u_test(transaction_list, alternative);
		}
		else if (set_method.compare("chi") == 0) {
			func_f = new Functions4chi(transaction_list, std::abs( alternative));
		}
		else {
			throw std::string("Error: choose \"fisher\", \"chi\" or \"u_test\" by using -p option.");
		}
		double lam = max_lambda;
		
		// check a MASL of max_lambda
		double n1 = 0.0;
		if (std::find(BINARY_METHODS.begin(), BINARY_METHODS.end(), set_method) !=  BINARY_METHODS.end()) {
			n1 = func_f->sumValue();
			if (n1 < max_lambda) {
				max_lambda = int( n1 );
				lam = int( n1 );
			}
		}
		
		fre_pattern->makeFile4Lem(transaction_list, trans4lcm); // make itemset file for lcm
		
		// If Fisher's exact test or chi-square test is used for computing P-value, 
		// LCM-LAMP is run to find optimal lambda.
		if (set_method == "fisher") {
			int neg_size = func_f->getAllSize() - func_f->getN1();
			n1 = std::min( n1, (double)neg_size );
			// # of positives == # of negatives, and two.sided hypothesis test.
			if (( func_f->getN1() == neg_size ) && (alternative == 0)) {
				lam_star = depthFirst( trans4lcm, max_comb, n1, 0.5*threshold, 1 );
			} else {
				lam_star = depthFirst( trans4lcm, max_comb, n1, threshold, 1 );
			}
		}
		else if (set_method == "chi") {
			int neg_size = func_f->getAllSize() - func_f->getN1();
			n1 = std::min( n1, (double)neg_size );
			// two-sided hypothesis test
			if (alternative == 0) {
				lam_star = depthFirst( trans4lcm, max_comb, n1, 0.5*threshold, 2 );
			}
			// one-sided
			else {
				lam_star = depthFirst( trans4lcm, max_comb, n1, threshold, 2 );
			}
		}
		// If Mann-Whitney U test of Chi-square test is used,
		// LAMP ver 1. is run for computing the optimal lambda. 
		else {
			// two-sided hypothesis test
			if (alternative == 0) {
				lam_star = breadthFirst( trans4lcm, max_comb, 0.5*threshold, lam, outlog );
			}
			// one-sided hypothesis test
			else {
				lam_star = breadthFirst( trans4lcm, max_comb, threshold, lam, outlog );
			}
		}

		fre_pattern->frequentPatterns( trans4lcm, lam_star, max_comb ); // P_lambda* at line 13
		k = fre_pattern->getTotal( lam_star );
	} catch (std::string &msg) {
		throw msg;
	} catch (...) {
		throw std::string("Error: An unexpected error occurred while trying multiple test.");
	}

	// multiple test by using k and lambda_star
	outlog << "finish calculation of K: " << k << std::endl;
	// If lam_star > max_lambda, m_lambda set to max_lambda.
	// This case cause when optimal solution is found at first step.
	outlog << lam_star << std::endl;
	if (max_lambda < lam_star)
		lam_star = max_lambda;

	return lam_star;
}