#rosettacode — Public Fediverse posts

Here you go, numerous #ATS fans, another #Mathematics #RosettaCode contribution in #ATSlang --

https://rosettacode.org/wiki/Determine_if_two_triangles_overlap#ATS

A #RosettaCode contribution for #ATS -- the old insideness of a convex hull algorithm. I decided to do this because I am likely to stick the algorithm within my next Bézier intersection algorithm (which will be coded in Ada using homogeneous geometric algebra, not in ATS using euclidean, but whatever) --

Find if a point is within a triangle - Rosetta Code https://rosettacode.org/wiki/Find_if_a_point_is_within_a_triangle#ATS

#ATSlang #Mathematics #Geometry

Have at it, #fonts nerds and #graphics weirdos! A #RosettaCode task for y’all:

Bézier curves/Intersections - Rosetta Code https://rosettacode.org/wiki/B%C3%A9zier_curves/Intersections

#ATS #ATSlang #Dlang #Maxima

I wrote a new #RosettaCode task of interest to both #ATS fans and #fonts fans:

Steffensen's method - Rosetta Code https://rosettacode.org/wiki/Steffensen%27s_method

Incidentally, before being smart and using #MetaPost for the graphic (the only SW I should have considered, aside from #Asymptote), I tried using the software formerly known as FF, but which did nothing but crash. I mean, really, it did nothing but crash. FontCrash, it will be called.

cc: @khaled

More #ATS (#ATSlang) for #RosettaCode --

https://rosettacode.org/wiki/Simulated_optics_experiment/Data_analysis#ATS

There is a new #ATS example at #RosettaCode, part of my nascent tendentious series of simulations that show quantum physicists are entirely wrong in some of their beliefs:

https://rosettacode.org/wiki/Simulated_optics_experiment/Simulator

This #ATSlang code is all or mostly free of the proofs and complicated call by reference you often see in my ATS code. You could translate it straight into OCaml or SML. It is a simulation, supposedly impossible, of experiments you sometimes see hyped in the news, but which are stupid.

I just added a task to #RosettaCode, so have at it!

Bernstein basis polynomials - Rosetta Code https://rosettacode.org/wiki/Bernstein_basis_polynomials

#Algol60 #algol #python #fonts #bezier

I just added a task to #RosettaCode, so have at it!

Bernstein basis polynomials - Rosetta Code https://rosettacode.org/wiki/Bernstein_basis_polynomials

#Algol60 #algol #python #fonts #bezier

I just added a task to #RosettaCode, so have at it!

Bernstein basis polynomials - Rosetta Code https://rosettacode.org/wiki/Bernstein_basis_polynomials

#Algol60 #algol #python #fonts #bezier

I just added a task to #RosettaCode, so have at it!

Bernstein basis polynomials - Rosetta Code https://rosettacode.org/wiki/Bernstein_basis_polynomials

#Algol60 #algol #python #fonts #bezier

I just added a task to #RosettaCode, so have at it!

Bernstein basis polynomials - Rosetta Code https://rosettacode.org/wiki/Bernstein_basis_polynomials

#Algol60 #algol #python #fonts #bezier

Some naïve quadrature implementations, in #ATS, for #RosettaCode --

https://rosettacode.org/wiki/Numerical_integration#ATS

#ATSlang #FunctionalProgramming #NumericalMethods

Last for the day: some quadrature instead of array stuff:

https://rosettacode.org/wiki/Numerical_integration/Gauss-Legendre_Quadrature#ATS

#ATS #ATSlang #RosettaCode

But back to Gaussian elimination, we have LU decomposition: https://rosettacode.org/wiki/LU_decomposition#ATS

#ATS #ATSlang #RosettaCode

Now for something (in)completely different: Cholesky decomposition.

https://rosettacode.org/wiki/Cholesky_decomposition#ATS

#ATS #ATSlang #RosettaCode

And here is the same code again modified, this time to find the reduced row echelon form of a matrix:

https://rosettacode.org/wiki/Reduced_row_echelon_form#ATS

#ATS #ATSlang #RosettaCode

Now I have added Gaussian elimination with back substitution:

https://rosettacode.org/wiki/Gaussian_elimination#ATS

#ATS #ATSlang #RosettaCode

And now I have added the #RosettaCode task for Gauss-Jordan matrix inversion:

https://rosettacode.org/wiki/Gauss-Jordan_matrix_inversion#ATS

#ATS #ATSlang

Here is some significant #ATS code, albeit not an optimized implementation: #QRDecomposition (#QRFactorization) for #RosettaCode --

https://rosettacode.org/wiki/QR_decomposition#ATS

#ATSlang #LinearAlgebra #NumericalMethods #Mathematics

A little #RosettaCode example of a Maybe #monad, in #ATS --

https://rosettacode.org/wiki/Monads/Maybe_monad#ATS

