One thing I look for in a numerical package is the ability to make nice plots (typically PDF) of what I’m working on. I know I could almost always work on my data, export it, and make a great graph… but in keeping with the 80/20 rule I want to be able to do most of my plots without a lot of extra work. This is especially true if I’m making a one-off plot for class notes. For publications, I’d be happy to hand draw the figure in blood while standing on my head if I had to. The bottom line is: it’s 2009, making a nice looking PDF plot should be easy.

Here is an example along with some quick tips I’ve found along the way. Hopefully these are easier to find for you than they were for me (digging through docs and searching through listservs). Remember, Octave is scriptable so you can save this in a plot template or a function, and make your plots even easier.

Nice EPS output:

h = figure;
set (h,'papertype', '<custom>')
set (h,'paperunits','inches');
set (h,'papersize',[3 2.5])
set (h,'paperposition', [0,0,[3 2.5]])
set (h,'defaultaxesposition', [0.15, 0.15, 0.75, 0.75])
set (0,'defaultaxesfontsize', 14)
plot(rand(50,1))
xlabel('Time (s)')
ylabel('Velocity (m/s)')
print('figure.eps','-deps')

The commands here select the papertype (as custom) and use inch units (could be ‘centimeters’ too). Next, set the paper size (figure size) and the position on the paper. The coordinates for paper position are [left bottom width height]. The default axes position is similar, although now in normalized units (between 0 and 1). I like the look of these axes, and there isn’t too much whitespace. I also like a clear legible font size (14 in this example). The rest are some axes labels.

Nice PDF plots

PDF plots are still problematic because it seems like I have to run an extra step. Either I can convert the EPS to PDF, or I can export PDF and then crop the PDF so the whole page isn’t showing. For the former option, I just open the EPS in Preview.app and save as a PDF (this gives me the intermediate preview step for free). For the latter option, I have found pdfcrop useful. This is a little utility that ships wih TeX-Live which I have installed as part of MacTex 2008. There is a newer version MacTex 2009. In any case, the only major difference is the final print command:

print('figure.pdf','-dpdf')

If you have a more elegant solution, please let me know. I think better PDF exports are on the list for Octave development but the current priority (in terms of graphics output) seems to be breaking away from Gnuplot and allowing other graphics backends. In general, this is a good thing. I love Gnuplot, but there are certainly uses where Gnuplot isn’t the best tool in the toolbox.

Endnote: I’m using Octave 3.2.2 and Gnuplot 4.2 patchlevel 5 on a PPC mac. These packages were downloaded from Octave Forge.

Here’s an octave function for doing the previously-mentioned modeling, including the optimization. The function file is generated automatically, it can easily be extended to more fields and/or Gaussians in the mixture. Prior to applying this function, the data must of course be appended/combined together and the frequency data monotonically increasing by introducing the aforementioned frequency offset(s).

function [func p c d]=fitMultipleGaussMix(m,spin,larm,params,g)
% a script for fitting multi-field data to find delta cs iso, cq and eta

%te=ampl>eps; [ii jj]=find((te(2:end)-te(1:end-1))!=0); 

%pk_pos(:,1) = (sum(reshape(g(ii,1),2,length(ii)/2))./2)';
%pk_pos(:,2)=max(g(:,2)).*ones(size(pk_pos(:,1))).*0.5;

%plot(g(:,1),g(:,2),pk_pos(:,1),pk_pos(:,2),'x');  

%print('output1.eps','-depsc');

I=spin;
tempA = 3e5 * (I* (I+1) - 3/4)./ ((2* I * (2*I-1))^2 * larm.^2);

constA(1:m,:)=tempA(1);
constA(m+1:2*m,:)=tempA(2);

constA=constA';

%sample peak width & amplitude

%[a b]=max(abs(g(:,2))); wid = abs(g(b-1,1)-g(b+1,1)); amp = 0.5*a;

%make a function file, gaussian mixture

