брокеры опционов
список интернет магазинов

Tag Archives: programación - Page 2

init php

Nunca fui un programador en serio, me gusto hasta ahí nomás, por momentos me fanatizaba pero luego de poco tiempo lo abandonaba.

Siempre odié la programación web, me parecía que no servía para un carajo y que solo se podían hacer pavaditas…

Siempre me equivoqué!

La cosa es que hace un tiempo, por cuestiones laborales me he tenido que poner a programar algunas páginas webs, estáticas, nada raro, solo css y html puro: una boludez.
Sin embargo llego el momento de hacer algunas cosas dinámicas y por eso me empecé a meter -en contra de mi voluntad- en php.

Luego de esta breve introducción les muestro una pavada -que me servirá mas de ayuda memoria que otra cosa- que se utiliza para generar un html a partir de un pequeño código php embebido que se encarga de levantar el contenido que mostrará la página desde un archivo de texto plano.

¿Para qué me sirve esto?
Para no estar modificando los menúes una y otra vez de cada página. Supongamos que tenemos una estructura repetida en 10 páginas y si necesitamos hacer un cambio debemos repetirlo en cada una de estas. Sin embargo de este modo, el código php que se encuentra en cada página va a ir a buscar el contenido a un archivo madre, algo así como un template.

El código
El código php embebido necesario para leer el txt -llamemoslé menu.txt- y cargarlo en la página html sería el siguiente:

$archivo = “menu.txt”;
$abrir = @file_get_contents($archivo);
echo $abrir;
?>”

Algunos detalles
Por supuesto que nuestro apache tiene que tener soporte para php, sino nada de lo anterior se va a ejecutar. De este modo, el navegador ni el navegante se enteran de lo que pasó atrás, ellos simplemente ven la página generada.
Otro tema a tener en cuenta es que los archivos que antes llamabamos html ahora deben tener la extensión .php .

Caracteres en un archivo binario usando C++

Escribir y leer datos en un archivo binario no presenta demasiadas dificultades. Por ejemplo, para escribir un entero “e” y un float “f” en un archivo binario “bin” hacemos lo siguiente:

int e=10;
float f=12.5;
fstream bin(“archivo.bin”, ios::binary|ios::out);
bin.write((char *)&e, sizeof(int));
bin.write((char *)&f, sizeof(float));
bin.close();

Todo es lindo y prolijo, ahora, qué pasa si tengo una cadena de caracteres al estilo C de 14 caracteres?

Bien, las cadenas de caracteres al estilo C son vectores de bytes, y por lo tanto el identificador de la variable es un puntero a la dirección de memoria del primer caracter. O sea que para escribir este flujo de 14 bytes debemos ir iterando y guardar dato por dato. Vamos a los bifes, supongamos que tenemos una cadena “pianobar”:

char pianobar[14]=”nace una flor”;
fstream bin(“archivo.bin”, ios::binary|ios::out);
for (int i=0;i<14;i++){
bin.write((char *)&pianobar[i], 1)
}

Ahora, vamos a leer esta cadena:

char pianobar[14];
fstream bin(“archivo.bin”, ios::binary|ios::in);
bin.read((char *)&pianobar, 14)

De lo anterior vemos que la escritura se hace caracter por caracter, dejando un espacio de 1 byte por cada uno, luego al momento de leer el dato, se indica la cantidad total de bytes (para el ejemplo 14) y se asigna a la variable.

El único detalle a tener en cuenta es que la longitud de la cadena que hemos definido es de 14, sin embargo posee un máximo de 13 caracteres, ya que el último caracter queda reservado para el siguiente código de finalización “\0”. Otro punto a tener en cuenta es que las cadenas, al igual que los vectores comienzan en la posición 0.

getline luego de cin

Desde no hace mucho estoy intentando aprender C++. Viste que todo el mundo te dice: “Un informático no puedo no saber C++…“, así que como creo que tienen algo de razón encaminé mi vida por el sendero del qué dirán.

C++ tiene muchas diferencias con respecto a otros lenguajes, no es solo aprenderse la nueva sintaxis, sino que existen nuevos conceptos previamente inexistentes para mi. Aparte de esto, a veces me encuentro con pequeños detalles pelotudos que me hacen renegar. Uno de esos detalles “pelotudos” se me dio este fin de semana: Simplemente utilizaba para leer un número entero el cin>>n y líneas más abajo para leer un renglón completo utilizaba un cin.getline().

Todo parecía y compilaba bien, pero al momento de ejecutar mi pequeño programa obtenía comportamientos NO esperados (para mi pobre lógica). Acá un fragmento de código que reproduce el problema:

cout<<"Cantidad de cadenas a ingresar:";
cin>>n;
for (int i=1;i<=n;i++){
cout<<"Cadena: ";
cin.getline(cadena);
}

La salida da lo siguiente:

Cantidad de cadenas a ingresar: 3
Cadena: Cadena:

Como se ve, el programa no esperó para ingresar la primer cadena, sino que siguió con el ingreso de la segunda cadena. ¿Por qué pasa esto?

