hp
jblog
toc

Tau Day MMXVIII

2018-06-28, post № 199

C, programming,

                                     int
        O=19,I=19;typedef long double f 
    ;long fac(long n){return n?n--*fac( 
  n):1;}f pow(f x,int p){return p--?x   
 *pow(x,p):1;}f sin(f x){f v=0;for      
(int           k=~0;++k                 
<=             O;)k%2&&                 
              (v+=(~-k                  
             %4?-1:1)*                  
             pow(x,k)                   
            /fac(k));                   
            return v                    
           ;}main()                     
           {f a=6,b                     
          =7, tau;                      
          for (int                      
         j=~0;++j                       
         <I;)sin(           tau         
        =a+(b-a)           /2           
        )>0? (b=          tau           
        ):(a=tau        )  ;            
        printf (      "%ca"             
        "u ~ %.*Lf",116,                
           O,tau);}                     

Try it online!

Happy tau day.

Truth

2018-06-16, post № 198

mathematics, programming, Python, #logic, #proposition calculus

Proposition calculus deals with statements and the relation between statements, where each of them can only be in one of two states; \vdash p\lor\lnot p. Therefore, when working with finitely many connected propositions, one can algorithmically determine all possible truth values of all atomic and thus connected propositions.

Truth is command-line tool which was written to precisely perform those computations; computing a logical expression’s truth value. Download link: truth.py
A list of all supportet operators can be seen by invoking the tool with a --help flag.
This project was inspired by Albert Menne’s Einführung in die Logik [1]; the operator syntax used is similar to his, translated to be 7-bit-ASCII-compatible.

Truth can be used to either verify universally true statements, e. g. tertium non datur and a property of the replication, verum sequitur ex quodlibet.

-(p&-p) <-> 1  ,  1 <- p
1 0010   1  1     1 1  0
1 1001   1  1     1 1  1

Though not only absolute truth, but also complete relational equivalence between two expressions can be shown.

(p->q)|(r>-<s) <-> q|(r|s)&-(r&s)|-p
 01 0 1 0 0 0   1  00 000 01 000 110
 10 0 0 0 0 0   1  00 000 01 000 001
 01 1 1 0 0 0   1  11 000 01 000 110
 11 1 1 0 0 0   1  11 000 01 000 101
 01 0 1 1 1 0   1  01 110 11 100 110
 10 0 1 1 1 0   1  01 110 11 100 101
 01 1 1 1 1 0   1  11 110 11 100 110
 11 1 1 1 1 0   1  11 110 11 100 101
 01 0 1 0 1 1   1  01 011 11 001 110
 10 0 1 0 1 1   1  01 011 11 001 101
 01 1 1 0 1 1   1  11 011 11 001 110
 11 1 1 0 1 1   1  11 011 11 001 101
 01 0 1 1 0 1   1  00 111 00 111 110
 10 0 0 1 0 1   1  00 111 00 111 001
 01 1 1 1 0 1   1  11 111 00 111 110
 11 1 1 1 0 1   1  11 111 00 111 101

Complete contravalence can also be shown.

-(p/-p>-<0)|p->q<-r >-< p&-q&r
0 0110 1 0 101 01 0  1  001000
0 1101 1 0 110 01 0  1  111000
0 0110 1 0 101 11 0  1  000100
0 1101 1 0 111 11 0  1  100100
0 0110 1 0 101 01 1  1  001001
0 1101 1 0 010 00 1  1  111011
0 0110 1 0 101 11 1  1  000101
0 1101 1 0 111 11 1  1  100101

Worldwide Pinhole Day MMXVIII

2018-05-19, post № 197

art, #analogue, #photography, #pinhole photography, #WWPD

On the last sunday in April of 2018, the 29th, to commemorate Worldwide Pinhole Day, I ventured out in the wilderness to capture a few photons.

worldwide-pinhole-day-mmxviii-09.png
worldwide-pinhole-day-mmxviii-08.png
worldwide-pinhole-day-mmxviii-06.png

Snippet #0

2018-05-12, post № 196

JavaScript, programming, #lambda function

(_=>_<=_)([]>{})

Lichen, Extraterrestrials, Diodes #0

2018-04-21, post № 195

art, #LED, #photography

lichen-extraterrestrials-diodes-0.jpg

Third Anniversary

2018-03-28, post № 194

, #2017, #collage

Today marks this blog’s third anniversary. To celebrate and take a look back at the year, I have collected a few image highlights.

17500615947440398742637684298448259300459653195179624088723406481656498345927782897306957959023081425157582777952426879442535942327333206022815634243070984075006080698433225695442819778347008.0

BMP Implementation in C — Graphic Primitives

2018-03-24, post № 193

C, programming, #2017, #bitmap, #bmp, #drawing, #image library, #image manipulation, #library

