Ejemplo n.º 1
0
void ai_eval_hexes( int x, int y, int range, int(*eval_func)(int,int,void*), void *ctx )
{
    List *list = list_create( LIST_NO_AUTO_DELETE, LIST_NO_CALLBACK );
    AI_Pos *pos;
    int i, nx, ny;
    /* gather and handle all positions by breitensuche.
       use AUX mask to mark visited positions */
    map_clear_mask( F_AUX );
    list_add( list, ai_create_pos( x, y ) ); mask[x][y].aux = 1;
    list_reset( list );
    while ( list->count > 0 ) {
        pos = list_dequeue( list );
        if ( !eval_func( pos->x, pos->y, ctx ) ) {
            free( pos );
            break;
        }
        for ( i = 0; i < 6; i++ )
            if ( get_close_hex_pos( pos->x, pos->y, i, &nx, &ny ) )
                if ( !mask[nx][ny].aux && get_dist( x, y, nx, ny ) <= range ) {
                    list_add( list, ai_create_pos( nx, ny ) );
                    mask[nx][ny].aux = 1;
                }
        free( pos );
    }
    list_delete( list );
}
Ejemplo n.º 2
0
RGBColor
ImplicitSurface::trace_ray(const Ray& ray) const{
	//float range = 10.83;
	float range = 3.79;
	range *= range;
	float vres = (*world_ptr).vp.vres;
	float hres = (*world_ptr).vp.hres;
	const float x = (ray.o.x + hres/2) / hres * range;
	const float y = (ray.o.y + vres/2) / vres * range;
	float eval = eval_func(x, y);

	return RGBColor(eval, eval, eval);
	//return white;
}
Ejemplo n.º 3
0
// min
int min_node(int depth, int side, XY *move)
{
    int best = INFINITY, value;
    int nmoves;
    XY moves[MOVENUM], opp[MOVENUM];
    int pre_board[8][8];
    int i;
    
    if (depth == DEPTH)
        return eval_func();
    
    // 手を生成
	nmoves = generate_moves(side, moves);
    
    // 手がないとき
	if (nmoves == 0)
	{
		if (generate_moves(-side, opp) == 0) // 相手もおけないときは終了
			return get_terminal_value();
		else    // 違うときはパス
			moves[nmoves++] = PASSMOVE;
	}
    
    // たどっていく
    for (i = 0; i < nmoves; i++)
	{
        memcpy(pre_board, board, sizeof(board));    // 盤面の保存
		place_disk(side, moves[i]);   // 一手進める
        
        // 再帰(recursive)
		value = max_node(depth + 1, -side, move);
        
        memcpy(board, pre_board, sizeof(board));    // 戻す
        
        // 値の更新
        if (value <= best)
        {
            best = value;
            if (depth == 0)
                *move = moves[i];
        }
	}
    
	return best;
}
Ejemplo n.º 4
0
 Value eval(const Tree& tree, const Params& params, void* p, Cost* limit) {
     switch (tree.expr_id().type) {
         case Expr::Term: {
             return eval_term(tree.expr_id().index, params, p, limit);
         }
         case Expr::Func: {
             Args args;
             for (const Tree& child : tree.children())
                 args.push_back(eval(child, params, p, limit));
             return eval_func(tree.expr_id().index, args, p, limit);
         }
         case Expr::Select: {
             unsigned branch =
                 eval_select(tree.expr_id().index, params, p, limit);
             assert(branch < tree.children().size());
             return eval(tree.children()[branch], params, p, limit);
         }
         case Expr::Invalid:
             throw std::logic_error("Invalid expression");
     }
     assert(false);
 }
