nomina58mg.12.35

Să se găsească toate numerele întregi n pentru care numărul N=n⁸+4 este prim.

Să se determine în aceste cazuri numerele N.

in bash,Linux Mint

cabal repl -b arithmoi

in ghci, haskell

import Math.NumberTheory.Primes.Testing

tu gm =(,)<$>gm<*>gm

nab(a,b)n =n^a+b

isprinab t=isPrime.nab t

fisprin a =filter(isprinab(a,1)) [1..999]

fisprina b=filter(isprinab(2*b,b))[1..999]

all isPrime.map(nab(12,6)).fisprina$ 6

([3..99]\\).filter((1==).length.fisprin)$[1..99]

» 4,8,16,32,64

filter(isprinab(8,4))[1..9999] » 1

fisprina 6

» 1,35,119,343,595,637,665,791

nomina58mg.10.7

Produsul a două numere consecutive naturale este 18906. Să se afle numerele.

:m +Data.List Data.Bool

divisors n=let{rt=floor.sqrt.fromIntegral$ n;lw=filter((0==).rem n)[1..rt]}in(lw++).bool id tail(n==rt^2).reverse.(quot n<$>)$ lw

sudiv n k =(k+1==).div n$ k

fitadiv n =find(sudiv n).tail.init.divisors$ n

finothin f=filter((Nothing/=).f)

prosucc n =(n*).succ$ n

ff f xs =fmap f(xs,xs)

fifitadiv =map(fmap fromJust).finothin snd.map(ff fitadiv)

fifitadiv[18000..18999]

» (18090,134) (18360,135) (18632,136) (18906,137)

([16..80]==).map snd.fifitadiv$ [2^8..3^8]

mapM_ puconsho rx

(xy)=z+19 ➞ (xyz)⁝2 răspuns:234

(xy)=z+39 ➞ (xyz)⁝2 răspuns:456

(xy)=z+59 ➞ (xyz)⁝2 răspuns:678

(xy)=z+9 ➞ (xyz)⁝3 răspuns:123

(xy)=z+19 ➞ (xyz)⁝3 răspuns:234

(xy)=z+29 ➞ (xyz)⁝3 răspuns:345

(xy)=z+39 ➞ (xyz)⁝3 răspuns:456

(xy)=z+49 ➞ (xyz)⁝3 răspuns:567

(xy)=z+59 ➞ (xyz)⁝3 răspuns:678

(xy)=z+69 ➞ (xyz)⁝3 răspuns:789

(xy)=z+39 ➞ (xyz)⁝4 răspuns:456

(xy)=z+29 ➞ (xyz)⁝5 răspuns:345

(xy)=z+19 ➞ (xyz)⁝6 răspuns:234

(xy)=z+39 ➞ (xyz)⁝6 răspuns:456

(xy)=z+59 ➞ (xyz)⁝6 răspuns:678

(xy)=z+49 ➞ (xyz)⁝7 răspuns:567

(xy)=z+39 ➞ (xyz)⁝8 răspuns:456

(xy)=z+19 ➞ (xyz)⁝9 răspuns:234

(xy)=z+49 ➞ (xyz)⁝9 răspuns:567

(xy)=z+39 ➞ (xyz)⁝12 răspuns:456

(xy)=z+19 ➞ (xyz)⁝13 răspuns:234

(xy)=z+29 ➞ (xyz)⁝15 răspuns:345

(xy)=z+19 ➞ (xyz)⁝18 răspuns:234

(xy)=z+39 ➞ (xyz)⁝19 răspuns:456

(xy)=z+49 ➞ (xyz)⁝21 răspuns:567

(xy)=z+29 ➞ (xyz)⁝23 răspuns:345

(xy)=z+39 ➞ (xyz)⁝24 răspuns:456

(xy)=z+19 ➞ (xyz)⁝26 răspuns:234

(xy)=z+49 ➞ (xyz)⁝27 răspuns:567

(xy)=z+39 ➞ (xyz)⁝38 răspuns:456

