int main(void){
float *u_past;
float *u_present;
int n_points=100;
u_present = reserva(n_points);
u_past = reserva(n_points);
return 0;
}
float *p_cruz(float *x, float *y){
float *z=reserva();
z[0]=x[1]*y[2]-x[2]*y[1];
z[1]=x[2]*y[0]-x[0]*y[2];
z[2]=x[0]*y[1]-x[1]*y[0];
return z;
}
float *suma_vec(float *x, float *y){
float *z=reserva();
int i;
for(i=0; i<3; i++)
z[i]=x[i]+y[i];
return z;
}
float *p_escalar(float a, float *x){
float *y=reserva();
int i;
for (i=0; i<3; i++)
y[i]=a*x[i];
return y;
}
int main() {
LUGARES *lugares = (LUGARES *) malloc (sizeof(LUGARES));
int first;
reserva(lugares, 2, &first);
printf("%d\n", first);
return 0;
}
int main(int argc, char **argv){
int n_iterations=atoi(argv[1]);
int n_puntos=1000;
int i;
int j;
float *valores=reserva(n_iterations);
float suma;
for (j=0;j<n_iterations;j++){
suma=0;
srand48(time(NULL)+1000*j);
for (i=0;i<1000;i++){
suma=suma+fun(drand48());
}
valores[j]=suma/1000.0;
}
print_array(valores, n_iterations);
return 0;
}
void main (){
double *A;
int i;
int n_walkers = 500000;
A = reserva(n_walkers);
#pragma omp parallel for
for (i=0; i<n_walkers; i++){
A[i] = walk(10.0, i);
}
print(A,n_walkers);
}
::Ice::DispatchStatus
UC3M::CineTicketService::___reserva(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
__checkMode(::Ice::Normal, __current.mode);
::IceInternal::BasicStream* __is = __inS.startReadParams();
::Ice::Int horaSesion;
::Ice::Int numeroButaca;
__is->read(horaSesion);
__is->read(numeroButaca);
__inS.endReadParams();
::Ice::Int __ret = reserva(horaSesion, numeroButaca, __current);
::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
__os->write(__ret);
__inS.__endWriteParams(true);
return ::Ice::DispatchOK;
}
// ----------------------------- Referencia::ListaIdentificadores::calculaIds()
inline
void Referencia::ListaIdentificadores::calculaIds(const std::string & ref)
{
char * ptr;
const char * org;
unsigned int tamRef = ref.size();
unsigned int posIds[ tamRef + 1 ];
init();
lista = new(std::nothrow) char[ tamRef + 1 ];
if ( lista != NULL ) {
// Copiar la cadena, hallando el num de ids.
num = 1;
ptr = lista;
org = ref.c_str();
posIds[ 0 ] = 0;
while( ( *ptr = *org ) != '\0' ) {
if ( *ptr == CHR_SEP_IDENTIFICADOR ) {
// Guardar la posición del id
posIds[ num++ ] = ( ( ptr + 1 ) - lista );
// Cambiar el punto por un 0
*ptr = 0;
}
++ptr, ++org;
}
// Reservar la memoria necesaria
reserva( alinea( num ) );
// Establecer los id's
for(unsigned int i = 0; i < num; ++i) {
// Guardar índice de id en vector de posiciones
ids[ i ] = lista + posIds[ i ];
}
// Si la referencia es '.'
if ( tamRef == 1
&& *lista == CHR_SEP_IDENTIFICADOR )
{
num = 1;
}
}
}
void menu(reservas lista_reservas, prereservas lista_pre) {
int menu=9;
do {
printf("Menu:\n1- Reservar lavagem ou manutenção\n2- Cancelar reserva de lavagem ou manutenção\n3- Cancelar pré-reserva de lavagem ou manutenção\n4- Listar reservas e pré-reservas\n5- Listar reservas e pré-reservas associadas a um cliente\n6- Lavagem ou Manutenção Concluida\n0- Sair\nO que fazer? ");
scanf("%d", &menu);
getchar(); //eliminar o '\n' não lido pelo scanf
switch(menu) {
case 0:
clear_screen();
printf("A terminar...\n");
break;
case 1:
clear_screen();
reserva(lista_reservas, lista_pre);
break;
case 2:
clear_screen();
cancela(lista_reservas, lista_pre);
update_reservas(lista_reservas);
break;
case 3:
clear_screen();
cancela_pre(lista_pre);
update_prereservas(lista_pre);
break;
case 4:
clear_screen();
listar(lista_reservas, lista_pre);
break;
case 5:
clear_screen();
listar_cliente(lista_reservas, lista_pre);
break;
case 6:
clear_screen();
concluida(lista_reservas, lista_pre);
break;
default:
clear_screen();
printf("Não é uma opção válida!\n");
}
} while(menu != 0);
}
LUGARES* reserva(LUGARES* livres, int n, int* reservado) {
if(livres == NULL) {
(*reservado) = -1;
return livres;
}
if( livres->end - livres->begin > n ) {
(*reservado) = livres->begin;
livres->begin += n;
}
else if( livres->end - livres->begin == n) {
(*reservado) = livres->begin;
return livres->next;
}
else {
return reserva(livres->next, n, reservado);
}
return livres;
}
int main(int argc, char **argv){
if(argc!=3){
printf("USAGE: %s\n", USAGE);
exit(1);
}
int n_iterations=atoi(argv[1]);
int n_burn=atoi(argv[2]);
int iterMCMC;
int numT;
iterMCMC=n_iterations+n_burn;
double *x,*t;
double *a,*b,*c,*d,*chi;
t=reserva(3000);
x=reserva(3000);//Se usa mucho mas espacio del necesario para no tener problemas con el numero de datos
a=reserva(iterMCMC);
b=reserva(iterMCMC);
c=reserva(iterMCMC);
d=reserva(iterMCMC);
chi=reserva(iterMCMC);
a[0]=0;
b[0]=0;
c[0]=0;
d[0]=1;
numT=importarDatos(t,x,"monthrg.dat");
mcmc(chi,a,b,c,d,x,t,numT,iterMCMC);
imprimirResultados("a",a,n_burn,n_iterations);
imprimirResultados("b",b,n_burn,n_iterations);
imprimirResultados("c",c,n_burn,n_iterations);
imprimirResultados("d",d,n_burn,n_iterations);
guardar(chi,a,b,c,d,n_burn,n_iterations);
guardarLectura(x,t,numT);
}
// Lógica para alocar as cadeiras para o cliente.
int alocCadeiras(int sala[][TAMCADEIRA], int vagas[], int cli, int qtdReserva, int qtdFila, int tamMaiorFila) {
int i, j, maior[2]; // No array a primeira posição é a quantidade livre e segunda posição em que fila ele está;
// Só roda as reservas se o total de lugares for maior ou igual ao que o cara pediu para reservar.
if (getTotalLugares(vagas, qtdFila) >= qtdReserva) {
maior[0] = vagas[0]; // Primeira "maior" fileira com lugares livres.
maior[1] = 0; // A posição desse primeiro "maior".
// Acha um outro primeiro maior "de verdade" pela quantidade de vagas ou simplesmente o maior de todos (não vou alocar em lugares com muito mais espaço que preciso).
for (i = 0; i < qtdFila; i++) {
if (vagas[i] > maior[0]) {
maior[0] = vagas[i];
maior[1] = i;
}
// Se já achou um maior que comporta a quantidade de reservas solicitada, encerra por aqui.
if (vagas[i] >= qtdReserva) {
i = qtdFila;
}
}
// Se o maior tiver espaço o suficiente para a reserva, só reserva.
if (maior[0] >= qtdReserva) {
reserva(cli, qtdReserva, tamMaiorFila, sala, vagas, maior[1]);
return 1;
}
// Se o maior for a primeira fila.
if (maior[1] == 0) {
// Se a fila atual e a seguinte tem lugares o suficiente, reserva.
if ((maior[0] + vagas[maior[1] + 1]) >= qtdReserva) {
reserva(cli, qtdReserva, tamMaiorFila, sala, vagas, maior[1]);
reserva(cli, qtdReserva, tamMaiorFila, sala, vagas, maior[1] + 1);
return 1;
}
}
// Se o maior for a última fila.
if (maior[1] == (qtdFila - 1)) {
// Se a fila atual e a anterior tem lugares o suficiente, reserva.
if ((vagas[maior[1] - 1] + maior[0]) >= qtdReserva) {
reserva(cli, qtdReserva, tamMaiorFila, sala, vagas, maior[1]);
reserva(cli, qtdReserva, tamMaiorFila, sala, vagas, maior[1] - 1);
return 1;
}
}
// Percorre toda a fila em busca de vagas com a mesma quantidade do maior (menos a primeira e segunda fila).
for (i = 1; i < (qtdFila - 1); i++) {
if (vagas[i] == maior[0]) {
maior[0] = vagas[i];
maior[1] = i;
}
// Se a fila anterior, a atual e a seguinte tem lugares o suficiente, reserva.
if ((vagas[maior[1] - 1] + maior[0] + vagas[maior[1] + 1]) >= qtdReserva) {
reserva(cli, qtdReserva, tamMaiorFila, sala, vagas, maior[1] - 1);
reserva(cli, qtdReserva, tamMaiorFila, sala, vagas, maior[1]);
reserva(cli, qtdReserva, tamMaiorFila, sala, vagas, maior[1] + 1);
return 1;
}
}
// Só reserva por aí.
for (i = 0; i < qtdFila; i++) {
for (j = 0; j < tamMaiorFila && qtdReserva > 0; j++) {
if (sala[i][j] == 0) {
qtdReserva--;
sala[i][j] = cli;
vagas[i] -= 1;
}
}
}
return 1;
}
return 0; // Não tem espaço, então retorna "false".
}