Ejemplo n.º 5
0
namespace GiNaC {

//////////
// Hermite polynomials H_n(x)
//////////

static ex hermite_evalf(const ex& n, const ex& x, PyObject* parent)
{
	if (not is_exactly_a<numeric>(x)
             or not is_exactly_a<numeric>(n))
                return hermite(n,x).hold();

        // see http://dlmf.nist.gov/18.5.E13
        numeric numn = ex_to<numeric>(n);
        numeric numx = ex_to<numeric>(x);
        std::vector<numeric> numveca, numvecb;
        numveca.push_back(numn / *_num_2_p);
        numveca.push_back(*_num1_2_p + (numn / *_num_2_p));
        return pow(numx * (*_num2_p), numn) * hypergeometric_pFq(numveca, numvecb, -pow(numx, *_num2_p).inverse(), parent);
}

static ex hermite_eval(const ex& n, const ex& x)
{
	if (is_exactly_a<numeric>(x)) {
                numeric numx = ex_to<numeric>(x);
                if (numx.is_zero())
                        if (n.info(info_flags::integer)
                                and n.info(info_flags::odd))
                                return _ex0;
                if (is_exactly_a<numeric>(n) and numx.info(info_flags::inexact))
                        return hermite_evalf(n, x, nullptr);
        }

        if (not is_exactly_a<numeric>(n))
                return hermite(n, x).hold();
        numeric numn = ex_to<numeric>(n);
        if (not numn.info(info_flags::integer) or numn < 0)
                throw std::runtime_error("hermite_eval: The index n must be a nonnegative integer");

        if (numn.is_zero())
                return _ex1;

        // apply the formula from http://oeis.org/A060821
        // T(n, k) = ((-1)^((n-k)/2))*(2^k)*n!/(k!*((n-k)/2)!) if n-k is even and >=0, else 0.
        // sequentially for all viable k. Effectively there is the recurrence
        // T(n, k) = -(k+2)*(k+1)/(2*(n-k)) * T(n, k+2), with T(n, n) = 2^n
        numeric coeff = _num2_p->power(numn);
        ex sum = _ex0;
        int fac = 1;
        while (numn >= 0) {
                sum = sum + power(x, numn) * coeff;
                coeff /= *_num_4_p;
                coeff *= numn;
                --numn;
                coeff *= numn;
                --numn;
                coeff /= fac++;
                }
        return sum;
}

static ex hermite_deriv(const ex& n, const ex & x, unsigned deriv_param)
{
	    if (deriv_param == 0)
                    throw std::runtime_error("derivative w.r.t. to the index is not supported yet");
	    return _ex2 * n * hermite(n-1, x).hold();
}

REGISTER_FUNCTION(hermite, eval_func(hermite_eval).
                        evalf_func(hermite_evalf).
                        derivative_func(hermite_deriv).
		        latex_name("H"));

//////////
// Gegenbauer (ultraspherical) polynomials C^a_n(x)
//////////

static ex gegenb_evalf(const ex& n, const ex &a, const ex& x, PyObject* parent)
{
	if (not is_exactly_a<numeric>(x)
             or not is_exactly_a<numeric>(a)
             or not is_exactly_a<numeric>(n))
                return gegenbauer(n,a,x).hold();

        // see http://dlmf.nist.gov/18.5.E9
        numeric numn = ex_to<numeric>(n);
        numeric numx = ex_to<numeric>(x);
        numeric numa = ex_to<numeric>(a);
        numeric num2a = numa * (*_num2_p);
        std::vector<numeric> numveca, numvecb;
        numveca.push_back(-numn);
        numveca.push_back(numn + num2a);
        numvecb.push_back(numa + (*_num1_2_p));
        numeric factor = numn + num2a - (*_num1_p);
        factor = factor.binomial(numn);
        return factor * hypergeometric_pFq(numveca, numvecb, ((*_num1_p)-numx)/(*_num2_p), parent);
}

static ex gegenb_eval(const ex& n, const ex &a, const ex& x)
{
	numeric numa = 1;

	if (is_exactly_a<numeric>(x)) {
                numeric numx = ex_to<numeric>(x);
                if (is_exactly_a<numeric>(n)
			and is_exactly_a<numeric>(a)
			and numx.info(info_flags::inexact))
                        return gegenb_evalf(n, a, x, nullptr);
        }

        if (not is_exactly_a<numeric>(n))
                return gegenbauer(n, a, x).hold();

        numeric numn = ex_to<numeric>(n);
        if (not numn.info(info_flags::integer) or numn < 0)
                throw std::runtime_error("gegenb_eval: The index n must be a nonnegative integer");

        if (numn.is_zero())
                return _ex1;
	if (numn.is_equal(*_num1_p))
		return _ex2 * a * x;

	if (is_exactly_a<numeric>(a)) {
		numa = ex_to<numeric>(a);
		if (numa.is_zero())
			return _ex0; // C_n^0(x) = 0
	}

	if (not is_exactly_a<numeric>(a) or numa < 0) {
		ex p = _ex1;
		ex sum = _ex0;
		ex sign = _ex1;
		ex aa = _ex1;
		unsigned long nn = numn.to_long();

		sign = - 1;
		for (unsigned long k=0; k<=nn/2; k++) {
			sign *= - 1;
			aa = a;
			p = 1;

			// rising factorial (a)_{n-k}
			for (unsigned long i=0; i<nn-k; i++) {
				p *= aa;
				aa = aa + 1;
			}

			p /= numeric(k).factorial();
			p /= numeric(nn-2*k).factorial();
			sum += pow(2*x, nn-2*k) * p * sign;
		}
		return sum;
	}

	// from here on see flint2/fmpq_poly/gegenbauer_c.c
	numeric numer = numa.numer();
	numeric denom = numa.denom();
	numeric t = numn.factorial();
	numeric overall_denom = pow(denom, numn) * t;

	unsigned long nn = numn.to_long();
	numeric p = t / (numeric(nn/2).factorial());
	if ((nn%2) != 0u)
		p *= *_num2_p;
	if ((nn&2) != 0u)
		p = -p;

	for (unsigned long k=0; k < nn-nn/2; k++) {
		p *= numer;
		numer += denom;
	}

	p *= denom.power(nn/2);
        ex sum = _ex0;
	if ((nn%2) != 0u)
		sum += x*p;
	else
		sum += p;

	for (long k=nn/2-1; k>=0; --k) {
		p *= numer;
		p *= 4*(k+1);
		p *= *_num_1_p;
		p /= denom;
		p /= nn-2*k-1;
		p /= nn-2*k;
		sum += pow(x, nn-2*k) * p;
		numer += denom;
	}

        return sum / overall_denom;
}

static ex gegenb_deriv(const ex& n, const ex & a, const ex & x, unsigned deriv_param)
{
	    if (deriv_param == 0)
                    throw std::runtime_error("derivative w.r.t. to the index is not supported yet");
	    if (deriv_param == 1)
                    throw std::runtime_error("derivative w.r.t. to the second index is not supported yet");

	    return _ex2 * a * gegenbauer(n-1, a+1, x).hold();
}

REGISTER_FUNCTION(gegenbauer, eval_func(gegenb_eval).
                        evalf_func(gegenb_evalf).
                        derivative_func(gegenb_deriv).
		        latex_name("C"));

} // namespace GiNaC
Ejemplo n.º 6
0
static ex exp_imag_part(const ex & x)
{
	return exp(GiNaC::real_part(x))*sin(GiNaC::imag_part(x));
}