#ATSlang #FunctionalProgramming

Alright, you many, many #ATS fanatics. I have a treat for you: four #RosettaCode tasks at once!

https://rosettacode.org/wiki/Bresenham_tasks_in_ATS

#ATSlang #FunctionalProgramming #GraphicsProgramming #Fonts

Sure, one can use SDL2 or whatever to draw lines, and, sure, these figures have "aliasing", but the tasks call for aliased figures. (I already did antialiased lines in ATS for a different task.)

Okay, you NUMEROUS fans of #ATS, I have done the next step in that set of #RosettaCode tasks dealing with #pixmaps (#bitmaps):

https://rosettacode.org/wiki/Bitmap/Write_a_PPM_file#ATS

You have to get new versions of the earlier files, if you looked at those before. There is a link to them at the top of this entry.

#ATSlang

I have added another #ATS example to #RosettaCode, this time for a strangely named ‘Munching Squares’ task:

https://rosettacode.org/wiki/Munching_squares#ATS

(The reason I say the task is strangely named is that ‘Munching Squares’ is an animation. Perhaps the task is not adequately fleshed out. I did what I thought it wanted.)

#ATSlang

Okay, you #ATS fans, whom I know to be plentiful! Here is the #RosettaCode task for drawing antialiased straight lines, done in ATS:

https://rosettacode.org/wiki/Xiaolin_Wu's_line_algorithm#ATS

#ATSlang #FunctionalProgramming #ProceduralProgramming

Anti-aliased straight line drawing, implemented in #ObjectIcon (using the drawing of individual pixels, rather than cheating):

Xiaolin Wu's line algorithm - Rosetta Code https://rosettacode.org/wiki/Xiaolin_Wu's_line_algorithm#ObjectIcon

#RosettaCode

(I discovered (a) that ‘variable’ does what Parlett documented, even though it is different from what ‘variable’ does in Icon; (b) there are major bugs in ipl.math(ExtMath). I have marked them ‘SEVERE BUG’ in my issues tracker. Easy to fix, but not today.)

I hope that so far I have AT LEAST done enough to prevent #ObjectIcon disappearing into nowhere.

Now I have to go mention the new repo on #RosettaCode. I’ll just make a handwritten note, for now.

Of course, any RC contributor can make the changes. But one shouldn’t give the impression I plan to be a ‘maintainer’. I’m an older, disabled person simply providing the thing in the most forkable way.

(Were it my own project, it would surely be in a Mercurial archive, not Git.)

Mandelbrot set - Rosetta Code https://rosettacode.org/wiki/Mandelbrot_set#ObjectIcon

#Mandelbrot #MandelbrotSet #ObjectIcon #RosettaCode #ComputerProgramming

A #RosettaCode #quaternion task entry for both #OtusLisp and ‘regular’ #Scheme --

Quaternion type - Rosetta Code https://rosettacode.org/wiki/Quaternion_type#Ol

My latest addition to the #ATS repertoire of #RosettaCode -- an implementation of the #Quaternion type task --

Quaternion type - Rosetta Code https://rosettacode.org/wiki/Quaternion_type#ATS

Also related to ATS, I posted the #m4 output of vmc (which I wrote in ATS) to the #Mandelbrot set task:

https://rosettacode.org/wiki/Mandelbrot_set#M4

#ATSlang

This #compiler for the #RosettaCode Virtual Machine assembly language can now target any of #ATS, #C, #Mercury, or #Scheme --

https://sourceforge.net/p/chemoelectric/rosettacode-contributions/ci/default/tree/vmc.dats

The Scheme code runs very fast in #ChezScheme, so-so in all else I have tried. I wonder how they do it. Maybe a lot of C code (instead of Scheme) in the runtime is part of it?

The generated Mercury is not so fast, but such is life with Mercury. It’s fastish, considering.

#ATSlang #ContinuationPassingStyle #FunctionalProgramming

I went ahead and wrote a Virtual Machine to #ATS translator for the #RosettaCode #compiler task series:

Compiler/virtual machine interpreter - Rosetta Code https://rosettacode.org/wiki/Compiler/virtual_machine_interpreter#Compiler

The thing’s designed to make it relatively easy to handle many other languages. Languages with #goto should be easy to do, for instance: convert the program to one procedure with a lot of goto in it. And #Scheme could be done easily. I have ideas for #ObjectIcon and co-expressions.

#FunctionalProgramming

Finally (at least for today), here is a second #Fortran program:

https://rosettacode.org/wiki/Modular_arithmetic#Program_2

#RosettaCode #ProceduralProgramming

Lo and behold, now #OwlLisp (a dialect of #Scheme without anything mutable in it):

https://rosettacode.org/wiki/Modular_arithmetic#Owl_Lisp

