Exemple #1
0
void
ComputeCostOfBox (box *b)
{
   long different_costs;
   long i;
   long j;
   long new_cost;
   cost_info cost_list[MAX_PARTICLES_PER_BOX];
   cost_info winner;
   long winner_index;
   long cost_index[MAX_PARTICLES_PER_BOX];

   if (b->type == PARENT)
      b->cost = ((b->num_v_list * V_LIST_COST(Expansion_Terms))
		 / DIVISOR(Expansion_Terms)) + 1;
   else {
      different_costs = 0;
      for (i = 0; i < b->num_particles; i++) {
	 new_cost = b->particles[i]->cost;
	 for (j = 0; j < different_costs; j++) {
	    if (new_cost == cost_list[j].cost)
	       break;
	 }
	 if (j == different_costs) {
	    cost_list[different_costs].cost = new_cost;
	    cost_list[different_costs].num = 1;
	    different_costs += 1;
	 }
	 else
	    cost_list[j].num += 1;
      }

      winner.cost = cost_list[0].cost;
      winner.num = 1;
      winner_index = 0;
      cost_index[0] = 0;
      for (i = 1; i < different_costs; i++) {
	 if (cost_list[i].num > cost_list[winner_index].num) {
	    winner.cost = cost_list[i].cost;
	    winner.num = 1;
	    winner_index = i;
	    cost_index[0] = i;
	 }
	 else {
	    if (cost_list[i].num == cost_list[winner_index].num) {
	       cost_index[winner.num] = i;
	       winner.num += 1;
	    }
	 }
      }
      if (winner.num != 1) {
	 for (i = 1; i < winner.num; i++)
	    winner.cost += cost_list[cost_index[i]].cost;
	 winner.cost /= winner.num;
      }
      b->cost = (winner.cost * b->num_particles) / DIVISOR(Expansion_Terms);
      if (b->cost == 0)
	 b->cost = 1;
   }
}
Exemple #2
0
static int i8250_setup(struct uart *dev, const struct uart_params *params) {
	uint8_t line_stat;

	line_stat = calc_line_stat(params);

	line_stat = UART_NO_PARITY | UART_8BITS_WORD | UART_1_STOP_BIT;

	/* Turn off the interrupt */
	out8(0x0, dev->base_addr + UART_IER);
	/* Set DLAB */
	out8(UART_DLAB, dev->base_addr + UART_LCR);
	/* Set the baud rate */
	out8(DIVISOR(params->baud_rate) & 0xFF, dev->base_addr + UART_DLL);
	out8((DIVISOR(params->baud_rate) >> 8) & 0xFF, dev->base_addr + UART_DLH);
	/* Set the line status */
	out8(line_stat, dev->base_addr + UART_LCR);
	/* Uart enable FIFO */
	out8(UART_ENABLE_FIFO, dev->base_addr + UART_FCR);
	/* Uart enable modem (turn on DTR, RTS, and OUT2) */
	out8(UART_ENABLE_MODEM, dev->base_addr + UART_MCR);

	/*enable rx interrupt*/
	if (params->irq) {
		/*enable rx interrupt*/
		out8(UART_IER_RX_ENABLE, dev->base_addr + UART_IER);
	}

	return 0;
}
Exemple #3
0
static void serial_mem_hardware_init(int port, int speed, int word_bits, int parity, int stop_bits)
{
	unsigned char reg;

	/* We will assume 8n1 for now. Does anyone use anything else these days? */

	/* Disable interrupts. */
	writeb(0, MEMBASE + 0x01);

	/* Assert RTS and DTR. */
	writeb(3, MEMBASE + 0x04);

	/* Set the divisor latch. */
	reg = readb(MEMBASE + 0x03);
	writeb(reg | 0x80, MEMBASE + 0x03);

	/* Write the divisor. */
	writeb(DIVISOR(speed) & 0xFF, MEMBASE);
	writeb(DIVISOR(speed) >> 8 & 0xFF, MEMBASE + 1);

	/* Restore the previous value of the divisor. */
	writeb(reg & ~0x80, MEMBASE + 0x03);
}
void
_acb_poly_powsum_one_series_sieved(acb_ptr z, const acb_t s, slong n, slong len, slong prec)
{
    slong * divisors;
    slong powers_alloc;
    slong i, j, k, ibound, kprev, power_of_two, horner_point;
    int critical_line, integer;

    acb_ptr powers;
    acb_ptr t, u, x;
    acb_ptr p1, p2;
    arb_t logk, v, w;

    critical_line = arb_is_exact(acb_realref(s)) &&
        (arf_cmp_2exp_si(arb_midref(acb_realref(s)), -1) == 0);

    integer = arb_is_zero(acb_imagref(s)) && arb_is_int(acb_realref(s));

    divisors = flint_calloc(n / 2 + 1, sizeof(slong));
    powers_alloc = (n / 6 + 1) * len;
    powers = _acb_vec_init(powers_alloc);

    ibound = n_sqrt(n);
    for (i = 3; i <= ibound; i += 2)
        if (DIVISOR(i) == 0)
            for (j = i * i; j <= n; j += 2 * i)
                DIVISOR(j) = i;

    t = _acb_vec_init(len);
    u = _acb_vec_init(len);
    x = _acb_vec_init(len);
    arb_init(logk);
    arb_init(v);
    arb_init(w);

    power_of_two = 1;
    while (power_of_two * 2 <= n)
        power_of_two *= 2;
    horner_point = n / power_of_two;

    _acb_vec_zero(z, len);

    kprev = 0;
    COMPUTE_POWER(x, 2, kprev);

    for (k = 1; k <= n; k += 2)
    {
        /* t = k^(-s) */
        if (DIVISOR(k) == 0)
        {
            COMPUTE_POWER(t, k, kprev);
        }
        else
        {
            p1 = POWER(DIVISOR(k));
            p2 = POWER(k / DIVISOR(k));

            if (len == 1)
                acb_mul(t, p1, p2, prec);
            else
                _acb_poly_mullow(t, p1, len, p2, len, len, prec);
        }

        if (k * 3 <= n)
            _acb_vec_set(POWER(k), t, len);

        _acb_vec_add(u, u, t, len, prec);

        while (k == horner_point && power_of_two != 1)
        {
            _acb_poly_mullow(t, z, len, x, len, len, prec);
            _acb_vec_add(z, t, u, len, prec);

            power_of_two /= 2;
            horner_point = n / power_of_two;
            horner_point -= (horner_point % 2 == 0);
        }
    }

    _acb_poly_mullow(t, z, len, x, len, len, prec);
    _acb_vec_add(z, t, u, len, prec);

    flint_free(divisors);
    _acb_vec_clear(powers, powers_alloc);
    _acb_vec_clear(t, len);
    _acb_vec_clear(u, len);
    _acb_vec_clear(x, len);
    arb_clear(logk);
    arb_clear(v);
    arb_clear(w);
}
Exemple #5
0
static int
cyg_hal_plf_serial_control(void *__ch_data, __comm_control_cmd_t __func, ...)
{
    static int irq_state = 0;
    channel_data_t* chan;
    cyg_uint8 ier;
    int ret = 0;
    CYGARC_HAL_SAVE_GP();

    // Some of the diagnostic print code calls through here with no idea what the ch_data is.
    // Go ahead and assume it is channels[0].
    if (__ch_data == 0)
      __ch_data = (void*)&channels[0];

    chan = (channel_data_t*)__ch_data;

    switch (__func) {
    case __COMMCTL_IRQ_ENABLE:
        irq_state = 1;

        HAL_READ_UINT8(chan->base + SER_16550_IER, ier);
        ier |= SIO_IER_ERDAI;
        HAL_WRITE_UINT8(chan->base + SER_16550_IER, ier);

        HAL_INTERRUPT_SET_LEVEL(chan->isr_vector, 1);
        HAL_INTERRUPT_UNMASK(chan->isr_vector);
        break;
    case __COMMCTL_IRQ_DISABLE:
        ret = irq_state;
        irq_state = 0;

        HAL_READ_UINT8(chan->base + SER_16550_IER, ier);
        ier &= ~SIO_IER_ERDAI;
        HAL_WRITE_UINT8(chan->base + SER_16550_IER, ier);

        HAL_INTERRUPT_MASK(chan->isr_vector);
        break;
    case __COMMCTL_DBG_ISR_VECTOR:
        ret = chan->isr_vector;
        break;
    case __COMMCTL_SET_TIMEOUT:
    {
        va_list ap;

        va_start(ap, __func);

        ret = chan->msec_timeout;
        chan->msec_timeout = va_arg(ap, cyg_uint32);

        va_end(ap);
    }        
    break;
    case __COMMCTL_SETBAUD:
    {
        cyg_uint32 baud_rate;
        cyg_uint16 baud_divisor;
        cyg_uint8* port = chan->base;
        va_list ap;

        va_start(ap, __func);
        baud_rate = va_arg(ap, cyg_uint32);
        va_end(ap);

        switch (baud_rate)
        {
        case 110:    baud_divisor = DIVISOR(110);    break;
        case 150:    baud_divisor = DIVISOR(150);    break;
        case 300:    baud_divisor = DIVISOR(300);    break;
        case 600:    baud_divisor = DIVISOR(600);    break;
        case 1200:   baud_divisor = DIVISOR(1200);   break;
        case 2400:   baud_divisor = DIVISOR(2400);   break;
        case 4800:   baud_divisor = DIVISOR(4800);   break;
        case 7200:   baud_divisor = DIVISOR(7200);   break;
        case 9600:   baud_divisor = DIVISOR(9600);   break;
        case 14400:  baud_divisor = DIVISOR(14400);  break;
        case 19200:  baud_divisor = DIVISOR(19200);  break;
        case 38400:  baud_divisor = DIVISOR(38400);  break;
        case 57600:  baud_divisor = DIVISOR(57600);  break;
        case 115200: baud_divisor = DIVISOR(115200); break;
        case 230400: baud_divisor = DIVISOR(230400); break;
        default:     return -1;                      break; // Invalid baud rate selected
        }

        // Disable port interrupts while changing hardware
        HAL_READ_UINT8(port+SER_16550_IER, ier);
        HAL_WRITE_UINT8(port+SER_16550_IER, 0);

        // Set baud rate.
        cyg_hal_plf_serial_set_baud(port, baud_divisor);

        // Reenable interrupts if necessary
        HAL_WRITE_UINT8(port+SER_16550_IER, ier);
    }
    break;

    case __COMMCTL_GETBAUD:
        break;
    default:
        break;
    }
    CYGARC_HAL_RESTORE_GP();
    return ret;
}