static ex exp_conjugate(const ex & x)
{
	// conjugate(exp(x))==exp(conjugate(x))
	return exp(x.conjugate());
}

REGISTER_FUNCTION(exp, eval_func(exp_eval).
                       evalf_func(exp_evalf).
                       expand_func(exp_expand).
                       derivative_func(exp_deriv).
                       real_part_func(exp_real_part).
                       imag_part_func(exp_imag_part).
                       conjugate_func(exp_conjugate).
                       latex_name("\\exp"))

//////////
// natural logarithm
//////////

static ex log_evalf(const ex & x)
{
	if (is_exactly_a<numeric>(x))
		return log(ex_to<numeric>(x));
	
	return log(x).hold();
}
Ejemplo n.º 7
0
		case info_flags::negint:
		case info_flags::nonnegint:
		case info_flags::has_indices:
			return arg.info(inf);
	}
	return false;
}

static bool conjugate_info(const ex & arg, unsigned inf)
{
	return func_arg_info(arg, inf);
}

REGISTER_FUNCTION(conjugate_function, eval_func(conjugate_eval).
                                      evalf_func(conjugate_evalf).
                                      expl_derivative_func(conjugate_expl_derivative).
                                      info_func(conjugate_info).
                                      print_func<print_latex>(conjugate_print_latex).
                                      conjugate_func(conjugate_conjugate).
                                      real_part_func(conjugate_real_part).
                                      imag_part_func(conjugate_imag_part).
                                      set_name("conjugate","conjugate"))