Continuing development of my C bitmap library, I added basic graphic primitives to augment the library’s functionality beyond simply reading and writing bitmaps and manually manipulating individual pixels. Source code can be seen below and also downloaded — bmp.c.
The underlying implementation of the bitmap file format can be seen in my prior post BMP Implementation in C. Graphic primitives include drawing lines, rectangles, circles, ellipses; rotating, flipping, cropping, resizing and blitting images. A full list of defined graphic primitives can be seen below, together with a short functionality description.

bmp-implementation-in-c-graphic-primitives_drw.png
Test image regarding drawing primitives.
/* === DRAWING PRIMITIVES === */
void hline      (image *img, int x0, int x1, int y , int c               ); // draw horizontal line
void vline      (image *img, int x , int y0, int y1, int c               ); // draw vertical line
void line       (image *img, int x0, int y0, int x1, int y1, int c       ); // draw line
void fillrect   (image *img, int x0, int y0, int x1, int y1, int c       ); // draw filled rectangle
void rect       (image *img, int x0, int y0, int x1, int y1, int c       ); // draw rectangle
void fillcircle (image *img, int x , int y , int r , int c               ); // draw filled circle
void circle     (image *img, int x , int y , int r , int t , int c       ); // draw circle (with certain thickness)
void fillellipse(image *img, int x , int y , int rx, int ry, int c       ); // draw filled ellipse
void ellipse    (image *img, int x , int y , int rx, int ry, int t, int c); // draw ellipse (with certain thickness)

/* === TRANSFORMATION PRIMITIVES === */
image *resize   (image *img, int w , int h                                ); // resize an image
image *hflip    (image *img                                               ); // flip horizontally
image *vflip    (image *img                                               ); // flip vertically
image *rrotate  (image *img                                               ); // rotate clockwise
image *lrotate  (image *img                                               ); // rotate counter-clockwise
image *hrotate  (image *img                                               ); // rotate half a revolution
image *crop     (image *img, int x0, int y0, int x1, int y1               ); // crop an image
void   blit     (image *img, image*, int x , int y                        ); // blit an image onto another one
bmp-implementation-in-c-graphic-primitives_flp.png
Test image regarding transformation primitives.

Future plans for this library include performance optimizations regarding the ellipse drawing primitives; circle drawing is already optimized as it uses the shape’s symmetry to save computational cost.Further primitives that may be added include a flood filling functionality as well as the ability to draw irregular polygons.

Source code: bmp.c

Pi Day MMXVII

2018-03-14, post № 192

C, mathematics, programming, #improper integral, #power series, #source layout, #Taylor series

Today it is the fourteenth of March 2018. Today’s date — when written in the M/D/Y format —, 3/14/18, looks close enough to Archimedes’ constant’s decimal representation for it to be the constant’s celebratory day.
As always on Pi Day, I have implemented an algorithm to generate 𝜋, albeit this year’s accuracy is not the greatest (Try it online [1]).

           typedef double d;typedef long l;l f(l n
      ){l f=1;while(n>1)f*=n--;return f;}d ne(d v,
    l p){d r=1;for(l k=0;k<p;k++)r*=v;return r;}d 
   ps(d(*c)(l),l i,d x){d s=0;for(l k=0;k<i;k++)s 
  +=c(k)*       ne(x,        k);return            
 s;}           d exc         (     l              
n){            return       1./f (n)              
              ; } d         exp(d x               
             )   {         return                 
            ps(exc        ,20,x);}                
           d G( d         x){return               
           exp(-x        *x);}d I                 
          (d a,d         b,d g,d                  
        (* f)(d         )){d cs=                  
       0;for( d         x=a;x<=                   
      b;x +=g)         cs+=f(x)                   
    *g;return          cs ;  }          int       
  main( ) { d          pi_root         =I(        
 -2.5, 2.5 ,           1e-4,G);      d pi         
= pi_root *            pi_root+(0xf&0xf0          
) ; printf(             "%c%c%c%c%c%f%c"          
,'p','i',                ' ','=',' ',pi           
  ,'\n'                     ) ; }                 

I use various methods of generating 𝜋 throughout the Pi Days; this time I chose to use an improper integral paired with a power series. 𝜋 is calculated using a famous identity involving infinite continuous sums, roots, e, statistics and — of course — 𝜋.

\int\limits_{-\infty}^\infty e^{-x^2}\mathrm{d}x=\sqrt{\pi}

Furthermore, to compute 𝑒, the following identity is used.

\exp{x}=\sum\limits_{n=0}^\infty\frac{x^n}{n!}

Both formulae are combined, the approximated value of \sqrt{\pi} is squared and 𝜋 is printed to stdout.

You can download this program’s prettified (some call it obfuscated, see above) source code pi.c and also the (nearly, as #include is not missing so that the compiler does not need to guess my dependencies) equivalent code in a more traditional source layout tpi.c.

Happy Pi Day!

Extra assets: pi_no-warnings.c
Jonathan Frech's blog; built 2024/05/27 06:43:58 CEST