the-ray-tracer-challenge-fsharp
AngouriMath
Our great sponsors
the-ray-tracer-challenge-fsharp | AngouriMath | |
---|---|---|
10 | 18 | |
19 | 754 | |
- | 2.4% | |
4.0 | 5.4 | |
7 months ago | 3 months ago | |
F# | C# | |
MIT License | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
the-ray-tracer-challenge-fsharp
-
Good book to learn F#?
Take a book that is project-based, such as The Ray Tracer Challenge, no matter what language it uses in the book, and start going through the book in F#. I have done so, for example, here is my in-work F# implementation for the ray tracer book.
-
OCaml at First Glance
Yes, please do! Warning: F# will ruin other languages for you. I find it rather painful to work in basically anything else after using F#, with gradients of pain for different languages. Haha.
And that's a good question. I have basically every book written on F#, but I can't say I have ever used them for anything more than reference.
The official docs/guide/reference are actually really good, and I refer to them a lot when using some feature I'm not familiar with: https://docs.microsoft.com/en-us/dotnet/fsharp/what-is-fshar...
F# For Fun and Profit is well-known, but I can't say I use it a lot: https://fsharpforfunandprofit.com/
The same author's (Scott Wlaschin) book is very good: https://pragprog.com/titles/swdddf/domain-modeling-made-func...
As for books, I have always liked:
* Functional Programming Using F# by Hansen and Rischel (might be too simple if you are already comfortable with functional programming and is out of date every now and then with changes to F# that's happened)
* Expert F# 4.0 by Don Syme and others (contains a lot of nice things by the designer of F#
One of the latest books is Stylish F# 6: Crafting Elegant Functional Code for .NET 6 by Kit Eason. I have the first edition but haven't read it.
My personal recommendation is to take the approach of type/domain driven design. That is, I start off every F# module the same:
1. Define my types with discriminated unions, records, type aliases (such as for tuples) or single case discriminated unions. Use classes when necessary but try to prefer the more functional types.
2. Start writing functions against these.
And that's basically it. One thing to recognize with F# is that it mixes OOP rather nicely. Even discriminated unions and records, which are immutable, can have members defined on them, including operator overloading (something F# is pretty good about). They can even implement interfaces and be defined with generic types, which is also nice and powerful.
I have some projects that might of interest, since they're simple enough and illustrate the above process.
https://github.com/bmitc/the-ray-tracer-challenge-fsharp
https://github.com/bmitc/nand2tetris
Lastly, I'd suggest just starting up some projects. You could also take the Programming Languages course on Coursera by Dan Grossman. Part A uses SML, and you could port the examples and homework solutions to F# (I did so when I took the course). I also take books written for other languages and port the code to F#, usually taking a more idiomatic functional style. .NET Interactive notebooks (https://github.com/dotnet/interactive) are a great way to get started. You just need to install the .NET 6 SDK (which gets you F#) and then install the .NET Interactive Notebook extension in VS Code. That's it. There is also the book The Little MLer which gets people comfortable with discriminated unions (sum types), and I used the book and ported the examples to F#. I need to go back and finish that annotation project (https://github.com/bmitc/the-little-fsharper). I'll probably convert the script files to .NET Interactive notebooks if I do.
-
What are you working on? (2022-07)
Here's mine, which is only about halfway through: https://github.com/bmitc/the-ray-tracer-challenge-fsharp
-
Das.Test - an opinionated unit testing library written in F# for F#
I used FsUnit here: https://github.com/bmitc/the-ray-tracer-challenge-fsharp/tree/main/RayTracerChallenge/XUnitTests
-
The joy of building a ray tracer, for fun, in Rust
Yes, the book has both implementations of the required functions (for all the complicated ones you need) and tests all written in pseudocode.
The book is really good. I have a half-finished implementation in F#, and what I find striking is just how close the F# code is to the pseudocode. I have also started an idiomatic port to Racket but have only done the tuples, vector, and point implementations so far. I need to pick these up again.
https://github.com/bmitc/the-ray-tracer-challenge-fsharp
https://github.com/bmitc/the-ray-tracer-challenge-racket
I mean, check this out: https://github.com/bmitc/the-ray-tracer-challenge-fsharp/blo...
I have also worked through pieces of Ray Tracing in One Weekend (what was referenced in this post). They get you going much faster, but the code is written in C++. I found the translation to a functional style was harder (was just using Racket and F#'s mutability features), whereas the way The Ray Tracer Challenge is laid out and specified, I found it much easier to translate to an idiomatic functional style.
- Really great example projects?
- Is F# Tough to Learn?
- What are F#'s advantages?
-
Can anyone suggest any interesting F# projects?
Another project of mine is going through the book The Ray Tracer Challenge with F#. The book is language agnostic and represents the code with pseudocode and presents a test driven approach. My repository is here: https://github.com/bmitc/the-ray-tracer-challenge-fsharp
-
Super simple ray tracer guide after first math semester
I highly recommend the two books:
Ray Tracing in One Weekend: https://www.amazon.com/dp/B01B5AODD8/
The Ray Tracer Challenge: https://www.amazon.com/dp/1680502719/
For the latter, I have made it a pretty good way through the book, implementing a functional (in the programming paradigm sense) version of the ray tracer in F#. It’s actually rather mind boggling how close the F# code and tests are to the psuedocode found in the book.
https://github.com/bmitc/the-ray-tracer-challenge-fsharp
AngouriMath
-
Is there a c# library available that will evaluate arithmetic string such "5+3+max(3)" in runtime say from a file and provide output
it's also might be helpful AngouriMath
-
Nobody talks about that Nuget gallery needs to sign back in every time?
Another example of my library, which, unlike the previous one, uses myget.org for versions from push to the main branch (note that in this case you will have to go to myget.org and create a feed there before you can push to it).
-
Which API for matrix concatenation do you like the most?
Original issue, in case you want to comment there.
-
Is there a model mathematical functions that perform the same purpose?
This is slightly off topic but it sounds like you might be interested in AngouriMath: https://am.angouri.org/
-
No, +5 is not equivalent to advantage in (nearly) any situation
The other programmer mindset is to write yourself a library to do the exact, symbolic math for you. I hereby introduce you to https://am.angouri.org/
-
F# + Plotly.NET + AngouriMath + Interactive: symbolic algebra for research!
AngouriMath: symbolic algebra library I'm working on.
-
My first app in F#!
This app is made in F#, and it is F#-based CLI for AngouriMath, symbolic algebra library that I work on.
-
AngouriMath 1.3 is here! (update for a FOSS symbolic algebra library)
Thanks everyone for support. For those, who have no idea what it all is about, it's a symbolic algebra library for .NET, you can check its github here.
-
Honk#! Honk in convenient C# now!
Are there use cases? Yes, I recently (just a few days ago) moved a symbolic algebra library AngouriMath to it, and it is already making my life much easier.
-
.NET's AngouriMath now can be used from C++! (proof of concept version)
AngouriMath is an open-source symbolic algebra written in and for .NET (I'm its main contributor). Recently I made it possible to use it from F# and Jupyter, so I thought, why not to try C++?
What are some alternatives?
nand2tetris - Original course HDL solutions, F# implementations for the software stack, and VHDL implementations for the hardware stack for the nand2tetris course and The Elements of Computing Systems book.
MathNet - Math.NET Numerics
Bolero - Bolero brings Blazor to F# developers with an easy to use Model-View-Update architecture, HTML combinators, hot reloaded templates, type-safe endpoints, advanced routing and remoting capabilities, and more.
MKL.NET - A simple cross platform .NET API for Intel MKL
equinox - .NET event sourcing library with CosmosDB, DynamoDB, EventStoreDB, message-db, SqlStreamStore and integration test backends. Focused at stream level; see https://github.com/jet/propulsion for cross-stream projections/subscriptions/reactions
UnitConversion - Expansible Unit Conversion Library for .Net Core and .Net Framework
the-ray-tracer-challenge-racket - Racket implementations of the ray tracer found in The Ray Tracer Challenge book by Jamis Buck.
Jace - Jace.NET is a calculation engine for the .NET platform.
WebApiTest - Sustainable Web API written in F# that showcases the language's strengths via a functional style.
Rationals - 🔟 Implementation of rational number arithmetic for .NET with arbitrary precision.
CardManagement
interactive - .NET Interactive combines the power of .NET with many other languages to create notebooks, REPLs, and embedded coding experiences. Share code, explore data, write, and learn across your apps in ways you couldn't before.