//////////
// real part
//////////

static ex real_part_evalf(const ex & arg)
{
	if (is_exactly_a<numeric>(arg)) {
		return ex_to<numeric>(arg).real();
Ejemplo n.º 8
0
/*
**
** void	setup_spop(EVOLDATA ev, MATRIX fSearchPop, VECTOR fRefProbDist,
**						MATRIX fRefPop, MATRIX fLC, MATRIX fDC)
**						
** Sets up the search population by performing the initial evaluations.
**
** Assumes that ref. population is already setup and SORTED
**
*/
void	setup_spop(EVOLDATA ev, MATRIX fSearchPop, VECTOR fRefProbDist,
						MATRIX fRefPop, MATRIX fLC, MATRIX fDC)
{
	int i, j, k, iSelIndex;
	float fRandVal;
	float fTempVec[MAXVECTOR];
	int	iFlag;

	for (i=1; i<=ev.iSearchPopSize; i++)
	{
		eval_func(fSearchPop[i], ev.iNumTestCase, ev);  /* simple evaluation */

		
		/* now, pick a reference vector at RANDOM (0) or ORDERED (1) */
		if (ev.iSelRefPoint == RANDOM)
			iSelIndex = (int)randgen(1.0, (float)ev.iRefPopSize);
		else
		{	
		fRandVal = randgen(0.0, 1.0);
		k=1;
		while (fRandVal >= fRefProbDist[k])
			k++;
		if (k >= ev.iRefPopSize) k = 1;
		iSelIndex = k;
		}
						
		/* move from search to reference */
		k = 0; iFlag = FALSE; fRandVal = 0.0;

		if (ev.iRepairMethod == RANDOM)
		do
		{
			fRandVal = randgen(0.0, 1.0);
			
			for (j=1; j<=ev.iNumVars; j++)
				fTempVec[j] = fRandVal*fSearchPop[i][j] +
								(1-fRandVal)*fRefPop[iSelIndex][j];
								
			iFlag = check_all(ev, fTempVec, fLC, fDC);
			k++;
		} while ((iFlag == FALSE) && (k < 100));
		else if (ev.iRepairMethod == DETERMINISTIC)
		do
		{
			fRandVal = 1.0/power(2.0, k);
			for (j=1; j<=ev.iNumVars; j++)
				fTempVec[j] = fRandVal*fSearchPop[i][j] +
								(1-fRandVal)*fRefPop[iSelIndex][j];		
			iFlag = check_all(ev, fTempVec, fLC, fDC);
			k++;
		} while ((iFlag == FALSE) && (k < 20));
		
		/* if no feasible Z, Z = Y */
		if (iFlag == FALSE)
			for (j=1; j<=ev.iNumVars; j++)
				fTempVec[j] = fRefPop[iSelIndex][j];
		
		/* now, evaluate Z */
		eval_func(fTempVec, ev.iNumTestCase, ev);
		
		/* if Z better than Y, replace Y by Z */
		switch(ev.iObjFnType)
		{
			case MAX:
				if (fTempVec[0] >  fRefPop[iSelIndex][0])
					for (j=0; j<=ev.iNumVars; j++)
						fRefPop[iSelIndex][j] = fTempVec[j];
				break;
			case MIN:
				if (fTempVec[0] <  fRefPop[iSelIndex][0])
					for (j=0; j<=ev.iNumVars; j++)
						fRefPop[iSelIndex][j] = fTempVec[j];
				break;
			default:
				break;
		}
		
		/* eval(X) = eval(Z) */
		fSearchPop[i][0] = fTempVec[0];
		/* if probability allows, replace X by Z as well */
		fRandVal = randgen(0.0, 1.0);
		if (fRandVal < ev.fReplRatio)
			for (j=0; j<=ev.iNumVars; j++)
				fSearchPop[i][j] = fTempVec[j];
				
		
	}

}