str = [ 'function [y]=gaussMix(x,temp)',
        ' ',
        '% custom gauss mix for lineshape fit',
        '% wjb 02/09',
        ' ',
        'constA = [',num2str(constA),'];',
	'constA = transpose(constA);',
	'p(1:',num2str(m),',1)=temp(1:',num2str(m),'); p(1:',num2str(m),',2)=temp(',num2str(m+1),':',num2str(2*m),'); p(1:',num2str(m),',3)=temp(',num2str(2*m+1),':',num2str(3*m),')-constA(1:',num2str(m),').*temp(',num2str(3*m+1),':',
num2str(4*m),').^2;','p(',num2str(m+1),':',
num2str(2*m),',1)=temp(',num2str(5*m+2),').*
temp(1:',num2str(m),');p(',num2str(m+1),':',
num2str(2*m),',2)=temp(',num2str(4*m+1),':',num2str(5*m),');
p(',num2str(m+1),':',num2str(2*m),',3)=temp(',num2str(5*m+1),')+
temp(',num2str(2*m+1),':',num2str(3*m),')constA(',num2str(m+1),':',
num2str(2*m),').*temp(',num2str(3*m+1),':',num2str(4*m),').^2;'];

fid=fopen('gaussMix.m','w'); fdisp(fid,str); 

str= 'y=';

for i=1:2*m-1

str = [str, ' p(',num2str(i),',1)./(sqrt(2*pi)*p(',num2str(i),',2)).*exp(-((x-p(',num2str(i),',3)).^2)./(2*p(',num2str(i),',2).^2)) + '] ;

end

str=[str, 'p(',num2str(2*m),',1)./(sqrt(2*pi)*p(',num2str(2*m),',2)).*exp(-((x-p(',num2str(2*m),',3)).^2)./(2*p(',num2str(2*m),',2).^2));'];
fdisp(fid,str);  fclose(fid);

[func p c d]=leasqr(g(:,1),g(:,2),params,"gaussMix",0.0000000001,4000);

%print('output2.eps','-depsc');

%[l ll]=size(q);

%p=reshape(p,length(p)/3,3);

%p(:,1)=p(:,1)./sum(p(:,1));

Today I’m starting a new personal project. As I do a lot of scientific programming, mostly with Matlab, I have found very inconvenient the fact that I cannot enter greek character in my codes. I will give you a simple example, so you understand what I’m talking about.

If I want to write the next equation into code,

my current Matlab code looks like this:
THETA = THETAo/(THETAo^2 + LAMBDAo^2);

Wouldn’t the code be nicer if you could write:
Θ = Θo/(Θo^2 + Λo^2);

For this reason I am starting GατΩR, a text editor tailored to scientific programming languages, as Matlab, with the only purpose to help in the readability of scientific codes involving a lot formulas containing variables that are normally represented with Greek letters.

The December, 2009 issue of Linux For You carries the first part of my article series on GNU Octave. I have started this series by talking about Matrices. In the upcoiming  January,2010 issue I will talk about solving Linear equations.

This article marks my foray into writing about scientific computing tools and also a article series.

For the sake of ToC:

1. Getting Started with GNU Octave, Part -1 : December, 2009 issue of Linux For You

(The Linux For You folks have a awesome Typesettinng team)

Según varios estudios sobre el llamado Twinkle Aftereffect es posible detectar partes del campo visual en las cuales no disponemos de visión (un ejemplo es el punto ciego, que es la salida del nervio óptico del ojo, en el cual no disponemos de fotorreceptores, por lo tanto, no podemos ver la luz).

El principio básico consiste en hacer ver al paciente una pantalla con ruido/nieve (como la que aparece en la tele cuando ésta no está sintonizada con ningún canal) durante cierto tiempo (yo lo hago con un mínimo de 30 segundos, ya que necesita un tiempo para “asimilar” qué leches está viendo). Lógicamente, las zonas de la retina no funcionales visualmente hablando, no percibirán la nieve/ruido, por lo que tendrían que percibir un agujero (estos “agujeros” los podemos provocar, colocando zonas en la simulación donde no haya ruido), pero durante el proceso visual, rellenamos esos huecos, básicamente con lo que rodea al agujero. Aquí viene cuando empezamos a jugar con la visión, si, de repente, eliminamos el ruido y colocamos una pantalla del mismo color que el fondo (en mis simulaciones utilizo un gris “neutro”). El paciente, por lo general, percibe que hay ciertas zonas del fondo gris que “vibran”, “se mueven”, “hacen cosas raras”, “hostia tú, ¡qué flipada!”… Esas zonas “hostia tú, ¡qué flipada!” son las zonas de retina que no presentan función visual, por lo que “et voilà!”, ya sabemos donde están las zonas por las que el paciente no ve.

Como colofón, voy a colocar dos imágenes con fondo gris: Una primera que muestra el ruido con un escotoma (o “hueco de no visión”) y la imagen que percibe el paciente después de un tiempo observando el ruido (con el escotoma ya “suprimido” por el sistema visual):

NOTA: Para una correcta visualización de las imágenes, pulsar sobre ellas.

El hueco se encuentra en la esquina inferior derecha del ruido

Aquí podemos observar el ruido ya rellenado

Después de varios días de inactividad bloguera, vuelvo a las andadas:

Parece que Matlab y yo nos hemos reconciliado y, aunque sigo con mi cruzada por el software libre y sigo apostando por Octave, en el trabajo utilizo indistintamente ambos.

Mi gran logro ha llegado hoy, de mano de la inspiración divina y la ciencia infusa, aunque tengo que dar las gracias a un sueño que tuve anoche, os pongo en antecedentes:

Llevo una semana y media enfrascado en la difícil situación de cómo conseguir que Matlab/Octave, más concretamente el paquete Psychtoolbox, entienda que cuando quiero utilizar 3 imágenes e interactuar con ellas para “montarlas” una sobre otra no significa que quiero sustituya una por la otra, sino que las 3 funcionen a la vez. La finalidad de ésto es mostrar a los alumnos de la Escuela de Óptica de la UMU cómo es realmente la visión humana (prometo colgar un par de imágenes).

Pues bien, anoche tuve un sueño en el que las imágenes iban cogidas de la mano y la primera de ellas guiaba a las otras y una lucecita se encendió en mi cabeza, a pesar de mi cansancio de anoche (llegué más tarde de la cuenta gracias a los dos engendros que tengo por compañeros de tertulias y puesta común de ideas y proyectos)… como iba contando, a pesar del cansancio, enchufé el ordenador, arranqué Ubuntu (sí, trabajo en casa con soft libre) y Octave hizo el resto, escribí unas cuantas líneas de código, guardé y ejecuté la simulación…

Parece que las imágenes no eran tan amigas como en mi sueño, me vuelvo a la cama a chafar un poco la oreja…

Aquí estoy yo programando con Octave

¡Otro sueño! Las imágenes ya no van de la mano, simplemente la primera guía al resto con una linterna en la mano en medio de la oscuridad, simplemente que una le dice a la otra por dónde debe ir y ésta a la última… Vuelvo a conectar el ordenador, arranco Ubuntu, Octave… escribo líneas de código, parece que va… pantalla en blanco… pantalla en gris… me crea las máscaras de transparencia… monta solo dos imágenes… ¡no! hace un pequeño esfuerzo… ¡sí! monta las tres imágenes… faltan depurar un par de detalles, pero el resultado es esperanzador.

Por cierto, no puedo olvidar que las imágenes fueron desenfocadas por mi coleguita Antonio de BBAA (también fue cámara de televisión, pero prefiere que no le recordemos esa época… una larga historia).

PD. El viernes 11 de Diciembre conferencia en el Centro Social Universitario de la Universidad de Murcia (con la flecha verde) sobre mi labor como Becario de Investigación, trataré de llevar simulaciones y unos cuantos ejemplos.

I’ve been writing GPU code for Kirchhoff Time Migration, a technique applied in seismic imaging. Among the tools used by geophysicists and other workers in oil + gas to perform seismic imaging, the most ubiquitous is probably KTM. This method is directly preceeded by the seismic image construction technique developed primarily by Hagedoorn, although both approaches essentially represent Greens functions solutions to the scalar wave equation. Data surveys are constructed using an array of pulsed sources and corresponding receivers. Data recorded at receiver locations (referred to as ‘traces’) generally correspond to a particular source-receiver pair, and in the simplest case source and receiver are coincident. An image into the earth is constructed by first calculating the traveltime for a given src/rec position and image point, using these values as well as the one way traveltime and velocity at the depth in question. This traveltime is then used as an index into the trace data, to find the amplitude point (energy) which contributes to the image point. Many points from different traces constructively and destructively interfere to create the subsequent image. The initial approach developed by Hagedoorn used little more than a compass and ruler to perform this imaging task, which is to quote the vernacular ‘old school’ and provides great pedagogical insight into KTM. There is a fantastic article by Bleistein here, and below is an example of a Hagedoorn construction performed in octave; the surface is the superposition of the arcs, like figure 2 of the article.

There is no light at the end of the tunnel,
only a glorious sound
Even if you walk with your eyes closed
you can always be found

It rises ever higher
Asking you to join
Going up one octave
the Great Man in the sky
is following it
his finger tracing
stave by stave
his melody from heaven.

There is no sadness in this world
only the absence of glee
those who turn away from it
obviously cannot see

For it rises ever higher
Asking you to join.
Going up one octave,
the Great Man in the sky
is following it
his finger tracing
stave by stave
his melody from heaven.

Follow your heart and you will be
Following the melody of heaven.

Título: Octave

Autor(a): Haru Akiyama

Ano: 2008

Nº Volumes: …

Scanlations: Tranquil Spring

Aviso: esta história apresenta conteúdo erótico/sexual em certas ocasiões.

Quando era mais nova, Miyashita Yukino, queria tornar-se numa Idol. Quando viu esse sonho concretizar-se rapidamente caiu no esquecimento. O seu grupo tinha falhado em termos de vendas e rapidamente se acabaram os seus 15 minutos de fama. Regressou à escola e durante algum tempo sofreu com os insultos, gozo e troça por parte daqueles que a conheciam.

Agora, com vinte anos, Yukino vive sozinha em Tóquio tentando endireitar a sua vida. A sua vinda para Tóquio é como uma lufada de ar fresco, um recomeçar da sua vida, que rapidamente se torna em algo mais.

Trabalha como mananger de novos talentos, sendo incapaz de deixar os seus dias como Idol no passado.

Por ter passado um mau bocado enquanto estudante, rapidamente criou uma imagem muito negativa acerca dos homens. Enquanto Idol, existe um mundo que muitos desconhecem. Todo um jogo de favores e preferências e a reputação de uma Idol nunca está de todo limpa no caminho para o sucesso. Aos vinte anos, Yukino é ainda virgem e depara-se com situações que a colocam a pensar sobre toda a questão envolta nos relacionamentos e sexo.

Numa noite em que decide passar por uma lavandaria para lavar a sua roupa, encontra-se com um rapaz que lhe pergunta se alguma vez apareceu na televisão. Assombrada pelo seu passado e medo de ser reconhecida, a sua resposta é interrompida por uma rapariga que surge e rapidamente coloca o seu irmão no seu lugar.

É nessa mesma noite que conhece Setsuko, uma compositora que outrora também pertencera a um grupo Idol falhado. O seu irmão era o dono da lavandaria e pelo facto da sua irmã ter sido uma Idol, não evitou fazer a pergunta a Yukino.

A curiosidade de Yukino acerca de Setsuko e do facto desta ter sido também um Idol, faz com que Yukino se interesse na rapariga. Procura por informações e rapidamente descobre o grupo a que Setsuko pertencera. Regressa mais tarde à lavandaria e conhece um pouco mais o rapaz que naquela noite lhe perguntara acerca do seu passado.

Por não ter uma casa-de-banho no seu quarto de apartamento, Yukino costuma visitar a casa de banhos perto do seu apartamento. Nela encontra Setsuko que a convida para ir comer a sua casa.

Depois de contar as suas experiências enquanto Idol e reflectir na sua vida actual, Setsuko não arranja desculpas e confronta Yukino com o seu problema. No fundo tudo o que Yukino deseja é atenção e alguém que seja capaz de lhe dar isso.

A conversa acaba por tomar um rumo diferente e acabam por se envolver fisicamente. A partir dessa noite o romance entre as duas desperta, sem antes deixar de contar, claro, pela conhecida fase de negação por parte de Yukino até conseguir compreender as suas emoções. Durante todo esse processo, descobre ainda que a sua antiga amiga e companheira Idol, Mika, é agora uma estrela em ascensão, que deixou para trás o seu passado falhado como membro do seu antigo grupo e é agora uma nova artista com uma atitude e talento a ganhar valor.

Convencida de que tudo o que planeara iria acontecer como previu, Yukino encontra-se agora cheia de dúvidas, curiosidades e imensos caminhos por onde seguir. Repensar na sua vida e ideais começa a fazer parte do seu dia-a-dia. Setsuko abre-lhe as portas para novas experiências e sentimentos, por vezes criando ainda mais dúvidas e receios na sua cabeça, mas que num todo se resumem ao encontro de todas a sua respostas para encontrar a sua felicidade.

Um primeiro volume de leitura simples, interessante e com uma história que aborda as relações, sexualidade, mundo dos Idols, desejos, aspirações de carreira, sonhos e identidade pessoal de uma maneira diferente e um pouco fora da norma a que estamos habituados nas mais variadas mangas.

Hello all,

I did all this work in august, but forgot to create a blog to post it. I’m sure there are people out there interested in this stuff (I was but didin’t find anything!).

This are the instructions to have the Matlab CUDA plugin that Nvidia provides ( http://developer.nvidia.com/object/matlab_cuda.html ) working in Octave in linux 64 bits.

In case you didn’t know, Octave supports since 3.2 single precision floats, so I recommend that for interfacing with CUDA.

Instructions for compiling Matlab CUDA plugin for Octave in Linux:

1. Install CUDA SDK and Toolkit following instructions from Nvidia site. In ubuntu 9.04, I had to install also:

sudo apt-get install build-essential libglut3-dev
sudo aptitude install libxi-dev
sudo apt-get install libxmu-dev

Remember the last warning in the installation:

* Please make sure your PATH includes /usr/local/cuda/bin
* Please make sure your LD_LIBRARY_PATH
*   for 32-bit Linux distributions includes /usr/local/cuda/lib
*   for 64-bit Linux distributions includes /usr/local/cuda/lib64

2. Compile a program called mexext which produces “mex” as string output and put it in /usr/bin. I did

#include <stdio.h>

int main()
{
printf(“mex\n”);
return 0;
}

And compiled it, but I suppose a simple script with “echo mex” would work.

3. Use this Makefile, instead of the one supplied by Nvidia (problems with HTML formatting, see attachments at the botoom):

# Define installation location for CUDA and compilation flags compatible
# with the CUDA include files.
CUDAHOME    = /usr/local/cuda
INCLUDEDIR  = -I$(CUDAHOME)/include
INCLUDELIB  = -L$(CUDAHOME)/lib64 -lcufft -lcudart -Wl,-rpath,$(CUDAHOME)/lib64
CFLAGS      = -fPIC -D_GNU_SOURCE -pthread -fexceptions -Wall
COPTIMFLAGS = -O3 -funroll-loops -msse2

# Define installation location for Octave
MEX = /usr/bin/mkoctfile
MEXEXT        = .mex
MEXOPT   = –mex

# nvmex is a modified mex script that knows how to handle CUDA .cu files.
NVMEX = ./nvmkoctfile

# List the mex files to be built.
MEXFILES = fft2_cuda.mex       \
fft2_cuda_sp_dp.mex \
ifft2_cuda.mex      \
Szeta.mex

all: $(MEXFILES)

clean:
rm -f $(MEXFILES) *.linkinfo

#.SUFFIXES: .cu .o .mex

#.cu.o:
#    nvcc -c COPTIMFLAGS=’$(COPTIMFLAGS)’  $< $(INCLUDEDIR) $(INCLUDELIB)

#.mex:
#    $(MKOCTFILE) CFLAGS=’$(CFLAGS)’ COPTIMFLAGS=’$(COPTIMFLAGS)’ $@ \
#        $(INCLUDEDIR) $(INCLUDELIB)

.SUFFIXES: .cu .cu_o .mex

.c.mex:
CFLAGS=’$(CFLAGS)’ COPTIMFLAGS=’$(COPTIMFLAGS)’ $(MEX) $(MEXOPT) $< \
$(INCLUDEDIR) $(INCLUDELIB)

.cu.mex:
COPTIMFLAGS=’$(COPTIMFLAGS)’ $(NVMEX) $(MEXOPT) $< $(INCLUDEDIR) $(INCLUDELIB)

3.Now perform these changes in the Octave suplied mkoctfile, and save it as nvmkoctfile in the source directory (or use the attached one, which is for Octave 3.0.1):

mkoctfile always appends -g to
: ${CFLAGS=”-g -O2″}
: ${CPICFLAG=”-fPIC”}
: ${CXX=”g++”}
: ${CXXFLAGS=”-g -O2″}
: ${CXXPICFLAG=”-fPIC”}

even if -g is not used.

Removed -g there and changed -O2 to -O3.

Also changed:

-W*)
pass_on_options=”$pass_on_options $1″
;;

to

-W*)
pass_on_options=”$pass_on_options $1″
;;
-O*)
pass_on_options=”$pass_on_options $1″
;;
-f*)
pass_on_options=”$pass_on_options $1″
;;