El tema es que cin>> agrega al flujo de entrada previo al dato a leer un (caracter “\n”) e ignora el último (caracter “\n”). Luego, cuando getline() encuentra en el flujo ingresado previamente el primer “\n” culmina su ejecución -recordemos que el getline() lee hasta encontrar un salto de carro, o sea un “\n”-.


Solución:

Yo la hice simple, uso luego del cin un getline que lea un caracter, de modo que captura el “\n” que tanto jodía antes, quedaría así:


char s[1];
cout<<"Cantidad de cadenas a ingresar:";
cin>>n;
cin.getline(s);

for (int i=1;i<=n;i++){
cout<<"Cadena: ";
cin.getline(cadena);
}

Pedime arreglo

Ayer estaba tratando de programar el algoritmo bit-reverse order que se usa en la fft y primeramente lo había hecho a pata, bien “a lo bruto”, después me puse a mirar acá y vi que si lo hacía de manera implícita era una boludez.
Lo hice con una función recursiva, así sirve para cualquier arreglo de longitud potencia de 2, en fin, la parte del algoritmo que pone en la primer mitad los elementos de índice par y en la segunda los de índice impar, se puede hacer en dos lineas, y así economizar código. Si c es nuestro arreglo auxiliar y x el arreglo de entrada, y ambos van de 0 a N-1,

c(0:N/2 -1)=x(0:N-1:2) !– pares
c(N/2:N-1)=x(1:N-1:2) !– impares

Como decía arriba, si a esto lo pongo en una función a la que llamo recursivamente pasandole la primera mitad del vector c y luego la segunda mitad, el bit-reverse order sale por un tubo.

Arreglos implícitos

No se si el título realmente identifica lo que quiero mostrar, pero no importa…
El tema es así, para generar un vector -llamemoslo X- que vaya desde un valor determinado -límite inferior (li)- hasta otro -límite superior- con un incremento dx solíamos hacer -antes de ver la luz- un ciclo do de la siguiente manera:

do i=0,K
x(i)= li + real(i)*dx
end do

Esto me resultaba bastante incómodo, porque por cada inicialización de una variable independiente debíamos reccorrer todo un cliclo y hacer tres lineas de código, cuando en lenguajes interpretados esto se hace en una sola.

Bien, acá el tema es que fortran (ya empiezo a sentir cosas por él) es un lenguaje ecléctico entre aquelos interpretados y compilados, caracterísctica que a mi modo de ver lo destaca.

Para evitar las tediosas tres lineas anteriores, basta con definir el vector X de la siguiente manera:

X=(/(i*dx, i=li,ls)/)

Por ejemplo, si quisieramos tener valores entre -0.5 y 0.5 con un dx=0.1:

X= (/(i*0.1,i=-5,5)/)

Esto nos daría,

-0.5000000
-0.4000000
-0.3000000
-0.2000000
-0.1000000
0.000000
0.1000000
0.2000000
0.3000000
0.4000000
0.5000000

Muy útil para tener programas más limpios…
Hasta la próxima

Fortran no ha muerto

Sinceramente pensaba que fortran era de esos lenguajes viejísimos, muertos, que nunca en mi perra vida iba a ver. Una vez más me equivoqué feo.
Estoy encontrando funcionalidades en fortran que a mi modo de ver lo destacan de otros lenguajes, obviamente que depende mucho del objetivo de la aplicación que estamos programando.
En fin, yendo a los bifes les menciono algunos detalles modernos destacables relacionados con el manejo de arreglos,

  • Permite índices desde cualquier rango
    real :: x(-10:10)
    real :: y(0:10)

  • Trabajar con vectores de modo vectorizado
    write(*,*) x(0:10)
    y=x(-10:0)

  • Extraer algunos elementos del vector

    x((/1,8,5,6/)) -> esto nos devuelve una sección del arreglo con elementos x(1), x(8), x(5), x(6)

Ya volveré con algunos detalles más sobre este lenguaje que cada vez me gusta más.

Fortran en GNU/Linux

Para programar en fortran sin recurrir a compiladores propietarios encontré la alternativa ideal, por supuesto, del lado del software libre: gfortran.

Acá, algunos tips para compilar un programita con módulos:

Tengo dos fuentes, uno es el principal (main.f95) y otro es un módulo (my_mod.f95).

1) Creo el código objeto de cada uno:

$f95 -g -c -o my_mod.o my_mod.f95
$f95 -g -c -o main.o main.f95

Esto me genera los archivos objeto cuyo nombre se especificó en la opción -o y además me genera para el módulo un archivo extensión .mod (my_mod.mod)

2) Ahora lo compilo (enzalandolos y generando el ejecutable a partir de los objetos anteriores):

$f95 -o main.exe main.o my_mod.o

Ahora, uno con varios modulos:

1) Un modulo:

f95 -g -c -o my_random_module.o my_random_module.f95

2) Otro modulo:

f95 -g -c -o tri_modules.o tri_modules.f95

3) El que usa los modulos:

f95 -g -c -o ej_tres.o ej_tres.f95

4) Enlazo todo:

f95 -o ej_tres ej_tres.o my_random_module.o tri_modules.o

Social Widgets powered by AB-WebLog.com.

Social Widgets powered by AB-WebLog.com.

Social Widgets powered by AB-WebLog.com.