void fdpml1_txx(float *txxn1, float *vxn1, float *c11, float dx, int oo,
float (*fdx)(float *, int, float, int),
bool freesurface )
/*<stress decay in pml>*/
{
int ix;
/*Stress PML -- top*/
if (freesurface == false) {
for (ix=marg; ix<marg+pmlout; ix++) {
txxn1x[ix]=((1-dt*pmldx[ix]/2)*txxn0x[ix]+dt*c11[ix]*fdx(vxn1,ix, dx, oo))/(1+dt*pmldx[ix]/2);
txxn1[ix] = txxn1x[ix];
}
} else {
for (ix=marg; ix<marg+pmlout; ix++) {
txxn1x[ix]=((1-dt*pmldx[ix]/2)*txxn0x[ix]+dt*0.0*fdx(vxn1,ix,dx,oo))/(1+dt*pmldx[ix]/2);
txxn1[ix]= txxn1x[ix];
}
}
/*Stress PML -- bottom*/
for (ix=nx+pmlout+marg; ix<nx+2*pmlout+marg; ix++) {
txxn1x[ix]=((1-dt*pmldx[ix]/2)*txxn0x[ix]+dt*c11[ix]*fdx(vxn1,ix,dx,oo))/(1+dt*pmldx[ix]/2);
txxn1[ix] = txxn1x[ix];
}
}
static void test_hypot() {
for (unsigned i = 0; i < ARRAY_SIZE(Hypot_test_values); i++) {
double dx = Hypot_test_values[i][0];
double dy = Hypot_test_values[i][1];
double d = hypot(dx, dy);
fixed fdx(dx);
fixed fdy(dy);
fixed fd(MediumHypot(fdx, fdy));
ok(fabs(fd - fixed(d)) < fixed(1.0e-3), "hypot(dx, dy)", 0);
}
}
void fdpml1_vxz(float *vxn1, float *vxn0,
float *txxn0, float *denx,
float dx, int oo,
float (*fdx)(float *, int, float, int),
bool freesurface)
/*<velocity vx,vz decay in pml --FD method>*/
{
int ix;
/*Velocity PML --top*/
if (freesurface == false) {
for (ix=marg; ix<marg+pmlout; ix++) {
vxn1[ix] = ((1-dt*pmldx[ix]/2)*vxn0[ix] + dt/denx[ix]*fdx(txxn0, ix-1, dx, oo))/(1+dt*pmldx[ix]/2);
}
}
/*Velocity PML --bottom*/
for (ix=nx+pmlout+marg; ix<nx+2*pmlout+marg; ix++) {
vxn1[ix] = ((1-dt*pmldx[ix]/2)*vxn0[ix] + dt/denx[ix]*fdx(txxn0, ix-1, dx, oo))/(1+dt*pmldx[ix]/2);
}
}
//training step
//the raw data has the form {x1, x2, t}
//convert to form x={x0, x1, x2} and t=t
double updateWeights(Neuron* neuron, const double* rawData) {
int t = rawData[N]; //desired class (-1, +1)
double x[DIM]; //actual input vector
x[0] = 1; //dummy input for w0
for (int i = 1; i <= N; i++) {
x[i] = rawData[i - 1]; //copy feature vector from from rawData
}
//perceptron update step: w(k+1) = w(k) + eta*x*t
//memcpy(neuron->w, sumVec(neuron->w, multiplyVec(multiplyVec(x, t), neuron->eta)), DIM*sizeof(double));
//neuron update step: delta rule (w(k+1) = w(k) + (error*w(k) * (fdx(w(k)*in) * in)
double out = f(neuron, x);
double e = error(out, t);
double f_dx = fdx(neuron, &x);
double* a = vectorProd(multiplyVec(neuron->w, e, N), multiplyVec(neuron->w, f_dx, N), N);
memcpy(neuron->w, sumVec(neuron->w, (a), N) , DIM*sizeof(double));
return e;
}
int main(){
int iteracao = 0; //contador de iteracoes
double x_i, x_i1, tol;
//x_new = novo candidato a raiz, x_old = candidato testado que nao deu certo
tol = 1.0e-10; // para a precisao de 10 casas decimais
// valores iniciais escolhidos para xi e xi+1
x_i = 0.1;
x_i1 = 1;
//laco com criterio de parada de quando o erro for menor que 10^(-10) para garantir a precisao de 10 casa decimais
while(fabs(x_i - x_i1)/fabs(x_i1) > tol){
x_i = x_i1; // atualizacao de valores para a possivel proxima etapa
x_i1 = x_i - f(x_i)/fdx(x_i); // metodo de newton rhapson
iteracao++;//contador de iteracoes
printf("Interacao %d: x = %.10lf\n",iteracao,x_i1);
}
printf("x = %.10lf\n",x_i1);// resultado da raiz aproximada
return 0;
}
int main(int argc, char* argv[])
{
clock_t tstart,tend;
double duration;
bool verb;
int nx, nz, nxz, nt, ix, iz, it;
float dt, dx, dz;
float **txxn1, **txxn0, **vxn1, **vzn1, **vxn0, **vzn0;
float **vel, **den, **c11, *source;
float **denx, **denz;
int spx, spz;
sf_file fvel, fden, fsource, fwf/*wave field*/;
sf_axis at, ax, az;
int oo;
spara sp= {0};
tstart = clock();
sf_init(argc, argv);
if (!sf_getbool("verb", &verb)) verb=false; /*verbosity*/
/*Set I/O file*/
fsource = sf_input("in"); /*source wavelet*/
fvel = sf_input("vel"); /*velocity*/
fden = sf_input("den"); /*density*/
fwf = sf_output("out");/*wavefield snap*/
/* Read/Write axes */
at = sf_iaxa(fsource, 1);
nt = sf_n(at);
dt = sf_d(at);
az = sf_iaxa(fvel, 1);
nz = sf_n(az);
dz = sf_d(az);
ax = sf_iaxa(fvel, 2);
nx = sf_n(ax);
dx = sf_d(ax);
sf_oaxa(fwf, az, 1);
sf_oaxa(fwf, ax, 2);
sf_oaxa(fwf, at, 3);
if (SF_FLOAT != sf_gettype(fsource)) sf_error("Need float input");
if (SF_FLOAT != sf_gettype(fvel)) sf_error("Need float input");
if (SF_FLOAT != sf_gettype(fden)) sf_error("Need float input");
if(!sf_getint("oo",&oo)) oo=4;
if (!sf_getint("spx", &spx)) sf_error("Need spx input");
/*source point in x */
if (!sf_getint("spz", &spz)) sf_error("Need spz input");
/* source point in z */
vel = sf_floatalloc2(nz, nx);
den = sf_floatalloc2(nz, nx);
c11 = sf_floatalloc2(nz, nx);
denx = sf_floatalloc2(nz, nx);
denz = sf_floatalloc2(nz, nx);
nxz = nx*nz;
sf_floatread(vel[0], nxz, fvel);
sf_floatread(den[0], nxz, fden);
for (ix = 0; ix < nx; ix++) {
for ( iz= 0; iz < nz; iz++) {
c11[ix][iz] = den[ix][iz]*vel[ix][iz]*vel[ix][iz];
denx[ix][iz] = den[ix][iz];
denz[ix][iz] = den[ix][iz];
if(c11[ix][iz] == 0.0) sf_warning("c11=0: ix=%d iz%d", ix, iz);
}
}
/*den[ix+1/2][iz]*/
for ( ix = 0; ix < nx-1; ix++) {
for (iz = 0; iz < nz; iz++) {
denx[ix][iz] = (den[ix+1][iz] + den[ix][iz])*0.5;
}
}
/*den[ix][iz+1/2]*/
for ( ix = 0; ix < nx; ix++) {
for (iz = 0; iz < nz-1; iz++) {
denz[ix][iz] = (den[ix][iz+1] + den[ix][iz])*0.5;
}
}
source = sf_floatalloc(nt);
sf_floatread(source, nt, fsource);
txxn1 = sf_floatalloc2(nz, nx);
txxn0 = sf_floatalloc2(nz, nx);
vxn1 = sf_floatalloc2(nz, nx);
vzn1 = sf_floatalloc2(nz, nx);
vxn0 = sf_floatalloc2(nz, nx);
vzn0 = sf_floatalloc2(nz, nx);
for (ix = 0; ix < nx; ix++) {
for (iz = 0; iz < nz; iz++) {
txxn1[ix][iz] = 0.0;
}
}
for (ix = 0; ix < nx; ix++) {
for (iz = 0; iz < nz; iz++) {
txxn0[ix][iz] = 0.0;
}
}
for (ix = 0; ix < nx; ix++) {
for (iz = 0; iz < nz; iz++) {
vxn1[ix][iz] = 0.0;
}
}
for (ix = 0; ix < nx; ix++) {
for (iz = 0; iz < nz; iz++) {
vxn0[ix][iz] = 0.0;
}
}
for (ix = 0; ix < nx; ix++) {
for (iz = 0; iz < nz; iz++) {
vzn1[ix][iz] = 0.0;
}
}
for (ix = 0; ix < nx; ix++) {
for (iz = 0; iz < nz; iz++) {
vzn0[ix][iz] = 0.0;
}
}
/* MAIN LOOP */
sp.trunc=0.2;
sp.srange=10;
sp.alpha=0.5;
sp.decay=1.0;
sf_warning("============================");
sf_warning("nx=%d nz=%d nt=%d", nx, nz, nt);
sf_warning("dx=%f dz=%f dt=%f", dx, dz, dt);
for (it = 0; it < nt; it++) {
sf_warning("it=%d;", it);
if (it<=sp.trunc) {
explsourcet(txxn0, source, it, dt, spx, spz, nx, nz, &sp);
}
/*velocity*/
for (ix = M; ix < nx-M; ix++ ) {
for (iz = M; iz < nz-M; iz++) {
vxn1[ix][iz] = vxn0[ix][iz] + dt/den[ix][iz]*fdx(txxn0, ix-1, iz, dx, oo);
vzn1[ix][iz] = vzn0[ix][iz] + dt/den[ix][iz]*fdz(txxn0, ix, iz, dz, oo);
}
}
/*Velocity PML*/
/*Stress*/
for (ix = M; ix < nx-M; ix++) {
for ( iz = M; iz < nz-M; iz++) {
txxn1[ix][iz] = txxn0[ix][iz] + dt*c11[ix][iz]*(fdx(vxn1, ix, iz, dx, oo) + fdz(vzn1, ix, iz-1, dz, oo));
}
}
for (ix = 0; ix<nx; ix++) {
for (iz = 0; iz < nz; iz++) {
txxn0[ix][iz] = txxn1[ix][iz];
vxn0[ix][iz] = vxn1[ix][iz];
vzn0[ix][iz] = vzn1[ix][iz];
}
}
for ( ix = 0; ix < nx; ix++) {
sf_floatwrite(txxn0[ix], nz, fwf);
}
}/*End of LOOP TIME*/
sf_warning(".");
tend = clock();
duration = (double)(tend-tstart)/CLOCKS_PER_SEC;
sf_warning(">> The CPU time of sfsgfd2 is: %f seconds << ", duration);
exit(0);
}