(xy)=z+19 ➞ (xyz)⁝39 răspuns:234

(xy)=z+9 ➞ (xyz)⁝41 răspuns:123

(xy)=z+39 ➞ (xyz)⁝57 răspuns:456

(xy)=z+49 ➞ (xyz)⁝63 răspuns:567

(xy)=z+29 ➞ (xyz)⁝69 răspuns:345

(xy)=z+39 ➞ (xyz)⁝76 răspuns:456

(xy)=z+19 ➞ (xyz)⁝78 răspuns:234

(xy)=z+49 ➞ (xyz)⁝81 răspuns:567

(xy)=z+59 ➞ (xyz)⁝113 răspuns:678

(xy)=z+39 ➞ (xyz)⁝114 răspuns:456

(xy)=z+29 ➞ (xyz)⁝115 răspuns:345

(xy)=z+19 ➞ (xyz)⁝117 răspuns:234

(xy)=z+39 ➞ (xyz)⁝152 răspuns:456

(xy)=z+49 ➞ (xyz)⁝189 răspuns:567

(xy)=z+59 ➞ (xyz)⁝226 răspuns:678

(xy)=z+39 ➞ (xyz)⁝228 răspuns:456

(xy)=z+69 ➞ (xyz)⁝263 răspuns:789

(xy)=z+59 ➞ (xyz)⁝339 răspuns:678

nomina58mg.11.29

Să se demontreze că numărul n=3^40-2^40 se divide prin 5.

n(k)=3^k-2^k

n(2i)=3^(2i)-2^(2i)=9^i-4^i

import Data.List

potenc(a,b)k=a^k-b^k

sortt(t,ns) =(t,sort ns)

ff f xs=fmap f(xs,xs)

tridu k=3^k-2^k

tu gm =(,)<$>gm<*>gm

numod =nub.map(flip mod 10)

numob b=numod.map(b^)$ [1..1000]

numop t=numod.map(potenc t)$[1..500]

rn<-return.map sortt.map(ff numop).tu$ [1..9]

([2,4..998]==).filter((0==).flip mod 5.tridu)$ [1..999]

map(flip mod 5).map tridu$ [1..24]

» 1,0,4,0,1,0,4,0,1,0,4,0,1,0,4,0,1,0,4,0,1,0,4,0

numop(9,4)

» 5

rn

in vim

