int main (){
variableGlobal = 1;
funcion();
funcion();
funcion();
funcion();
printf("\n Valor final de variableGlobal= %d\n",variableGlobal);
system("pause");
return 0;
}
int main()
{
int num;
printf("numero de la serie de fibbonaci ");
scanf("%i",&num);
printf("el valore es: %d\n",funcion(num));
}
int Busca_Hash(TH *T, int m, char* k, int i)
{
cout<<endl<<i<<" "<<m<<" "<<k<<" "<<i;
int j,rep;
j = funcion(m,k,strlen(k));
while(i<m)
{
if(T[j].state == 0) {
cout<<"\nVacio";
return -1;
}
if(T[j].state==1){
rep=Buscar_Elemento(T[j].der,k);
if(rep==1)
return 1;
}
if(T[j].state==2){
if(T[j].data==k)
return 1;
else
rep=Buscar_Elemento(T[j].der,k);
if(rep==1)
return 1;
}
i++;
}
return -1;
}
int main (){
int variableLocal = 0;
printf("variable global = %i\n",variableGlobal);
printf("variable local = %i\n",variableLocal);
funcion (8);
return 0;
}
//m=tamaño de T
void Inserta_Hash(TH *T, int m, char* k)
{
Imprime_Tabla(T,m);
int j;
j = funcion(m,k,strlen(k));
cout<<endl<<j;
if(T[j].state == 0 || T[j].state ==1)
{
T[j].data = k;
T[j].state = 2;
cout<<"\nElemento insertado con exito!";
return;
}
if(T[j].state ==2){
if(T[j].der==NULL){
LE*L;
L = (LE *) Inicia_Lista();
T[j].der=L;
Inserta_Elemento(L,k);
cout<<"\nElemento insertado con exito!";
return;
}
else{
Inserta_Elemento(T[j].der,k);
cout<<"\nElemento insertado con exito!";
return;
}
}
cout<<"\nTabla llena!";
}
float funcion(float n){
if(n==1){
return 1;
}else{
return (1/n)+funcion(n-1);
}
}
void escucharUMC() {
int sockServidor;
sockServidor = nuevoSocket();
asociarSocket(sockServidor, config->puerto);
escucharSocket(sockServidor, 1);
int ret_handshake = 0;
while(ret_handshake == 0) { // Mientras que el cliente adecuado no se conecte
sockUMC = aceptarConexionSocket(sockServidor);
if ( validar_conexion(sockUMC, 0) == FALSE ) continue;
else ret_handshake = handshake_servidor(sockUMC, "S");
}
int head;
while(TRUE) {
void *mensaje = aplicar_protocolo_recibir(sockUMC, &head);
if(mensaje == NULL) {
log_info(logger, "UMC se ha desconectado.");
cerrarSocket(sockUMC);
cerrarSocket(sockServidor);
log_info(logger, "Swap ha salido del sistema.");
return;
}
void (*funcion)(void*) = elegirFuncion(head); // elijo función a ejecutar según protocolo
if(funcion == NULL) continue;
funcion(mensaje); // ejecuto función
funcion = NULL;
}
cerrarSocket(sockUMC);
cerrarSocket(sockServidor);
log_info(logger, "Swap ha salido del sistema.");
}
/* Iterador in order */
void abb_in_order_r(abb_nodo_t* nodo, bool funcion(const char*, void*, void*), void* extra){
if (nodo->izq)
abb_in_order_r(nodo->izq, funcion, extra);
funcion(nodo->clave, nodo->dato, extra);
if (nodo->der)
abb_in_order_r(nodo->der, funcion, extra);
return;
}
int main(){
float n;
printf("Introduce numero entero: ");
scanf("%f",&n);
printf("Resultado: %.2f\n",funcion(n));
getch();
return 0;
}
static int termino() //doesnt consume any tokens
{
if( funcion() || TOKEN.type ==VAR || TOKEN.type == OBJ_FUNC)
return 1;
return 0;
}
bool ShapeTroughCHC::findRoot( double (*funcion)( double, double, double, double, double, double ), double xCoord, double e, double r1, double theta, double a, double b, double y0, int max, double* alpha )
{
double r = 2 * r1 *( 1 - e * cos( theta + 0.5* gc::Pi ) );
double y1 = funcion( a, xCoord, r1, theta, r, e );
double y2 =funcion( b, xCoord, r1, theta, r, e );
double delta = fabs( a - b ) / 100;
while( ( ( y1 * y2 ) > 0.0 ) && ( a < b ) )
{
a += delta;
y1 = funcion( a, xCoord, r1, theta, r, e );
//funcion( a, r, thetaI, ray );
}
if( ( ( y1 * y2 ) > 0.0 ) || ( a > b ) ) return false;
int iterations = 0;
while( ( fabs( a - b ) > 0.000000000001 ) && ( iterations < max ) )
{
double x = ( a + b ) / 2.0 ;
//double y = funcion( x, r, thetaI, ray );
double y = funcion( x, xCoord, r1, theta, r, e );
if( y == y0 )
{
*alpha = x;
return true;
}
if( ( y > y0 ) && ( y2 > y1 ) ) b= x;
else if( ( y > y0 ) && ( y2 < y1 ) ) a = x;
else if( ( y < y0 ) && ( y2 > y1 ) ) a= x;
else b = x;
iterations++;
}
if( iterations >= max ) return false;
*alpha = ( a + b ) / 2 ;
return true;
}
double chi2(double a, double b, double c, double d, double *x, double *t, int numT){
double chi=0;
int i;
for(i=0;i<numT;i++){
chi=chi+pow(funcion(a,b,c,d,t[i])-x[i],2);
}
return chi;
}
void main()
{
int x;
x = 0;
funcion(1,2,3);
x = 1;
printf("%d\n",x);
}
int main(int argc, const char *argv[]){
double suma = 0.0;
unsigned i;
for (i = 0; i < 100000; i++) {
suma += funcion(i, i % 5);
}
printf("suma = %g\n", suma);
return 0;
}
int main(){
int random;
int estado;
int j;
funcion();
//funcion();
return 0;
}
int main()
{
int A[5];
A[0] = 3;
A[1] = 60;
A[2] = 71;
A[3] = 13;
A[4] = 743;
printf("Resultado es : %f\n",funcion(A,5));
}
int main(){
int dim,n;
printf("introdusca la dimension del vector:");
scanf("%d",dim);
float a[dim];
float* p=a;
for(i=0;i<dim;i++)
scanf("%f",p+i);
printf("ingrese n:");
scanf("%d",&n);
p=funcion(a,n);
free(p);
}
static int atomo()
{
// ( funcion() || comparacion() ) is ambiguous since both call funcion(). fix is to call funcion and if parsed ok, is next tok is
// a REL_OP, then it must be a comparision, if not, we backtrack the parse and try comparacion()
// (which will check for a funcion() or a variable as first token
int save_toks_ptr = toks_ptr;
if ( funcion() && ( tokens[toks_ptr+1].category != REL_OP) ) //if its just a funcion with no comparison next
return 1;
toks_ptr = save_toks_ptr;
return ( comparacion() );
}
void MontanaRusa::creaTuboFrenet(){
//Lo multiplicamos por el numero de vueltas
GLfloat intervalo = 2*M_PI*2/NQ;
PV3D** vertices = getVertices();
//Construimos los vertices de cada cara del tubo
for(int i=0; i<NQ; i++){
GLfloat valor = i*intervalo;
PV3D* T = primeraDerivada(valor);
T->normaliza();
PV3D* B = primeraDerivada(valor)->productoVectorial(segundaDerivada(valor));
B->normaliza();
PV3D* N = B->productoVectorial(T);
PV3D* C = funcion(valor);
for(int j=0; j<NP; j++){
int indiceVertice = NP*i+j;
PV3D* vertice = perfil[j]->multiplicaMatriz(N,B,T,C);
vertices[indiceVertice] = vertice;
}
}
//Construimos las caras
for(int i=0; i<NQ; i++){
for (int j=0; j<NP; j++){
int indiceCara = NP*i+j;
caras[indiceCara] = new Cara(4);
VerticeNormal** normalesCara = new VerticeNormal*[4];
int verticeBase = indiceCara;
int v0 = verticeBase % (NP*NQ);
int v1 = sucesor(verticeBase % (NP*NQ));
int v2 = (sucesor(verticeBase)+NP) % (NP*NQ);
int v3 = (verticeBase + NP) % (NP*NQ);
normalesCara[0] = new VerticeNormal(v0,indiceCara);
normalesCara[1] = new VerticeNormal(v1,indiceCara);
normalesCara[2] = new VerticeNormal(v2,indiceCara);
normalesCara[3] = new VerticeNormal(v3,indiceCara);
caras[indiceCara]->addVerticeNormal(normalesCara);
}
}
//Calculamos las normales de cada cara
for(int i=0; i<numCaras; i++){
normales[i] = CalculoVectorNormalPorNewell(caras[i]);
}
}
// Inserta un elemento k en la tabla T de tamañ m
void Inserta_Hash(no_hash *T, int m, int k)
{
int j, i = 0;
do
{
j = funcion(k, m, i);
if(T[j].state == 0 || T[j].state == 1)
{
T[j].data = k;
T[j].state = 2;
printf("\nElemento insertado con éxito!");
return;
}
else
i++;
}while(i < m);
printf("\nTabla llena!");
}
int Busca_Hash(no_hash *T, int m, int k, int i)
{
cout<<endl<<m<<" "<<k<<" "<<i;
int j;
if(i < m)
{
j = funcion(k, m, i);
if(T[j].state == 0)
return -1;
else
if(T[j].state == 1)
return Busca_Hash(T, m, k, i+1);
else
if(T[j].data == k)
return j;
else
return Busca_Hash(T, m, k, i+1);
}
return -1;
}
void MontanaRusa::dibujaCoche(){
GLfloat movimiento = coche->getMovimiento();
PV3D* T = primeraDerivada(movimiento);
T->normaliza();
PV3D* B = primeraDerivada(movimiento)->productoVectorial(segundaDerivada(movimiento));
B->normaliza();
PV3D* N = B->productoVectorial(T);
PV3D* C = funcion(movimiento);
GLfloat m[] = { N->getX(), N->getY(), N->getZ(), N->isPoint(),
B->getX(), B->getY(), B->getZ(), B->isPoint(),
T->getX(), T->getY(), T->getZ(), T->isPoint(),
C->getX(), C->getY(), C->getZ(), C->isPoint()};
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glMultMatrixf(m);
coche->dibuja();
glPopMatrix();
}
//factor
void factor(int toksig[])
{
int i;
int setpaso[NOTOKENS]; //conjunto de paso por valor
test(tokinifact,toksig,24); //error(24): Una expresión no puede empezar con este símbolo
while (tokinifact[token]==1) {
//mientras el token sea un símbolo inicial de factor...
if (token==ident) {
i=posicion();
if (i==0) {
copia_set(setpaso,toksig);
setpaso[parenc]=1; //setpaso=parenc+toksig
funcion(setpaso);
//error(11); //error 11: Identificador no declarado
}else if (buscarElemento(i) -> tipo==PROCEDIMIENTO)
error(21); //error 21: Una expresión no debe contener un identificador de procedimiento
obtoken();
}
else if (token == entero || token == real)
obtoken();
else if (token==parena) {
obtoken();
copia_set(setpaso,toksig);
setpaso[parenc]=1; //setpaso=parenc+toksig
expresion(setpaso);
if (token==parenc)
obtoken();
else
error(22); //error 22: Falta un paréntesis de cierre
};
init_set(setpaso); //conjunto vacío
setpaso[parena]=1; //setpaso=parena
test(toksig,setpaso,23); //error(23): El factor anterior no puede ir seguido de este simbolo o falta un punto y coma
}
}
int main(int argc, const char **argv){
double li, ls;//límites inferior y superior de la integral.
double dx = 0.25;//delta de x. Ancho. En este caso la hemos dejado siempre a 0.25 para el ejemplo. Cuanto menor la anchura, mayor precisión.
double s = 0;//Definir cuánto vale el área
system("clear");
printf("Límite inferior: ");
scanf(" %lf", &li);
printf("Límite superior: ");
scanf(" %lf", &ls);
for(double x=li; x < ls; x+=dx)
/*El área inicialmente vale 0. Ahora valdrá f(0) por la anchura.*/
s += funcion(x) * dx;
printf("\n\tÁrea = %lf\n\n", s);
return EXIT_SUCCESS;
}
void main (){
int res = funcion(4,5,6,4,3,2,1);
}
int main()
{
int x = 101;
printf("Valor es %d\n",funcion(x));
system("pause");
}
//instruccion
void instruccion(int toksig[])
{
int i;
int setpaso[NOTOKENS]; //conjunto de paso por valor
int vacio[NOTOKENS]; //conjunto vacío
init_set(vacio);
if (token==ident) {
if (esFuncion()) {
copia_set(setpaso,toksig);
funcion(setpaso);
}
else {
//ve a buscarlo a la tabla de símbolos
i=posicion();
if (i==0) {
error(11); //error 11: identificador no declarado
}
else if (buscarElemento(i) -> tipo != VARIABLE)
error(12); //error 12: no están permitidas las asignaciones a constantes o a procedimientos
obtoken();
if (token==asignacion)
obtoken();
else
error(13); //error 13: se esperaba el operador de asignación
copia_set(setpaso,toksig);
expresion(setpaso);
}
}
else if (token==calltok) {
obtoken();
if (token!=ident)
error(14); //error 14: "CALL" debe ir seguido de un identificador
else {
//buscar el nombre del procedimiento en la tabla de símbolos
i=posicion();
if (i==0)
error(11); //error 11: Identificador no declarado
else if (buscarElemento(i) -> tipo!=PROCEDIMIENTO)
error(15); //error 15 : No tiene sentido llamar a una constante o a una variable
obtoken();
}
}
else if (token==iftok) {
obtoken();
copia_set(setpaso,toksig);
setpaso[thentok]=setpaso[dotok]=1; //setpaso=thentok+dotok+toksig
condicion(setpaso);
if (token==thentok)
obtoken();
else
error(16); //error 16: Se esperaba un "THEN"
copia_set(setpaso,toksig);
instruccion(toksig);
}
else if (token==begintok) {
obtoken();
copia_set(setpaso,toksig);
setpaso[puntoycoma]=setpaso[endtok]=1; //setpaso=puntoycoma+endtok+toksig
instruccion(setpaso);
while (token==puntoycoma || token==calltok || token==begintok || token==iftok || token==whiletok || token == fortok) {
//aquí el while 'inserta' el punto y coma para continuar compilando cuando no lo encuentre
//el compilador detecta la omisión clásica del punto y coma
if (token==puntoycoma)
obtoken();
else
error(10); //error 10: Falta un punto y coma entre instrucciones
copia_set(setpaso,toksig);
setpaso[puntoycoma]=setpaso[endtok]=1; //setpaso=puntoycoma+endtok+toksig
instruccion(setpaso);
}
if (token==endtok)
obtoken();
else
error(17); //error 17: Se esperaba un "END" o un punto y coma
}
else if (token==whiletok) {
obtoken();
copia_set(setpaso,toksig);
setpaso[dotok]=1;//setpaso=dotok+toksig
condicion(setpaso);
if (token==dotok)
obtoken();
else
error(18); //error 18: Se esperaba un "DO"
copia_set(setpaso,toksig);
instruccion(setpaso);
}
else if (token == fortok) {
obtoken();
copia_set(setpaso,toksig);
setpaso[dotok]=1;//setpaso=dotok+toksig
if (token == ident) {
i = posicion();
if (i == 0) { // no se encontro el identificador
error(11); // identificador no declarado
}
else if (buscarElemento(i) -> tipo==PROCEDIMIENTO) {
error(21); //error 21: identificador de procedimiento
}
else { // era un identificador valido
obtoken();
if (token == intok) {
obtoken();
if (token == entero) {
obtoken();
if (token == dospuntos) {
obtoken();
if (token == entero) {
obtoken();
if (token == dotok) {
obtoken();
copia_set(setpaso,toksig);
instruccion(setpaso);
}
else {
error(18);
}
}
else {
error(38); // se esperaba un numero entero
}
}
else {
error(39); // se esperaban dos puntos
}
}
else {
error(38); // se esperaba un numero entero
}
}
else {
error(29); // se esperaba un IN despues del FOR
}
}
}
else
error(28);
} else if (token == booleantok) {
obtoken();
declaracionboolean();
} else if (token == codigoptok) {
obtoken();
declaracioninline();
}
//comprobación explícita de que los tokens que viene son sucesores de instrucción
copia_set(setpaso,toksig);
test(setpaso,vacio,19); //error(19): Un simbolo incorrecto sigue a una instrucción
}
void calculoLeyOhm (void (*funcion)(void))
{
funcion();
}