File:Julia set for z^2+0.7i*z.png
Материал из Викисклада, хранилища свободных медиафайлов
Перейти к навигации
Перейти к поиску
Размер этого предпросмотра: 600 × 600 пкс. Другие разрешения: 240 × 240 пкс | 480 × 480 пкс | 768 × 768 пкс | 1024 × 1024 пкс | 2000 × 2000 пкс.
Исходный файл (2000 × 2000 пкс, размер файла: 610 КБ, MIME-тип: image/png)
Сведения о файле
Структурированные данные
Краткие подписи
Это изображение желательно воссоздать или аккуратно преобразовать в векторный формат SVG. Это даёт несколько преимуществ, прочитать о которых подробнее вы можете на странице Commons:Media for cleanup. Если вам уже сейчас доступна векторная версия данного изображения, загрузите её, пожалуйста, а затем замените этот шаблон на следующий: {{Vector version available|Имя загруженного файла.svg}}.
|
Содержание
Краткое описание
[править]ОписаниеJulia set for z^2+0.7i*z.png |
English: Dynamic plane with Julia set for . Made with LCM = Level Curves Method. Level curves are boundaries of level sets ( escape and attraction time). Point escapes to infinityu or is attracted to the finite attractor ( here fixed point). The Julia set (boundary of filled-in Julia set) itself is not drawn: we see it as the locus of points where the level curves are especially close to each other = a place with high density of level curves. Points of critical orbit ( including crirital point and fixed point = finite attractor) are on the level curves like notes on the musical staff. Level curves cross at critical point and its preimages = saddle points. Compare it with fig 11 in 3-rd edition from 2006 of Dynamics in one complex variable: introductory lectures by John W. Milnor. ( or fig 5 from the preprint on Arxiv[1]. Critical point z= -0.35*i is the center of symmetry and lemniscate ( point in which level curves cross). Attracting fixed point z= 0 is the center of nested circles above the critical point. Preimage of fixed point z= -0.7*i is a the center of nested circles below the critical point.) |
Дата | |
Источник | Собственная работа |
Автор | Adam majewski |
Лицензирование
[править]Я, владелец авторских прав на это произведение, добровольно публикую его на условиях следующей лицензии:
Этот файл доступен по лицензии Creative Commons Attribution-Share Alike 4.0 International
- Вы можете свободно:
- делиться произведением – копировать, распространять и передавать данное произведение
- создавать производные – переделывать данное произведение
- При соблюдении следующих условий:
- атрибуция – Вы должны указать авторство, предоставить ссылку на лицензию и указать, внёс ли автор какие-либо изменения. Это можно сделать любым разумным способом, но не создавая впечатление, что лицензиат поддерживает вас или использование вами данного произведения.
- распространение на тех же условиях – Если вы изменяете, преобразуете или создаёте иное произведение на основе данного, то обязаны использовать лицензию исходного произведения или лицензию, совместимую с исходной.
c source code
[править]/*
https://arxiv.org/abs/math/9201272
Dynamics in one complex variable: introductory lectures
John W. Milnor
Figure 5. Julia set for z 7→ z^2 + .7z , with curves |φ| = constant .
or fig 11 in 3-rd edition from 2006
Adam Majewski
adammaj1 aaattt o2 dot pl // o like oxygen not 0 like zero
Structure of a program or how to analyze the program
============== Image X ========================
DrawImageOf -> DrawPointOf -> ComputeColorOf ( FunctionTypeT FunctionType , complex double z) -> ComputeColor
check only last function which computes color of one pixel for given Function Type
==========================================
---------------------------------
indent d.c
default is gnu style
-------------------
c console progam
export OMP_DISPLAY_ENV="TRUE"
gcc d.c -lm -Wall -march=native -fopenmp
time ./a.out > b.txt
gcc d.c -lm -Wall -march=native -fopenmp
time ./a.out
time ./a.out >i.txt
time ./a.out >e.txt
convert -limit memory 1000mb -limit disk 1gb dd30010000_20_3_0.90.pgm -resize 2000x2000 10.png
*/
#include <stdio.h>
#include <stdlib.h> // malloc
#include <string.h> // strcat
#include <math.h> // M_PI; needs -lm also
#include <complex.h>
#include <omp.h> // OpenMP
#include <limits.h> // Maximum value for an unsigned long long int
// https://sourceforge.net/p/predef/wiki/Standards/
#if defined(__STDC__)
#define PREDEF_STANDARD_C_1989
#if defined(__STDC_VERSION__)
#if (__STDC_VERSION__ >= 199409L)
#define PREDEF_STANDARD_C_1994
#endif
#if (__STDC_VERSION__ >= 199901L)
#define PREDEF_STANDARD_C_1999
#endif
#endif
#endif
/* --------------------------------- global variables and consts ------------------------------------------------------------ */
//FunctionType
typedef enum {Fatou = 0, IntLSM =1 , ExtLSM = 2, LSM = 3, DEM = 4, Unknown = 5 , BD = 6, MBD = 7 , SAC = 8, DLD = 9, ND = 10 , NP= 11, POT = 12 , Blend = 13
} FunctionTypeT;
// FunctionTypeT FunctionType;
// virtual 2D array and integer ( screen) coordinate
// Indexes of array starts from 0 not 1
//unsigned int ix, iy; // var
static unsigned int ixMin = 0; // Indexes of array starts from 0 not 1
static unsigned int ixMax; //
static unsigned int iWidth; // horizontal dimension of array
static unsigned int iyMin = 0; // Indexes of array starts from 0 not 1
static unsigned int iyMax; //
static unsigned int iHeight = 20000; //
// The size of array has to be a positive constant integer
static unsigned long long int iSize; // = iWidth*iHeight;
// memmory 1D array
unsigned char *data;
unsigned char *edge;
//unsigned char *edge2;
// unsigned int i; // var = index of 1D array
//static unsigned int iMin = 0; // Indexes of array starts from 0 not 1
static unsigned int iMax; // = i2Dsize-1 =
// The size of array has to be a positive constant integer
// unsigned int i1Dsize ; // = i2Dsize = (iMax -iMin + 1) = ; 1D array with the same size as 2D array
// see SetPlane
double radius = 1.3;
complex double center ;
double DisplayAspectRatio = 1.0; // https://en.wikipedia.org/wiki/Aspect_ratio_(image)
// dx = dy compare setup : iWidth = iHeight;
double ZxMin; //= -1.3; //-0.05;
double ZxMax;// = 1.3; //0.75;
double ZyMin;// = -1.3; //-0.1;
double ZyMax;// = 1.3; //0.7;
double PixelWidth; // =(ZxMax-ZxMin)/ixMax;
double PixelHeight; // =(ZyMax-ZyMin)/iyMax;
double ratio;
/*
ER = pow(10,ERe);
AR = pow(10,-ARe);
*/
//int ARe ; // increase ARe until black ( unknown) points disapear
//int ERe ;
double ER;
double ER2; //= 1e60;
double AR; // bigger values do not works
double AR2;
double AR_max;
//double AR12;
int IterMax = 100000;
int IterMax_LSM = 1000;
/* colors = shades of gray from 0 to 255
unsigned char colorArray[2][2]={{255,231}, {123,99}};
color = 245; exterior
*/
unsigned char iColorOfExterior = 245;
unsigned char iColorOfInterior1 = 99;
unsigned char iColorOfInterior2 = 183;
unsigned char iColorOfBoundary = 0;
unsigned char iColorOfUnknown = 5;
// pixel counters
unsigned long long int uUnknown = 0;
unsigned long long int uInterior = 0;
unsigned long long int uExterior = 0;
// critical points
// critical points
complex double zcr = -0.35*I; // only one critical point
//complex double zc2 = -2.2351741790771484375e-08+9.4296410679817199707e-09*I;
/*
*/
/*
coefficients read from input file milnor_fig11.txt
degree 2 coefficient = ( +1.0000000000000000 +0.0000000000000000*i)
degree 1 coefficient = ( +0.0000000000000000 +0.7000000000000000*i)
Input polynomial p(z)=(1+0i)*z^2+(0+0.69999999999999995559i)*z^1
derivative dp/dz = (2+0i)*z^1+(0+0.69999999999999995559i)
1 critical points found
cp#0: 0,-0.3499999999999999778 . It's critical orbit is bounded and enters cycle #0 length=1 and it's stability = |multiplier|=0.7 =attractive
internal angle = 0.25
cycle = {
-4.9406564584124654418e-324,4.9406564584124654418e-324 ; }
*/
const complex double C =0.7*I;
const int period = 1;
// periodic points = attractors
complex double z1 = 0.0 ; //fixed point (period 1) = attracting cycle
/* ------------------------------------------ functions -------------------------------------------------------------*/
// complex function
complex double fc(const complex double z0, const complex double c) {
double complex z = z0;
z = z*z + z*c;
return z;
}
// iterated function
complex double Fpc(const complex double z0, const complex double c, const int period) {
int p;
int pMax = period;
double complex z = z0;
for (p=0; p< pMax; ++p ){
z = fc(z,c);}
return z;
}
//------------------complex numbers -----------------------------------------------------
// from screen to world coordinate ; linear mapping
// uses global cons
double
GiveZx (int ix)
{
return (ZxMin + ix * PixelWidth);
}
// uses globaal cons
double
GiveZy (int iy)
{
return (ZyMax - iy * PixelHeight);
} // reverse y axis
complex double
GiveZ (int ix, int iy)
{
double Zx = GiveZx (ix);
double Zy = GiveZy (iy);
return Zx + Zy * I;
}
double cabs2(complex double z){
return creal(z)*creal(z)+cimag(z)*cimag(z);
}
/* find such AR for internal LCM/J and LSM that level curves croses critical point and it's preimages
for attracting ( also weakly attracting = parabolic) dynamics
it may fail if one iteration is bigger then smallest distance between periodic point and Julia set
*/
double GiveTunedAR(const int iter_Max, const double complex c , const double AR_max){
fprintf(stdout, " GiveTunedAR\n");
complex double z = zcr; // initial point z0 = criical point
int iter;
double r;
//int i_Max = 1000;
for (iter=0; iter< iter_Max; ++iter ){
// period !!!
r = cabs(z-z1);
//fprintf(stdout, " i = %d z = %f %+f \t r = %f = %d * pixeWidth \n",iter , creal(z), cimag(z), r, (int) (r/PixelWidth));
z = fc(z,c); // forward iteration
}
r = cabs(z-z1);
fprintf(stdout, " r = %f = %d * pixeWidth \n", r, (int) (r/PixelWidth));
if ( r> cabs(z-z1))
{ //fprintf(stdout, "one more forward iteration \n");
z = fc(z,c);
r = cabs(z-z1);
}
if ( r > AR_max )
{
//fprintf(stdout, " AR_max < r = %f = %d * pixeWidth \n", r, (int) (r/PixelWidth));
//fprintf(stdout, " increase i_max\n" );
r = AR_max;} // manual check
return r;
}
// =====================
int IsPointInsideTrap(complex double z){
if ( cabs2(z - z1) < AR2 ) {return 1;} // circle around z2a
return 0; // outside
}
int IsPointInsideTraps(complex double z){
if ( IsPointInsideTrap(z) ) {return 1;} //
return 0; // outside
}
// =====================
int IsPixelInsideTraps(unsigned int ix, unsigned int iy){
complex double z = GiveZ (ix, iy);
if ( IsPointInsideTraps(z) ) {return 1;} //
return 0; // outside
}
// ****************** DYNAMICS = trap tests ( target sets) ****************************
/* ----------- array functions = drawing -------------- */
/* gives position of 2D point (ix,iy) in 1D array ; uses also global variable iWidth */
unsigned int Give_i (unsigned int ix, unsigned int iy)
{
return ix + iy * iWidth;
}
//
unsigned char ComputeColorOfFatou (complex double z)
{
double r2;
int i; // number of iteration
for (i = 0; i < IterMax; ++i)
{
r2 =cabs2(z);
if (r2 > ER2) // esaping = exterior
{
uExterior += 1;
return iColorOfExterior;
}
// solid color for each Fatou components
if ( IsPointInsideTrap(z)) {
uInterior +=1;
if ( i % period )
{return iColorOfInterior1;}
else {return iColorOfInterior2;}
} // 50 + (i % 114); }
z = fc(z,C); // complex iteration f(z)=z^3 + c
}
uUnknown += 1;
return iColorOfUnknown;
}
// f(z)=1+z−3z2−3.75z3+1.5z4+2.25z5
unsigned char ComputeColorOfLSM (complex double z)
{
double r2;
int i; // number of iteration
for (i = 0; i < IterMax_LSM; ++i)
{
// complex iteration f(z)=z^3 + c
r2 =cabs2(z);
if (r2 > ER2) // esaping = exterior
{
uExterior += 1;
return 255- ((i*15) % 255);
}
// solid color for each Fatou components
if ( IsPointInsideTrap(z)) {
uInterior +=1;
if ( i % 2 )
{return (i*9) % 255 ;}
else {return (i*10) % 255;}
} // 50 + (i % 114); }
z = fc(z,C);
}
uUnknown += 1;
return iColorOfUnknown;
}
/* ==================================================================================================
============================= Draw functions ===============================================================
=====================================================================================================
*/
unsigned char ComputeColor(FunctionTypeT FunctionType, complex double z){
unsigned char iColor;
switch(FunctionType){
case Fatou :{iColor = ComputeColorOfFatou(z); break;}
// case IntLSM :{iColor = ComputeColorOfIntLSM(z); break;}
// case ExtLSM :{iColor = ComputeColorOfExtLSM(z); break;}
case LSM :{iColor = ComputeColorOfLSM(z); break;}
/*
case DEM : {iColor = ComputeColorOfDEM(z); break;}
case Unknown : {iColor = ComputeColorOfUnknown(z); break;}
case BD : {iColor = ComputeColorOfBD(z); break;}
case MBD : {iColor = ComputeColorOfMBD(z); break;}
case SAC : {iColor = ComputeColorOfSAC(z); break;}
case DLD : {iColor = ComputeColorOfDLD(z); break;}
case ND : {iColor = ComputeColorOfND(z); break;}
case NP : {iColor = ComputeColorOfNP(z); break;}
case POT : {iColor = ComputeColorOfPOT(z); break;}
case Blend : {iColor = ComputeColorOfBlend(z); break;}
*/
default: {}
}
return iColor;
}
// plots raster point (ix,iy)
int DrawPoint ( unsigned char A[], FunctionTypeT FunctionType, int ix, int iy)
{
int i; /* index of 1D array */
unsigned char iColor;
complex double z;
i = Give_i (ix, iy); /* compute index of 1D array from indices of 2D array */
z = GiveZ(ix,iy);
iColor = ComputeColor(FunctionType, z);
A[i] = iColor ; //
return 0;
}
int DrawImage ( unsigned char A[], FunctionTypeT FunctionType)
{
unsigned int ix, iy; // pixel coordinate
fprintf (stdout, "compute Fatou image LSM\n");
// for all pixels of image
#pragma omp parallel for schedule(dynamic) private(ix,iy) shared(A, ixMax , iyMax, uUnknown, uInterior, uExterior)
for (iy = iyMin; iy <= iyMax; ++iy)
{
fprintf (stderr, " %d from %d \r", iy, iyMax); //info
for (ix = ixMin; ix <= ixMax; ++ix)
DrawPoint(A, FunctionType, ix, iy); //
}
return 0;
}
int IsInside (int x, int y, int xcenter, int ycenter, int r){
double dx = x- xcenter;
double dy = y - ycenter;
double d = sqrt(dx*dx+dy*dy);
if (d<r)
return 1;
return 0;
}
int PlotBigPoint(complex double z, unsigned char A[]){
unsigned int ix_seed = (creal(z)-ZxMin)/PixelWidth;
unsigned int iy_seed = (ZyMax - cimag(z))/PixelHeight;
unsigned int i;
/* mark seed point by big pixel */
int iSide =4.0*iWidth/2000.0 ; /* half of width or height of big pixel */
int iY;
int iX;
for(iY=iy_seed-iSide;iY<=iy_seed+iSide;++iY){
for(iX=ix_seed-iSide;iX<=ix_seed+iSide;++iX){
if (IsInside(iX, iY, ix_seed, iy_seed, iSide)) {
i= Give_i(iX,iY); /* index of _data array */
A[i]= 0; //255-A[i];
}}}
return 0;
}
// fill array
// uses global var : ...
// scanning complex plane
int MarkAttractors (unsigned char A[])
{
fprintf (stdout, "mark attractors \n");
PlotBigPoint(z1, A); // period 1 cycle
//PlotBigPoint(z2b, A); //
return 0;
}
int MarkTraps(unsigned char A[]){
unsigned int ix, iy; // pixel coordinate
unsigned int i;
fprintf (stdout ,"Mark traps \n");
// for all pixels of image
#pragma omp parallel for schedule(dynamic) private(ix,iy) shared(A, ixMax , iyMax, uUnknown, uInterior, uExterior)
for (iy = iyMin; iy <= iyMax; ++iy)
{
fprintf (stdout, " %d from %d \r", iy, iyMax); //info
for (ix = ixMin; ix <= ixMax; ++ix){
if (IsPixelInsideTraps(ix, iy)) {
i= Give_i(ix,iy); /* index of _data array */
A[i]= 255-A[i]; // inverse color
}}}
return 0;
}
int PlotPoint(complex double z, unsigned char A[]){
unsigned int ix = (creal(z)-ZxMin)/PixelWidth;
unsigned int iy = (ZyMax - cimag(z))/PixelHeight;
unsigned int i = Give_i(ix,iy); /* index of _data array */
A[i]= 0; //255-A[i]; // Mark point with inveres color
return 0;
}
int DrawForwardOrbit(complex double z, unsigned long long int iMax, unsigned char A[] )
{
unsigned long long int i; /* nr of point of critical orbit */
printf("draw forward orbit \n");
PlotBigPoint(z, A);
/* forward orbit of critical point */
for (i=1;i<iMax ; ++i)
{
z = fc(z,C);
//if (cabs2(z - z2a) > 2.0) {return 1;} // escaping
PlotBigPoint(z, A);
}
return 0;
}
int Test(){
complex double z = zcr;
int i;
int iMax = 100;
printf(" |z-z1| = %f \n", cabs(z-z1));
/* forward orbit of critical point */
for (i=1;i<iMax ; ++i)
{
z = fc(z,C);
printf("z = %f%+f \t |z-z1| = %f \n", creal(z), cimag(z), cabs(z-z1));
//if (cabs2(z - z2a) > 2.0) {return 1;} // escaping
}
return 0;
}
// ***********************************************************************************************
// ********************** edge detection usung Sobel filter ***************************************
// ***************************************************************************************************
// from Source to Destination
int ComputeBoundaries(unsigned char S[], unsigned char D[])
{
unsigned int iX,iY; /* indices of 2D virtual array (image) = integer coordinate */
unsigned int i; /* index of 1D array */
/* sobel filter */
unsigned char G, Gh, Gv;
// boundaries are in D array ( global var )
// clear D array
memset(D, iColorOfExterior, iSize*sizeof(*D)); // for heap-allocated arrays, where N is the number of elements = FillArrayWithColor(D , iColorOfExterior);
// printf(" find boundaries in S array using Sobel filter\n");
#pragma omp parallel for schedule(dynamic) private(i,iY,iX,Gv,Gh,G) shared(iyMax,ixMax)
for(iY=1;iY<iyMax-1;++iY){
for(iX=1;iX<ixMax-1;++iX){
Gv= S[Give_i(iX-1,iY+1)] + 2*S[Give_i(iX,iY+1)] + S[Give_i(iX-1,iY+1)] - S[Give_i(iX-1,iY-1)] - 2*S[Give_i(iX-1,iY)] - S[Give_i(iX+1,iY-1)];
Gh= S[Give_i(iX+1,iY+1)] + 2*S[Give_i(iX+1,iY)] + S[Give_i(iX-1,iY-1)] - S[Give_i(iX+1,iY-1)] - 2*S[Give_i(iX-1,iY)] - S[Give_i(iX-1,iY-1)];
G = sqrt(Gh*Gh + Gv*Gv);
i= Give_i(iX,iY); /* compute index of 1D array from indices of 2D array */
if (G==0) {D[i]=255;} /* background */
else {D[i]=0;} /* boundary */
}
}
return 0;
}
// copy from Source to Destination
int CopyBoundaries(unsigned char S[], unsigned char D[])
{
unsigned int iX,iY; /* indices of 2D virtual array (image) = integer coordinate */
unsigned int i; /* index of 1D array */
//printf("copy boundaries from S array to D array \n");
for(iY=1;iY<iyMax-1;++iY)
for(iX=1;iX<ixMax-1;++iX)
{i= Give_i(iX,iY); if (S[i]==0) D[i]=0;}
return 0;
}
// *******************************************************************************************
// ********************************** save A array to pgm file ****************************
// *********************************************************************************************
int SaveArray2PGMFile (unsigned char A[], char * n, char *comment)
{
FILE *fp;
const unsigned int MaxColorComponentValue = 255; /* color component is coded from 0 to 255 ; it is 8 bit color file */
char name[100]; /* name of file */
snprintf (name, sizeof name, "%s", n ); /* */
char *filename = strcat (name, ".pgm");
char long_comment[200];
sprintf (long_comment, "fc(z)=z^2+z*c %s", comment);
// save image array to the pgm file
fp = fopen (filename, "wb"); // create new file,give it a name and open it in binary mode
fprintf (fp, "P5\n # %s\n %u %u\n %u\n", long_comment, iWidth, iHeight, MaxColorComponentValue); // write header to the file
size_t rSize = fwrite (A, sizeof(A[0]), iSize, fp); // write whole array with image data bytes to the file in one step
fclose (fp);
// info
if ( rSize == iSize)
{
printf ("File %s saved ", filename);
if (long_comment == NULL || strlen (long_comment) == 0)
printf ("\n");
else { printf (". Comment = %s \n", long_comment); }
}
else {printf("wrote %zu elements out of %llu requested\n", rSize, iSize);}
return 0;
}
int PrintCInfo ()
{
printf ("gcc version: %d.%d.%d\n", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__); // https://stackoverflow.com/questions/20389193/how-do-i-check-my-gcc-c-compiler-version-for-my-eclipse
// OpenMP version is displayed in the console : export OMP_DISPLAY_ENV="TRUE"
printf ("__STDC__ = %d\n", __STDC__);
printf ("__STDC_VERSION__ = %ld\n", __STDC_VERSION__);
printf ("c dialect = ");
switch (__STDC_VERSION__)
{ // the format YYYYMM
case 199409L:
printf ("C94\n");
break;
case 199901L:
printf ("C99\n");
break;
case 201112L:
printf ("C11\n");
break;
case 201710L:
printf ("C18\n");
break;
//default : /* Optional */
}
return 0;
}
int
PrintProgramInfo ()
{
// display info messages
printf ("Numerical approximation of Julia set for F(z,C) = z^2 + z*c) \n");
printf ("parameter C = ( %.16f ; %.16f ) \n", creal (C), cimag (C));
printf ("Period = %d orbit : \n", period);
printf ("\tfixed point z1 = ( %.16f ; %.16f ) \n", creal (z1), cimag (z1));
//printf ("\tparameter z2b = ( %.16f ; %.16f ) \n", creal (z2b), cimag (z2b));
printf ("Image Width = %f in world coordinate\n", ZxMax - ZxMin);
printf ("PixelWidth = %.16f \n", PixelWidth);
printf ("AR = %.16f = %f *PixelWidth = %f %% of ImageWidth \n", AR, AR / PixelWidth, AR / ZxMax - ZxMin);
printf("pixel counters\n");
printf ("\tuUnknown = %llu\n", uUnknown);
printf ("\tuExterior = %llu\n", uExterior);
printf ("\tuInterior = %llu\n", uInterior);
printf ("Sum of pixels = %llu\n", uInterior+uExterior + uUnknown);
printf ("all pixels of the array = iSize = %llu\n", iSize);
// image corners in world coordinate
// center and radius
// center and zoom
// GradientRepetition
printf ("Maximal number of iterations = iterMax = %d \n", IterMax);
printf ("ratio of image = %f ; it should be 1.000 ...\n", ratio);
//
return 0;
}
int SetPlane(complex double center, double radius, double a_ratio){
ZxMin = creal(center) - radius*a_ratio;
ZxMax = creal(center) + radius*a_ratio; //0.75;
ZyMin = cimag(center) - radius; // inv
ZyMax = cimag(center) + radius; //0.7;
return 0;
}
// Check Orientation of z-plane image : mark first quadrant of complex plane
// it should be in the upper right position
// uses global var : ...
int CheckZPlaneOrientation(unsigned char A[] )
{
double Zx, Zy; // Z= Zx+ZY*i;
unsigned i; /* index of 1D array */
unsigned int ix, iy; // pixel coordinate
fprintf(stderr, "compute image CheckOrientation\n");
// for all pixels of image
#pragma omp parallel for schedule(dynamic) private(ix,iy, i, Zx, Zy) shared(A, ixMax , iyMax)
for (iy = iyMin; iy <= iyMax; ++iy){
//fprintf (stderr, " %d from %d \r", iy, iyMax); //info
for (ix = ixMin; ix <= ixMax; ++ix){
// from screen to world coordinate
Zy = GiveZy(iy);
Zx = GiveZx(ix);
i = Give_i(ix, iy); /* compute index of 1D array from indices of 2D array */
if (Zx>0 && Zy>0) A[i]=255-A[i]; // check the orientation of Z-plane by marking first quadrant */
}
}
return 0;
}
// *****************************************************************************
//;;;;;;;;;;;;;;;;;;;;;; setup ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
// **************************************************************************************
int setup ()
{
fprintf (stderr, "setup start\n");
/* 2D array ranges */
iWidth = iHeight* DisplayAspectRatio ;
iSize = iWidth * iHeight; // size = number of points in array
// iy
iyMax = iHeight - 1; // Indexes of array starts from 0 not 1 so the highest elements of an array is = array_name[size-1].
//ix
ixMax = iWidth - 1;
/* 1D array ranges */
// i1Dsize = i2Dsize; // 1D array with the same size as 2D array
iMax = iSize - 1; // Indexes of array starts from 0 not 1 so the highest elements of an array is = array_name[size-1].
center = zcr;
SetPlane( center, radius, DisplayAspectRatio );
/* Pixel sizes */
PixelWidth = (ZxMax - ZxMin) / ixMax; // ixMax = (iWidth-1) step between pixels in world coordinate
PixelHeight = (ZyMax - ZyMin) / iyMax;
ratio = ((ZxMax - ZxMin) / (ZyMax - ZyMin)) / ((double) iWidth / (double) iHeight); // it should be 1.000 ...
ER = 200.0; //
ER2 = ER*ER;
AR_max = 5*PixelWidth*iWidth/2000.0 ; // adjust first number
// GiveTunedAR(const int i_Max, const complex double zcr, const double c, const double zp){
AR = GiveTunedAR(200, C, AR_max);
AR2 = AR * AR;
//AR12 = AR/2.0;
/* create dynamic 1D arrays for colors ( shades of gray ) */
data = malloc (iSize * sizeof (unsigned char));
edge = malloc (iSize * sizeof (unsigned char));
if (data == NULL || edge == NULL)
{
fprintf (stderr, " Could not allocate memory");
return 1;
}
fprintf (stderr, " end of setup \n");
return 0;
} // ;;;;;;;;;;;;;;;;;;;;;;;;; end of the setup ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
int end ()
{
fprintf (stderr, " allways free memory (deallocate ) to avoid memory leaks \n"); // https://en.wikipedia.org/wiki/C_dynamic_memory_allocation
free (data);
free(edge);
PrintProgramInfo ();
PrintCInfo ();
return 0;
}
// ********************************************************************************************************************
/* ----------------------------------------- main -------------------------------------------------------------*/
// ********************************************************************************************************************
int main ()
{
setup ();
//Test();
DrawImage (data, Fatou); // first find Fatou
SaveArray2PGMFile (data, "Fatou" , "Fatou ");
ComputeBoundaries(data,edge);
SaveArray2PGMFile (edge, "Fatou_b", "Boundaries of Fatou");
CopyBoundaries(edge,data);
SaveArray2PGMFile (data, "Fatou_B", "Fatou with boundaries");
DrawImage (data, LSM); // first find Fatou
SaveArray2PGMFile (data, "LSM", "LSM");
ComputeBoundaries(data,edge);
SaveArray2PGMFile (edge, "LCM", "Level Curves Method = Boundaries of Level Sets");
DrawForwardOrbit(zcr, 10, edge);
SaveArray2PGMFile (edge, "LCM_cr", "LCM and critical orbit");
MarkTraps(data);
MarkAttractors(data);
SaveArray2PGMFile (data, "LSM_bt", "Fatou with boundaries and traps; ");
CheckZPlaneOrientation(data);
SaveArray2PGMFile (data, "LSM_btm", "Fatou with boundaries and traps. First quadrant is marked");
/*
ComputeBoundaries(data,edge);
SaveArray2PGMFile (edge, 1, "Boundaries of Fatou; name = iWidth_IterMax_n");
CopyBoundaries(edge,data);
SaveArray2PGMFile (data, 2, "Fatou with boundaries; name = iWidth_IterMax_n");
DrawFatouImageLSM (data, IterMax); // first find Fatou
SaveArray2PGMFile (data, 6, "Fatou LSM, name = iWidth_IterMax_n");
CopyBoundaries(edge,data);
SaveArray2PGMFile (data, 8, "LSM with boundaries; name = iWidth_IterMax_n");
*/
end ();
return 0;
}
bash source code
[править]#!/bin/bash
# script file for BASH
# which bash
# save this file as d.sh
# chmod +x d.sh
# ./d.sh
# checked in https://www.shellcheck.net/
printf "make pgm files \n"
gcc d.c -lm -Wall -march=native -fopenmp
if [ $? -ne 0 ]
then
echo ERROR: compilation failed !!!!!!
exit 1
fi
export OMP_DISPLAY_ENV="TRUE"
printf "display OMP info \n"
time ./a.out > a.txt
export OMP_DISPLAY_ENV="FALSE"
printf "convert all pgm files to png using Image Magic convert \n"
# for all pgm files in this directory
for file in *.pgm ; do
# b is name of file without extension
b=$(basename "$file" .pgm)
# convert using ImageMagic
convert "${b}".pgm -resize 2000x2000 "${b}".png
echo "$file"
done
printf "delete all pgm files \n"
rm ./*.pgm
echo OK
# end
Make
[править]all:
chmod +x d.sh
./d.sh
Text output
[править]make chmod +x d.sh ./d.sh make pgm files display OMP info OPENMP DISPLAY ENVIRONMENT BEGIN _OPENMP = '201511' OMP_DYNAMIC = 'FALSE' OMP_NESTED = 'FALSE' OMP_NUM_THREADS = '8' OMP_SCHEDULE = 'DYNAMIC' OMP_PROC_BIND = 'FALSE' OMP_PLACES = '' OMP_STACKSIZE = '0' OMP_WAIT_POLICY = 'PASSIVE' OMP_THREAD_LIMIT = '4294967295' OMP_MAX_ACTIVE_LEVELS = '1' OMP_CANCELLATION = 'FALSE' OMP_DEFAULT_DEVICE = '0' OMP_MAX_TASK_PRIORITY = '0' OMP_DISPLAY_AFFINITY = 'FALSE' OMP_AFFINITY_FORMAT = 'level %L thread %i affinity %A' OMP_ALLOCATOR = 'omp_default_mem_alloc' OMP_TARGET_OFFLOAD = 'DEFAULT' OPENMP DISPLAY ENVIRONMENT END setup start end of setup compute image CheckOrientation allways free memory (deallocate ) to avoid memory leaks File LSM_a.pgm saved . Comment = fc(z)=z^3+c Fatou with boundaries and traps; name = iWidth_IterMax_n File LSM_am.pgm saved . Comment = fc(z)=z^3+c Fatou with boundaries and traps. First quadrant is marked Numerical approximation of Julia set for F(z,C) = z^2 + z*c) parameter C = ( 0.0000000000000000 ; 0.7000000000000000 ) Period = 1 orbit : fixed point z1 = ( 0.0000000000000000 ; 0.0000000000000000 ) Image Width = 2.600000 in world coordinate PixelWidth = 0.0001300065003250 AR = 0.0000000000000000 = 0.000000 *PixelWidth = 1.300000 % of ImageWidth pixel counters uUnknown = 0 uExterior = 418938082 uInterior = 327235851 Sum of pixels = 746173933 all pixels of the array = iSize = 400000000 Maximal number of iterations = iterMax = 100000 ratio of image = 1.000000 ; it should be 1.000 ... gcc version: 10.3.0 __STDC__ = 1 __STDC_VERSION__ = 201710 c dialect = C18 real 7m31,286s user 52m33,681s sys 0m6,141s convert all pgm files to png using Image Magic convert FatouAnd B.pgm Fatou_b.pgm Fatou.pgm LCM_9.pgm LCM_cr.pgm LSM_9.pgm LSM_am.pgm LSM_a.pgm delete all pgm files OK
References
[править]История файла
Нажмите на дату/время, чтобы увидеть версию файла от того времени.
Дата/время | Миниатюра | Размеры | Участник | Примечание | |
---|---|---|---|---|---|
текущий | 18:59, 9 июня 2021 | 2000 × 2000 (610 КБ) | Soul windsurfer (обсуждение | вклад) | file comment | |
18:27, 9 июня 2021 | 2000 × 2000 (610 КБ) | Soul windsurfer (обсуждение | вклад) | Uploaded own work with UploadWizard |
Вы не можете перезаписать этот файл.
Использование файла
Нет страниц, использующих этот файл.
Глобальное использование файла
Данный файл используется в следующих вики:
- Использование в el.wikipedia.org
- Использование в en.wikipedia.org
- Использование в en.wikibooks.org
- Использование в uk.wikipedia.org
Метаданные
Файл содержит дополнительные данные, обычно добавляемые цифровыми камерами или сканерами. Если файл после создания редактировался, то некоторые параметры могут не соответствовать текущему изображению.
Примечание к PNG-файлу |
|
---|---|
Дата и время изменения файла | 18:58, 9 июня 2021 |