Conversation

Notices

1. Embed this notice
   Karsten Johansson (ksaj@infosec.exchange)'s status on Thursday, 09-Jan-2025 16:53:28 JST Karsten Johansson

   • Ásbjørn 🏳️‍🌈

   WARNING: Awesome code follows

   I just read there is a more accurate way to calculate a dog's age in human years than simply multiplying by 7 (which does produce a lot of oddities, especially when it comes to dogs giving birth at "7" years old lol). The progression through the first, second and then subsequent years are handled in a manner that is much closer to how dogs typically age compared to humans.

   Here are #lisp and #python functions demonstrating the new calculations. Feel free to use them as you wish. Especially if you have one or more dogs.

   Feel free to improve or comment on the code in the comments or elsewhere. I always post these kinds of functions for conversation and community, I'm just learning python, so don't bark too loudly.

   The formats are:

   (dogs-age years months)
   and
   dogs_age(years, months)

   There is no error checking, so use zeros when necessary.

   Don't be strangers. Shake a paw!

   #commonlisp

   (defun dogs-age (years months)
   "Calculate the human age equivalent of a dog given its age in years and months."
   (let ((human-age 0))
   (cond
   ((< years 1)
   (setq human-age (* (/ months 12.0) 15)))
   ((= years 1)
   (setq human-age (+ 15 (* (/ months 12.0) 9))))
   ((>= years 2)
   (setq human-age (+ 15 9
   (* (- years 2) 5)
   (* (/ months 12.0) 5)))))
   human-age))

   #python3

   def dogs_age(years, months):
   """
   Calculate the human age equivalent of a dog given its age in years and months.
   """
   if years < 1:
   human_age = months * (15 / 12)
   elif years == 1:
   human_age = 15 + months * (9 / 12)
   else:
   human_age = 15 + 9 + (years - 2) * 5 + months * (5 / 12)

   return human_age

   Hey, @praetor you might be interestd in this, even if it isn't about cats. If you change the subsequent years from 5 to 4, it'll work for cats just the same, apparently. :ablobdj:

   #dog #dogs #dogsofmastodon #mondog

   • screwlisp and Alfred M. Szmidt repeated this.
   • Embed this notice
     Elias Mårtenson (loke@functional.cafe)'s status on Thursday, 09-Jan-2025 16:54:36 JST Elias Mårtenson

     in reply to

     • Ásbjørn 🏳️‍🌈

     @ksaj @praetor Since you posted it in two different languages, allow me to add another:

     { (y m)←⍵ ⋄ +/ 1 (0⌈y-2) m × ⊃(1+×y-1)⊇(0 0 15r12) (15 0 9r12) (24 5 5r12)}
     

     Call it by adding the year and the day at the end of the expression. If you want the output in decimal rather than a fraction, you can add 0.0 to the result by prefixing the entire expression with 0.0+.

     { (y m)←⍵ ⋄ +/ 1 (0⌈y-2) m × ⊃(1+×y-1)⊇(0 0 15r12) (15 0 9r12) (24 5 5r12)} 1 10
     

     https://kapdemo.dhsdevelopments.com/clientweb2/#c=eyAoeSBtKeKGkOKNtSDii4QgKy8gMSAoMOKMiHktMikgbSDDlyDiioMoMSvDl3ktMSniiocoMCAwIDE1cjEyKSAoMTUgMCA5cjEyKSAoMjQgNSA1cjEyKX0gMSAxMA==

   • Embed this notice
     screwlisp (screwtape@mastodon.sdf.org)'s status on Thursday, 09-Jan-2025 18:32:06 JST screwlisp

     in reply to

     • Elias Mårtenson
     • Ásbjørn 🏳️‍🌈

     @loke @ksaj @praetor
     Gotta read thread but here:
     (require :series)
     (series::install)
     (defun dogs-age (years &optional (months 0))
     (let*
     ((d0m (scan-range :from 0 :below 12))
     (h0y (#M* d0m (series 15/12)))
     (d1m (scan-range :from 12 :below 24))
     (h1y (#M+ (#M* d0m (series 9/12)) (series 15)))
     (d2+ (scan-range :from 24))
     (h2+ (#M+ (series 24) (#m* (series 5/12) (#m- d2+ (series 24))))))
     (collect-nth (+ months (* 12 years))
     (catenate h0y h1y h2+))))

   • Embed this notice
     Karsten Johansson (ksaj@infosec.exchange)'s status on Thursday, 09-Jan-2025 18:32:07 JST Karsten Johansson

     in reply to

     • Elias Mårtenson
     • Ásbjørn 🏳️‍🌈

     @loke @praetor There are quite a lot of things easier about python than lisp.

     When it comes to portable output, python wins hands down. It's frikken hard to write something graphical that'll work under Linux, Windows and MacOS in Lisp, using the exact same code for all three. It's trivial under python.

     screwlisp repeated this.
   • Embed this notice
     Elias Mårtenson (loke@functional.cafe)'s status on Thursday, 09-Jan-2025 18:32:07 JST Elias Mårtenson

     in reply to

     • Ásbjørn 🏳️‍🌈

     @ksaj @praetor That depends on the type of output you're looking for, and it's more of a tooling issue than a language issue. The integrated graphics tools I've added to Kap would be trivial to add to Lisp as well. It certainly was very easy on the Lisp machines.

     By the way, I implemented your code in explicit style in Kap, just to show that you can write code that way too.

     https://kapdemo.dhsdevelopments.com/clientweb2/#c=4oiHIGRvZ3NBZ2UgKHllYXJzOyBtb250aHMpIHsKICB3aGVuIHsKICAgICh5ZWFycyA8IDEpIHsgbW9udGhzIMOXICgxNcO3MTIpIH0KICAgICh5ZWFycyA9IDEpIHsgMTUgKyBtb250aHMgw5cgKDnDtzEyKSB9CiAgICAoMSkgICAgICAgICB7IDE1ICsgOSArICgoeWVhcnMtMinDlzUpICsgKG1vbnRoc8OXKDXDtzEyKSkgfQogIH0KfQoKcmVzdWx0IOKGkCBkb2dzQWdl4p+mMTs34p+nCmlvOnByaW50bG4gIlJlc3VsdDogIiByZXN1bHQrMC4w

     screwlisp repeated this.
   • Embed this notice
     Karsten Johansson (ksaj@infosec.exchange)'s status on Thursday, 09-Jan-2025 18:32:08 JST Karsten Johansson

     in reply to

     • Elias Mårtenson
     • Ásbjørn 🏳️‍🌈

     @loke @praetor That's cool. And a reasonable limit since after 3 years it's just a straight line until a very unlikely point is reached and exceeded.

     Funny enough, the equivalent is easier to write in python than in lisp. Maybe that's why it's used in a lot of labs.

   • Embed this notice
     Elias Mårtenson (loke@functional.cafe)'s status on Thursday, 09-Jan-2025 18:32:08 JST Elias Mårtenson

     in reply to

     • Ásbjørn 🏳️‍🌈

     @ksaj @praetor I don't think so. I think it has to do with the fact that the subject matter experts that wants to perform some computations are not programmers, so they use what they know. And the narrative these days is that python is the language that is "easy".

     Back in the day, that language was APL, and "non programmers" found it to be much easier than the alternatives.

     There is nothing inherently easier about python than lisp. Both languages require an understanding of the syntax and how to use it, and I don't think either are easier to learn than the other.

   • Embed this notice
     Elias Mårtenson (loke@functional.cafe)'s status on Thursday, 09-Jan-2025 18:32:09 JST Elias Mårtenson

     in reply to

     • Ásbjørn 🏳️‍🌈

     @ksaj @praetor By the way, if you want to plot the first 50 months:

     https://kapdemo.dhsdevelopments.com/clientweb2/#c=Y2hhcnQ6bGluZSB7ICh5IG0p4oaQ4o21IOKLhCArLyAxICgw4oyIeS0yKSBtIMOXIOKKgygxK8OXeS0xKeKKhygwIDAgMTVyMTIpICgxNSAwIDlyMTIpICgyNCA1IDVyMTIpfcKoICgxMDAgMTLiiqQpwqgg4o2zNTA=

   • Embed this notice
     Karsten Johansson (ksaj@infosec.exchange)'s status on Thursday, 09-Jan-2025 18:32:10 JST Karsten Johansson

     in reply to

     • Elias Mårtenson
     • Ásbjørn 🏳️‍🌈

     @loke @praetor

     "My dog is less than a year, 4 months old"

     versus

     "My dog is zero years, plus 4 months old"

     It suggests then I should have used :years and :keys and made them both optional in order to make it consistent for a human reader. Or leave it as-is and use (= years 0) since that reflects my input example where year is always input, even if 0.

     It all still works the same. I'm just trying to make it as lisperifically correct as it can be.

   • Embed this notice
     Karsten Johansson (ksaj@infosec.exchange)'s status on Thursday, 09-Jan-2025 18:32:11 JST Karsten Johansson

     in reply to

     • Elias Mårtenson
     • Ásbjørn 🏳️‍🌈

     @loke @praetor I was secretly hoping you'd provide your even-more-alien language version. :ablobdj:

     Question, since you're a little smarter than me: I learned that in Lisp programming, the preferred method is code is easiest understood by the (human) reader. So in this context, one of the cond conditions is (< years 1) which obviously could go below zero, but we humans know it never would.

     If a dog is less than a year old, a (human) reader would say "less than a year old", versus the tighter (= years 0) plus however many months.

     I think (hope?) the compiler would adjust it exactly the same way.

     What is considered better code - the human way or the computer way of writing it?

     EDIT: Also, yea, I think you need to prefix the 0.0+ or something (it didn't work for me). The result for 1 year 10 months is 45/2, which is quite a bizarre way to describe a dog's age. I just changed the 10 to 10.0 in the input and it gave me more civilized results. So it can be tamed somehow.

     EDIT2: Okay I got it. It works outside the brackets. It definitely needs to be there since 45/2 is such an unintuitive answer.

     screwlisp repeated this.
   • Embed this notice
     Elias Mårtenson (loke@functional.cafe)'s status on Thursday, 09-Jan-2025 18:32:11 JST Elias Mårtenson

     in reply to

     • Ásbjørn 🏳️‍🌈

     @ksaj @praetor You can always type ]ratmode decimal which will print all rationals in decimal form.

     A closing square bracket is the prefix for system commands.

     As it happens, my implementation will assume that any negative year to be zero (by virtue of the 0⌈n expression which returns the greatest of 0 and n). The same is not done for months, so negative months will yield weird results. Then again, passing in a complex number will also yield strange results.

     I approached the problem as just writing a mathematical equation, and just like any equation they have a domain of applicability.

     In maths, the assertion that input confirms to a given domain is in the text of the paper, not the formula itself, which maps to your example by the statement that the format is "(dogs-age years months)".

     Adding explicit checks for this makes the code less clear, I think. If this was part of an actual product, then the requirements are of course very different.

   • Embed this notice
     screwlisp (screwtape@mastodon.sdf.org)'s status on Thursday, 09-Jan-2025 18:43:39 JST screwlisp

     in reply to

     • Elias Mårtenson
     • Ásbjørn 🏳️‍🌈

     @loke @ksaj
     I see the arguement that the lambda list could have been (&optional (months 0) (years 0)) since not specifying years is code for 0 years, but in practice it's more common to hear "my dog is 2" and adding a zero space doesn't seem like a big deal to show it's a baby.

     My most annoying thing here is time (har har har) Since I've obviously hardcoded over and over again that a year is twelve months and it seems like there would be a better way to do that with macros.

     @praetor

   • Embed this notice
     screwlisp (screwtape@mastodon.sdf.org)'s status on Thursday, 09-Jan-2025 19:10:17 JST screwlisp

     in reply to

     • Elias Mårtenson
     • Ásbjørn 🏳️‍🌈

     @ksaj
     To some extent you could write them more similarly. I believe the return is implied in both. the age = is just a verbose style. The cond would use :otherwise or the python would use elif years >= 2. Obviously, lisp has rationals.

     I guess my one is a bit different: I viewed it as lazily indexing into an infinite series of dog ages. I suffer a bit from needing to make number atoms into series. And the numbers-everywhere feels messy, though I guess I write messily (cAsE)
     @loke @praetor

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Thursday, 09-Jan-2025 21:56:41 JST Alfred M. Szmidt

     in reply to

     • Ásbjørn 🏳️‍🌈

     @ksaj (dogs-age pi #C(0 1))

     #C(29.707963267948966d0 0.4166666865348816d0)

     @praetor

   • Embed this notice
     Karsten Johansson (ksaj@infosec.exchange)'s status on Friday, 10-Jan-2025 01:35:54 JST Karsten Johansson

     in reply to

     • Ásbjørn 🏳️‍🌈
     • Alfred M. Szmidt

     @amszmidt @praetor Proof that the world is round!

   • Embed this notice
     Karsten Johansson (ksaj@infosec.exchange)'s status on Friday, 10-Jan-2025 01:36:02 JST Karsten Johansson

     in reply to

     • Ásbjørn 🏳️‍🌈
     • Alfred M. Szmidt

     @amszmidt @praetor In an ideal world, our calendar would indeed be pi based.

   • Embed this notice
     lispm (lispm@moth.social)'s status on Friday, 10-Jan-2025 06:54:08 JST lispm

     in reply to

     • Elias Mårtenson
     • Ásbjørn 🏳️‍🌈

     @ksaj @loke @praetor using something like Gnuplot from CL ? https://github.com/mobius-eng/cl-gnuplot

   • Embed this notice
     lispm (lispm@moth.social)'s status on Friday, 10-Jan-2025 06:54:10 JST lispm

     in reply to

     • Elias Mårtenson
     • Ásbjørn 🏳️‍🌈

     @ksaj @loke @praetor I would write a algorithmically useful function and use that from a function which would be a convenience interface...example...

   • Embed this notice
     Karsten Johansson (ksaj@infosec.exchange)'s status on Friday, 10-Jan-2025 06:59:39 JST Karsten Johansson

     in reply to

     • Elias Mårtenson
     • Ásbjørn 🏳️‍🌈
     • lispm

     @lispm @loke @praetor Ah, this is a neat way to go about it.

     For humans, you'd need to add a months->years or months->yearsmonths for when months > 12. But you probably would have to with my code, too, since '12.5 years' is less optimal than '12 years 6 months'.

   • Embed this notice
     screwlisp (screwtape@mastodon.sdf.org)'s status on Friday, 10-Jan-2025 06:59:39 JST screwlisp

     in reply to

     • Elias Mårtenson
     • Ásbjørn 🏳️‍🌈
     • lispm

     @ksaj
     (defun months->years (months) "first return is years, second return is remainder months"
     (truncate months 12))
     @lispm @loke @praetor