s/),((/)\r((/g

:%sort /.*\%8v/

Ultimul cifre numarului a^k-b^k prin 10.

((a,b),resturi a^k-b^k prin 10)

Avem jos parametrele problemelor si resturi(a^k-b^k) prin 10.

((1,3),[0,2,4,8])

((1,7),[0,2,4,8])

((6,2),[0,2,4,8])

((6,8),[0,2,4,8])

((2,6),[0,2,6,8])

((3,1),[0,2,6,8])

((7,1),[0,2,6,8])

((8,6),[0,2,6,8])

((4,2),[0,2,6])

((4,8),[0,2,6])

((9,3),[0,2,6])

((9,7),[0,2,6])

((1,9),[0,2])

((6,4),[0,2])

((2,8),[0,4,6])

((3,7),[0,4,6])

((7,3),[0,4,6])

((8,2),[0,4,6])

((2,4),[0,4,8])

((3,9),[0,4,8])

((7,9),[0,4,8])

((8,4),[0,4,8])

((4,6),[0,8])

((9,1),[0,8])

((1,1),[0])

((2,2),[0])

((3,3),[0])

((4,4),[0])

((5,5),[0])

((6,6),[0])

((7,7),[0])

((8,8),[0])

((9,9),[0])

((2,1),[1,3,5,7])

((3,6),[1,3,5,7])

((7,6),[1,3,5,7])

((8,1),[1,3,5,7])

((2,5),[1,3,7,9])

((5,2),[1,3,7,9])

((5,8),[1,3,7,9])

((8,5),[1,3,7,9])

((4,3),[1,5,7])

((4,7),[1,5,7])

((9,2),[1,5,7])

((9,8),[1,5,7])

((2,3),[1,5,9])

((3,2),[1,5,9])

((7,8),[1,5,9])

((8,7),[1,5,9])

((4,5),[1,9])

((5,4),[1,9])

((6,5),[1])

((3,5),[2,4,6,8])

((5,3),[2,4,6,8])

((5,7),[2,4,6,8])

((7,5),[2,4,6,8])

((1,2),[3,5,7,9])

((1,8),[3,5,7,9])

((6,3),[3,5,7,9])

((6,7),[3,5,7,9])

((2,9),[3,5,9])

((3,4),[3,5,9])

((7,4),[3,5,9])

((8,9),[3,5,9])

((4,1),[3,5])

((9,6),[3,5])

((5,9),[4,6])

((9,5),[4,6])

((5,1),[4])

((1,4),[5,7])

((6,9),[5,7])

((1,6),[5])

((2,7),[5])

((3,8),[5])

((4,9),[5])

((6,1),[5])

((7,2),[5])

((8,3),[5])

((9,4),[5])

((1,5),[6])

((5,6),[9])

Beta testers needed! Stressed out math nerds who like to draw a little, apply within.

New!!!\~button entitled —-Ammann approximation ——useful=quasicrystal n-folding -mathematical people take note/take advantage? Sure.!

I created a mathematica paclet that provides support for simplicial homology, introducing an abstract simplicial complex object. The package allows computing homology, betti numbers, automorphism groups, and common invariants like euler characteristic, fvectors, and constructions such as cones, suspensions, products, joins, etc! So far, there has been no in-built or third party support for this in Mathematica, which motivated the creation of this package. I largely took inspiration and reference from sagemath's implementation of this.

I would love to hear your feedback on this! The package is open source, see at https://github.com/zplus11/SimplicialHomology/ and is also available on the Wolfram paclet repository at https://resources.wolframcloud.com/PacletRepository/resources/Taggar/SimplicialHomology/

There is plenty of scope for further development and extension, so feedback, suggestions, and PRs are very welcome :)

Woxi is a free open source interpreter for the Wolfram Language, written in Rust. The guiding rule of the project: whatever it implements must produce exactly the same output as wolframscript / Mathematica — the test suite (26'000+ unit tests) compares against it directly.

Version 0.3.0 is out now. Highlights since 0.2.0:

• Many Wolfram Demonstrations now run end to end in Woxi Studio, the included native notebook editor for .nb files — still far from all of them, but dozens (Kepler's Second Law, Parabolic Mirror, Doyle Spirals, …) serve as end-to-end tests. Manipulate covers a good part of the Demonstrations control vocabulary (interactive Locators, Trigger, Button, SetterBar, PopupMenu, controls nested in TabView/Grid, dependent controls, TrackedSymbols, Animate bodies, …), and typeset notebook input is read back as code.
• Plotting conformance: Automatic ticks now match Wolfram's algorithm, list plots grew Around error bars, Callout, Filling, PlotMarkers and friends, plus new ComplexListPlot and ListLinePlot3D.
• CAS: more Integrate/D/Series/Limit coverage, LinearProgramming with an exact simplex solver, NonlinearModelFit, Reduce over higher-degree polynomial inequalities, RootReduce, and many canonical-ordering fixes so results print exactly as wolframscript prints them.
• Windows is now a supported platform, and every release ships prebuilt binaries for Linux, macOS, and Windows.

Try it without installing anything in our playground and JupyterLite instance in the browser: https://woxi.ad-si.com

Install: cargo install woxi, pip install woxi (Python bindings), or npm install woxi-wasm. Full changelog: https://github.com/ad-si/Woxi/blob/main/changelog.md

If Woxi is useful to you, I'm now accepting donations on GitHub: https://github.com/sponsors/ad-si I hope to receive enough support to keep the project going for a long time, and to eventually reach full parity with Wolfram's implementation.

Any ""serious"" language like C/C++, C#, Pascal/Delphi, and many others offers tons of options for building standalone apps. What about WL/Mathematica/MMA?

One could say, well, yes (and no)! There's the CDF format (which for some reason is officially considered deprecated 👀), webMathematica (costs like a helicopter and is also depreciated), JavaView (a very niche legacy project), and Wolfram Cloud. But I'm personally not a big fan of any kinds of clouds, especially with shady subscription models, and I'd rather keep everything local.

CDF was one of the best solutions so far, but it requires Mathematica (also costly) to build it, which isn't something everyone has, though thankfully, WolframScript/WolframEngine is still freeware.

Other people would argue that WL is meant purely for prototyping, and that you should just "vibe-code something with an LLM and JS" instead. I don't share that point of view, and I've found another way to turn notebooks into tiny or medium-sized apps for my research group. It works so far quite well for a limited number of users: 3-4 - mostly students. I would like to warn you, that it won't work magically for a random Mathematica notebook, otherwise WR would steal this immediately.

If you're interested, here's the full story I wrote:

https://wljs.io/blog/making-apps

PS: The thumbnail image isn't an AI-generated, it's a few UI windows built with this method, printed out and cut from paper 🙂

I've been working on a numerical solver app for a while. It started as a project for solving algebraic equations and systems, plotting functions, and doing various numerical calculations.

It's free and available on both platforms:

📱 App Store
🤖 Google Play

The next part of the project I'm working on is ODEs and boundary value problems.

I'm trying to make this as general as possible. The idea is that the user can enter an ODE and its boundary conditions, including higher-order equations and boundary conditions involving derivatives, without the app needing a predefined solution for that particular equation.

I'm currently testing it with different first-, second-, and higher-order ODEs. One of the tests I've been using is:

y''' + y = 0, y(0) = 0, y'(0) = 0, y''(0) = 0

I'm also trying some more difficult BVPs to see where the solver starts to struggle. There are already some interesting cases where an equation that looks very simple mathematically turns into a much more challenging numerical problem.

I'm curious what people here think.

For those of you who use Mathematica regularly, what ODEs, BVPs, or other numerical problems would you use to really stress-test a general-purpose solver?

I'm particularly interested in problems that aren't just straightforward textbook examples. 😅

You have probably seen a few posts mentioning WLJS. This is an open-source frontend + additional libraries made to bring Mathematica-like experience to a freeware Wolfram Engine and possibly solve some performance/portability issues of Mathematica. Small note: this is not vibecoded product, it stems from a few initial experiments done in 2018 and is not endorsed or affiliated with WRI.

Can any valid Wolfram code or Mathematica expression run well on WLJS Notebook? The answer is yes\*, but the devil is in the details.

Static output and anything related to computation is 100% transferable. You can take pretty much any code from Stack Exchange or Wolfram Community and it should work out of the box with a high chance, since we use the same Wolfram Language kernel, in the form of the freeware Wolfram Engine distribution. Manipulate and Animate are compatible too - and fully interactive!

However, low-level dynamics do need to be ported to execute correctly.

Here's a guide on how to port (if actually needed) a program from Wolfram Mathematica to WLJS:

https://wljs.io/frontend/Guides/Migration

Any .nb (Mathematica Notebook) is, in principle, automatically converted with some compromises, of course. We're still improving this! Hope this guide helps you, or your LLM buddy 🙂

Here is another link.

Not a "MATLAB bad" post. The original code is solid and I replicate it bug-for-bug by default. Sharing the trap list for anyone migrating numerical code: round() half-away-from-zero vs numpy's round-half-to-even (inside the nmax series formula, so it changes array lengths), complex auto-promotion that NumPy doesn't do, ' vs .', library functions printing to stdout, and a docstring feature (complex medium index) that turns out to be latently broken. Full findings file, 714-fixture corpus and the verification report: https://github.com/GrednevMSU/mie-scattering-matlab-to-python

Yeah