Change the lines

while [ $# -gt 0 ]; do
file=
case “$1″ in
*.c)
file=$1
cfiles=”$cfiles $file”
;;

to

while [ $# -gt 0 ]; do
file=
case “$1″ in
*.c | *.cu)
file=$1
cfiles=”$cfiles $file”
;;

Also

: ${CC=”gcc”}
: ${CFLAGS=”-O3″}
: ${CPICFLAG=”-fPIC”}

to

: ${CC=”nvcc”}
: ${CFLAGS=’-O3 -Xcompiler “-fPIC -D_GNU_SOURCE -pthread -fexceptions -m64″ -Xcompiler “-O3 -funroll-loops -msse2 -DNDEBUG”‘}
: ${CPICFLAG=”"}

4. Comment or remove in fft2_cuda_sp_dp.c the line

#include “matrix.h”

and make. If you have problems with “cannot be declared weak”, read http://forums.nvidia.com/index.php?showtopic=104673 .
5. If something fails, remember to do a “make clean” AND delet all .o before compiling again.

6. Now you should have working .mex CUDA functions working in Octave. Use them as you please!

P.D. WordPress does not allow textfiles, but allow .doc. Remove the .doc or change it accordingly to the attached files!

Lo siento, Matlab puede conmigo… ¿pero cómo es posible que abra el programa, ejecute la simulación y no funcione, la cierre y la vuelva a abrir (sin hacer cambio ninguno) y ahora sí funcione? (Ésto en mi tierra se conoce como tocar los huevos).

Valderrama (el de los pelos guays) antes de pasarse al Software Libre. Míchel juega con su muñequito.

En fín, que me paso 100% al software libre, soy usuario de Ubuntu desde finales de 2004 (la 1ª edición) y muy orgulloso de ello, por fín he encontrado el sustituto a mi pesadilla, se llama Octave y, de momento, solo lo encuentro como línea de comandos, pero me han dicho que hay circulando un entorno gráfico (también conocido como GUI) por la red, por lo que me bajaré el paquete (no el de Valderrama, ése se lo dejo a Míchel, que parece entusiasmado) y lo instalaré, ya os contaré que tal.

También me he enterado que en Santa Otilia, patrona de la Escuela de Óptica, tengo que dar unas charlas sobre lo que estoy haciendo con mi Beca de Investigación. Ya me lo imagino: “Bueno chicos, os voy a decir que mi trabajo consiste básicamente en pelearme con un programita llamado MatLab, que se dedica a tocarme los… esto…, que me ayuda a realizar simulaciones de problemas, de test, etc… que podemos utilizar para analizar a nuestros pacientes… ¿Mi recomendación? Tiraros por un barranco antes de usarlo… quiero decir… sed buenos ópticos y dedicaros a la investigación que es guay”. En fín, que me tendré que ir preparando para darlas, improvisaré un Powerpoint (más bien dicho una presentación) y me iré preparando para lo que venga.

El Doctor con el Capitán Jack Harkness y la Doctora Martha Jones

Por cierto, me veo en la obligación de

recomendar la siguiente página

(http://www.humorfriki.com)… ¡sí! ¡soy un poco friki! … ¡vale! ¡soy muy friki! pero no llego al extremo de ver las series en japones subtituladas en japonés… me he quedado en el límite de ver todas las temporadas de Doctor Who (la recomiendo, me quedo con el Cuarto, el Noveno y el Décimo Doctor).

before i start i want to ‘lol’ first.
hahahaha….
because i forgot that i had created this web interface..

Picture 1.

When you click the “Click Me” button, it will call the “java-tws.php” function and then start a connection between computer host with TINI Microcontroller via telnet. And then, it will run several commands to get some temperature datas from sensors that connected on TINI microcontroller.

After that, temperature data will store on mysql database on host computer (this computer can easily say as a “server”). The data numerically compute by software like Octave/Matlab (call heat2d function). After this proccess has done, Octave/Matlab store the output value on mysql and then we can view the results on web page.

it’s so simple.
but hard on implementation.

agung.ridwan.sn

PS: if i’m online @my home, you can try to access the page by this url: http://agungridwan.mine.nu/tini/ajax/

Do il via ad un’altra rubrica, Appunti, nella quale inseriro’ cose che reputo interessanti trovate su libri, in rete o uscite fuori durante discussioni. Parto da un argomento che mi piace molto. Sul forum Debianizzati.org e’ stato aperto il thread intitolato Interpolazione con polinomio di x-grado. Viene proposta come soluzione l’uso alternativo di questi programmi: GNUplot, Octave e Qtiplot. Vediamo gli esempi indicati nel forum.

GNUplot
gnuplot> f(x) = a0 + a1*x + a2*x**2 + a3*x**3 + a4*x**4 + a5*x**5
gnuplot> fit f(x) "data.txt" via a0, a1, a2, a3, a4, a5
(dove in data.txt sono contenute le coppie [xi yi], xi e yi separati da un “tab” e ogni punto è su una nuova riga)

a0              = -113.631           +/- 1.49         (1.311%)
a1              = 14.7619            +/- 0.3216       (2.178%)
a2              = 0.00811888       +/- 0.02657      (327.3%)
a3              = -0.00297494      +/- 0.001054     (35.43%)
a4              = 7.67038e-06      +/- 2.015e-05    (262.6%)
a5              = -6.30903e-08     +/- 1.49e-07     (236.1%)

Octave
octave> x = [x0, x1, x2, ... xn]
octave> y = [y0, y1, y2, ... yn]
octave> polyfit(x, y, 5)

a0      = -1.1363e+02
a1      = 1.4762e+01
a2      = 8.1189e-03
a3      = -2.9749e-03
a4      = 7.6704e-06
a5      = -6.3090e-08

Qtiplot
(tutto graficamente)
- importare i valori xi e yi nella tabella che si presenta all’avvio
- scegliere dal menu “Analysis” l’opzione “Fit Wizard”
- (dopo aver dato un paio di “cancel” [qtiplot vuole assolutamente che scegliate la direcotry dei plugin, anche se per quest'operazione non serve]) Da “built-in” scegliere la funzione “Polynomnial”, scegliere poi il grado del polinomio utilizzando l’apposito campo ed infine pigiare il pulsante “Add expression” e “Fit >>”
- se si vuole si può cambiare ora qualche parametro (come gli intervalli degli assi X e Y, …), ma basterà pigiare ancora “Fit” per ottenere gli indici, la funzione e il grafico

a0       = -1.136312982562263e+02 +/- 1.490197698617564e+00
a1       = 1.476186506677628e+01 +/- 3.215805529182810e-01
a2       = 8.118882399515939e-03 +/- 2.656935116007203e-02
a3       = -2.974939167013951e-03 +/- 1.053944253900844e-03
a4       = 7.670375583296754e-06 +/- 2.014563182154056e-05
a5       = -6.309032269277494e-08 +/- 1.489855699192030e-07

Ad essere sincero Qtiplot non lo conoscevo, ma continuo a preferire Octave. Mi raccomando, chi fosse interessato partecipi sul forum.

Fonte: Forum Italiano Debian – Debianizzati.Org

Approfondimenti: Interpolazione polinomiale

[^] torna su | post<li> | 

Written by Gary Ewer, from “The Essential Secrets of Songwriting” website. You can read Gary’s songwriting e-books (and take advantage of a free deal) by visiting the Online Store.

It never ceases to amaze me how similar melodies are, no matter what genre, or even historical period, you examine. There really isn’t much difference between a good melody by Bach, and a good melody by Bob Dylan. Performance style accounts for the main difference. This means that if we follow the same guidelines Bach followed, we’ll get a well-structured melody. Here are five of those guidelines.

1. The interval between your highest note and lowest note should not (or rarely) exceed an octave and a half. (Not including any improvised melismas or other melodic variations.)
2. Melodies should contain repeating elements – certain intervals that recur, rhythms you use consistently, and so on. This adds a sense of form and structure specifically to your melody, and also to your song in general.
3. Melodies should be mainly comprised of stepwise motion, with occasional leaps for energy and interest. Not only is it easier to sing, it’s easier for listeners to remember.
4. Always be aware of how the melody line moves in relation the bass line. There are four possibilities: parallel motion (both parts move in the same direction by the same interval); similar motion (both parts move in the same direction by a different interval); oblique motion (one part stays the same while the other moves); and contrary (both parts move in opposite directions. The ideal is to have a good mixture of all four possibilities between the bass line and melody. Applying this guideline means you need to give active thought to your bass line – always a good thing!
5. Most melodies will benefit by having a climactic point, down from which it moves to a cadence (a “rest spot”). A climactic point is usually the highest note, but also refers to the moment of highest energy, which may not be the highest pitch. Think of the refrain in Dylan’s “The Times They Are A-Changin’” – the climactic point is in and around the word “times”, and the line then descends to a cadence- i.e., the end of the phrase.

All good melodies work hand-in-hand with the lyric. So decisions regarding specific choices of pitches and rhythms will need to use lyric as one of the main determining factors. But beyond that, applying the guidelines above will ensure that you’ve got a great melody that’s really got a chance of being a winner.

___________

Gary’s written six songwriting e-books designed to get you writing the songs you’ve always known you could write. It examines some of the world’s best songs, and shows you why they work, and what you can do to get your own songs sizzling! Read about those books here.

Octave is a computer program for performing numerical computations. It is mostly compatible with MATLAB.

As part of the GNU Project, it is free software under the terms of the GNU General Public License.

he project was conceived around 1988. At first it was intended to be a companion to a chemical reactor design course. Real development was started by John W. Eaton in 1992. The first alpha release dates back to January 4, 1993 and on February 17, 1994 version 1.0 was released. Version 3.0 was released on December 21, 2007.

The program is named after Octave Levenspiel, a former professor of the principal author who was known for his ability to perform quick back-of-the-envelope calculations.

In addition to use on desktops for personal scientific computing, octave is used in academia and industry. For example, Octave was used on a massive parallel computer at Pittsburgh supercomputing center to find vulnerability related to guessing social security numbers

Technical details

• Octave is written in C++ using STL libraries.
• Octave uses an interpreter to execute the Octave scripting language.
• Octave is extensible using dynamically loadable modules.
• Octave interpreter works in tandem with gnuplot and Grace software to create plots, graphs, and charts, and to save or print them.

Octave, the language

The Octave language is an interpreted programming language. It is a structured programming language (similar to C) and supports many common C standard library functions, and also certain UNIX system calls and functions. However, it does not support passing arguments by reference.

Octave programs consist of a list of function calls or a script. The syntax is matrix-based and provides various functions for matrix operations. It is not object-oriented, but it does support various data structures.

Its syntax is very similar to MATLAB, and careful programming of a script will allow it to run on both Octave and MATLAB.

Because Octave is made available under the GNU General Public License, it may be freely copied and used.[1] The program runs under most Unix and Unix-like operating systems, as well as Microsoft Windows.

octave:3> A = [1 7 -2; 4 -1 6]
A =

1   7  -2
4  -1   6

octave:4> B = ( A < 0 )
B =

0   0   1
0   1   0

Tyger recently developed an interest in structured music. She practiced on the piano for several days, developing an idea of chords, octaves, and pitch. Then she asked to try the fiddle.

I was hesitant at first, thinking she merely wanted to use the 1/4-sized instrument (which was Billy’s, and which he had neglected) as a toy. But I was wrong. When I finally sat her on my lap and showed her how to hold the fiddle and bow, she made real efforts to play something that sounded like music.

Of course, she has a ways to go. She needs to grow bigger before she will be able to properly hold the fidle in position, and draw the bow gracefully and with long sweeps, but her interest is there, and I am proud of heer.

Octave has released a major version 3.2 and now the latest bug fix release is 3.2.3. I decided to install it. What I did was to download the tarball from www.octave.org and then unzip it. After that, I run the configure:

./configure --prefix=$HOME/Programs/Octave-3.2.3

where the prefix defines the location where to install the new version of octave. I got some warning on the graphics library since Octave 3.2 uses a different graphics library.

configure: WARNING: qrupdate not found. The QR & Cholesky updating functions will be slow.
configure: WARNING: GraphicsMagick++ config script not found. Assuming GraphicsMagic++ library and header files are missing, so imread will not be fully functional
configure: WARNING: "FTGL headers not found. Native renderer will not have on-screen text"
configure: WARNING: "FLTK config script not found. Native graphics will be disabled."
configure: WARNING:
configure: WARNING: I didn't find the necessary libraries to compile native
configure: WARNING: graphics. It isn't necessary to have native graphics
configure: WARNING: but you will have to use gnuplot or you won't be able
configure: WARNING: to use any of Octave's plotting commands
configure: WARNING:


To solve this problem, I run Adept package manager and install the following:

libgraphicsmagick++1-dev
ftgl-dev
libfltk1.1-dev