#RosettaCode #ModularArithmetic #FunctionalProgramming #Lisp

I have added #ObjectIcon --
https://rosettacode.org/wiki/Modular_arithmetic#ObjectIcon

#RosettaCode #ProceduralProgramming

(I will not call this an example of #LogicProgramming, given that I never use goal-direction or failure in any significant way. But #ObjectOriented does apply.)

I just keep going. It is a pretty simple task. I did more than was called for, in the #ATS example I did first.

Here is #Fortran --

https://rosettacode.org/wiki/Modular_arithmetic#Fortran

As with the ATS, I use a macro, although the macro system is not as capable as that of ATS.

(I used the C preprocessor. There was once a standard Fortran preprocessor, but it was removed from the standard. Nobody used it. Everyone used the C preprocessor, m4, or some such.)

#RosettaCode #ProceduralProgramming

I have added #ATS to the languages for which there is a solution to the #RosettaCode #ModularArithmetic task:

Modular arithmetic - Rosetta Code https://rosettacode.org/wiki/Modular_arithmetic#ATS

This task was practically tailor-made for #Ada. :) But ATS lets us easily extend the language to handle modular numbers.

#ATSlang #FunctionalProgramming #Proofs

Update: After reading the task language again, I added some more commentary, to point out what I see as a flaw in the task.

I have now added #Oberon2 --

https://rosettacode.org/wiki/Modular_inverse#Oberon-2

#RosettaCode #Oberon

(UPDATE: Now with bugfix and regression test.)

I have now added #Oberon2 --

https://rosettacode.org/wiki/Modular_inverse#Oberon-2

#RosettaCode #Oberon

(UPDATE: Now with bugfix and regression test.)

I have now added #Oberon2 --

https://rosettacode.org/wiki/Modular_inverse#Oberon-2

#RosettaCode #Oberon

(UPDATE: Now with bugfix and regression test.)

I have now added #Oberon2 --

https://rosettacode.org/wiki/Modular_inverse#Oberon-2

#RosettaCode #Oberon

(UPDATE: Now with bugfix and regression test.)

And now I did #zsh :

https://rosettacode.org/wiki/Modular_exponentiation#zsh

But really it is #GNU #expr doing the work. I had considered using GNU #bc instead. Basically anything that can do the calculation. Unix-users in the old days often liked hoc; maybe there is a hoc implementation you could use. :)

#zshell #RosettaCode

Now I have done the #ObjectIcon --

https://rosettacode.org/wiki/Modular_exponentiation#ObjectIcon

I hope to one day host the Object Icon sources myself, but you can get the last version by the author at Sourceforge. And my ‘chemoelectric’ overlay has a live ebuild for Gentoo. (I should make a ‘dead’ ebuild with a date as version, since the sources are no longer changing unless I make the changes.)

#RosettaCode

I have hacked out a #Gentoo ebuild for the Oxford #Oberon2 Compiler:

chemoelectric / chemoelectric-overlay / dev-lang / obc — Bitbucket https://bitbucket.org/chemoelectric/chemoelectric-overlay/src/master/dev-lang/obc/

For the #RosettaCode buffs who program in all the languages except those they hate, and sometimes even in those they hate.

I have hacked out a #Gentoo ebuild for the Oxford #Oberon2 Compiler:

chemoelectric / chemoelectric-overlay / dev-lang / obc — Bitbucket https://bitbucket.org/chemoelectric/chemoelectric-overlay/src/master/dev-lang/obc/

For the #RosettaCode buffs who program in all the languages except those they hate, and sometimes even in those they hate.

I have hacked out a #Gentoo ebuild for the Oxford #Oberon2 Compiler:

chemoelectric / chemoelectric-overlay / dev-lang / obc — Bitbucket https://bitbucket.org/chemoelectric/chemoelectric-overlay/src/master/dev-lang/obc/

For the #RosettaCode buffs who program in all the languages except those they hate, and sometimes even in those they hate.

I have hacked out a #Gentoo ebuild for the Oxford #Oberon2 Compiler:

chemoelectric / chemoelectric-overlay / dev-lang / obc — Bitbucket https://bitbucket.org/chemoelectric/chemoelectric-overlay/src/master/dev-lang/obc/

For the #RosettaCode buffs who program in all the languages except those they hate, and sometimes even in those they hate.

It is not too often that I add a #Dlang example to #RosettaCode :

Continued fraction/Arithmetic/G(matrix ng, continued fraction n) - Rosetta Code https://rosettacode.org/wiki/Continued_fraction/Arithmetic/G(matrix_ng,_continued_fraction_n)#D

In fact, I think this is just the second time. I do not like this style of programming (even though #ObjectIcon is much alike and I hope to be its advocate in the absence of its author).

Yesterday I added a second #Scheme implementation (I also did the first) and #CommonLisp for this task.