Y combinator

cr7

Eli Bendersky ha un blog che seguo da sempre. Oggi –ahemm qualche giorno fa– posta questo: Some notes on the Y combinator. Roba che ho letto quando era già sera, non ho capito tanto (ahemmm niente, nada, zilch) e me lo sono sognato tutta la notte.
Non so se avete idea di quale possa essere la personificazione (incubosa) di Y? Credo di no. E non chiedetemi di raccontarvela; diciamo che al mattino vi sentite un po’ come ci si sente in questi tempi pre-referendum😦

Eli rockz (al solito) e parte con il link alla Wiki, ottimo (al solito).
Ma a me, per la mia storia & sono vecchio (auto-cit.) viene subito una domanda, forse solo mia, forse peregrina, forse senza senso, forse troppo ovvia, ma in ogni caso questa: “serve? quando si usa?“. Notare che non metto in discussione che si possa usare, mica mi metto contro Haskell Curry, Eli, et al. (notare che per l’occasione uso anche l’Oxford comma, solo questa volta).

Eli svolge in dettaglio tutta la lezione. Come si usa in questi casi parte con il Lisp, cioè un dialetto della famiglia, uno che ultimamente è di moda (perso non conosco nessuno che lo usi, ma non conosco neanche chi usi un Lisp).

Clojure (ecco, sa quello) è immediato (quasi) per il lisper anche niubbo (come me). Ad esempio la funzione factorial-rec di Eli:

(defn factorial-rec [n]
  (if (zero? n)
    1
    (* n (factorial-rec (- n 1)))))

in Racket diventa:

(define [factorial n]
    (if (zero? n)
        1
        (* n (factorial (- n 1)))))

C’è solo una una keyword che cambia nome (defn invece di define) e una parentesi spostata!
Ricordo che () e [] sono intercambiabili; anche se nessun racketeer scriverebbe come qui sopra.
Passo-passo si arriva a Y combinator – a tool for making anonymous functions recursive.

Ah! capito (forse): è come lambda, una variante (super) di lambda😀
Se sono impreciso è perché fin lì ci arrivo, porta passiensa (auto-cit.).

Non ho riprodotto l’esempio con Clojure (dovrei reinstallarlo) ma ecco, con Racket:

(define Y
  ((lambda (f)
     (f f))
   (lambda (z)
     (lambda (f)
       (f (lambda (x) (((z z) f) x)))))))

(define factorial
  (Y (lambda (recursive-factorial)
       (lambda (x)
         (if (<= x 0)
             1
             (* x (recursive-factorial (- x 1))))))))

(print (factorial 1000))

1000 può sembrare grosso ma no, nope:

y0

Ho eseguito 5 run ottenendo per real 236, 196, 203, 250 e 194 ms.

Confronto con la versione ricorsiva liscia, questa:

y1

Il tempo di esecuzione è simile al precedente (e troppo piccolo per essere significativo), comunque ho rilevato 209, 207, 242, 191 e 200 ms.

Reindirizzando l’output su file posso poi confrontare i risultati

y2

ovviamente😀

Ma Eli va avanti: The Y combinator in Python.
Finally, just to show that the Y combinator isn’t something unique to the Lisp family of languages, here’s a Python implementation:

ycombinator = lambda func: \
    (lambda self: func(lambda n: (self(self))(n)))(
        lambda self: func(lambda n: (self(self))(n)))

factorial = lambda recurse: \
    lambda n: \
        1 if n == 0 else n * recurse(n - 1)

print((ycombinator(factorial)) (400))

y3

Velocissimo per n non troppo grande altrimenti

y4

che finisce con

y5

Sì dice sempre Eli It’s even possible to create the Y combinator in C++. Static typing makes it somewhat less elegant than in the more dynamic languages, but C++14’s generic lambdas help a lot.

Resta la mia domanda iniziale, serve?
Ci ho googlato su un po’, trovato un esempio in JavaScript, suggerimento If you’re ready for a long read, Mike Vanier has a great explanation collegato a un riassunto commendevole: long story short, it allows you to implement recursion in a language that doesn’t necessarily support it natively. Tutto qui.

Trovata anche la risposta (l’altra non quella universale (42)): How are Y combinators used in practice?
They are not used in practice. They are nice theorical tool to provide recursion in a language without built-in recursion. Because all practical programming languages supports recursion natively, there is no use for Y.
Già detto che Quora rockz! :grin:?

OK, caso chiuso (?)😀

:mrgreen:

Voyager — post con un indovinello difficile

saturno

“Una volta, quando i vostri genitori andavano ancora all’asilo…”
“Tre computer con …”
“Qualcuno di di voi ha in tasca un computer più potente di quello. Non è il telefono, ma [indovina]”

Marco Bruno –ebbene sì lo conosco– rockz😀 assay, anzi di più,😀 racconta tutto questo e molto altro altro ancora di astronautica.

Attenti però che se aprite questo video poi ne avete per due ore. Non riuscirete a uscirne prima. Possono capitare anche ricadute, quello che sta capitando a me adesso.

Risposta alla domanda: trovate tutto a 12:50. Ma comincia prima, almeno da 8:30. Vero che vi ha sorpreso e non ve l’aspettavate?

Il video lo trovate su YouTube, il signor WordPress non lo prevede l’embed per la versione free:[AstronautiCON8] Le missioni Voyager.
Marco è über😀 forse l’ho già detto, a volte sono ripetitivo, sapete la mia memoria…


Siccome questo è un post impegnativo lo riciclo sull’altro blog. Cioè se voi lo leggete su Ok, panico sappiate che c’è anche Al Tamburo Riparato. E viceversa per i tamburisti.

Octave – Conclusione per adesso – 115

pop3
Ultime note (continuando da qui) poi passo ad altri argomenti e Octave lo riprenderò se (e solo se direbbe un mate) del caso😉

Il sito GNU Octave da cui ho copiato finora dovrebbe essere sempre a portata di browser.

In particolare ci sono due elenchi per chi ogni tanto si chiede “com’è già che si scrive…”. Qui ci sono gli operatori e qui tutte le funzioni.

C’è poi una funzione molto comoda, ne ho già parlato ma la ricordo: nella REPL (il terminale) scrivo doc matrix e ottengo

o631

sì tutto il manuale😀
doc usa curses, un layer sopra al terminale dal quale si esce con q (come quit).

A proposito io sono affezionato alla REPL che invoco con il comando octave -q --no-gui e del quale ho creato l’alias roc, quello che ho usato nei post precedenti.

o632

I ggiovani Gli utenti meno attempati di me preferiranno certamente l’ambiente integrato, richiamabile con Octave -q

o633

Ha i suoi vantaggi, c’è tutto a portata di click e posso copy-pastare più facilmente che dalla REPL (dove devo usare il tasto Ctrl), p.es:

o634

ed ecco pronto

>> 6 * 7
ans =  42
>> pwd
ans = /home/juhan/lab/octave/o-115
>>

Ctrl-L pulisce la finestra dei comandi, proprio come nel terminale.
Il comando doc continua a funzionare, meglio che nella REPL:

o635

apre uno o più tab (io ho dato il comando doc doc) gestibili con i pulsanti indicati dalle frecce rosse.

Questo è tutto. Non resta che provare, prenderci la mano, scoprire come usarlo, se con script complessi, quasi programmi tradizionali o in modo interattivo, immediato.
Un po’ per tutto:

o636

Una cosa ancora: il manuale usa scrivere le funzioni così:

>> log (10)
ans =  2.3026

io preferisco invece così:

>> log(10)
ans =  2.3026

Qualche C-ista potrebbe fare anche così:

>> log( 10 )
ans =  2.3026

Questione di gusti. Ah! negli script non dimenticate i commenti, #nèh!😀

:mrgreen:

Visto nel Web – 263

Ecco pronto il solito post su cosa ho wisto nel Web😀

cyhlsssweaayvxq

Learning to superoptimize programs
#:programming, codice, snippet
::: johnregehr

How the Trump Campaign Built an Identity Database and Used Facebook Ads to Win the Election
#:social media
::: Medium

After more than a year of writing, the Nim in Action manuscript is finished and has just went into production
#:linguaggi di programmazione
::: d0m96

Quit Social Media. Your Career May Depend on It
#:social media
::: The New York Times

Never mind the algorithms: the role of click farms and exploited #digitallabor in Trump’s election
#:social media
::: AntonioCasilli

gif

The Balanced Ternary Machines of Soviet Russia
un’occasione persa😦
Anna di dice: la macchina si scrive Сетунь con la “n” finale morbida e accento sulla prima sillaba. Il nome non si puo tradurre perchè è un toponimo cioè il nome di uno degli affluenti del fiume Moskva che attraversa la città Mosca. Hanno scelto questo nome perchè la facoltà universitaria dove avevano inventato la macchina si trovava vicino a questo affluente.
Grazie Anna ☺️ ✨ 💜 Servono traduzoni da e in russo?
#:storia
::: DEV ::: johnregehr

President Obama Says He Can’t Pardon Snowden
#:sicurezza, spionaggio, virus
::: Slashdot

#Orwell torna a casa
#:sicurezza, spionaggio, virus
::: tvsvizzera

This is an amazing demonstration of how computers work
#:hardware
::: mattgodbolt ::: glipari

Things to learn about Linux
#:manuali, how to
::: Julia Evans

cppv8zzusaedvmx

US Sets Plan To Build Two Exascale Supercomputers
#:innovazioni, futuro
::: Slashdot

“Haskell Tutorial and Cookbook”
free to read online
#:manuali, how to
::: EmreSevinc

We released mypy 0.4.6! ‘pip3 install mypy-lang’
#:linguaggi di programmazione
::: gvanrossum

ATM Hacks in ‘More Than a Dozen’ European Countries in 2016
#:sicurezza, spionaggio, virus
::: Slashdot

New paper suggests practical quantum computers are closer than we thought
#:innovazioni, futuro
::: MIT_CSAIL

cwg3ibuweaefd-i

Fedora 25 Now Available — Makes It Easier To Switch From Windows 10 Or Mac
#:sistemi operativi
::: Slashdot

The Case Against #Python 3
riporto; non concordo
#:linguaggi di programmazione
::: Donearm

“82% of middle-schoolers couldn’t distinguish between an ad labeled “sponsored content” and a real news story”
#:Web, Internet
::: fabiochiusi

Translating #maps into satellite images (and vice versa!)
#:programming, codice, snippet
::: miccferr

Let’s Encrypt Everything
#:sicurezza, spionaggio, virus
::: Coding Horror

cqejvfsuaaa-sdt

Tech Firms Seek To Frustrate Internet History Log Law
#:sicurezza, spionaggio, virus
::: Slashdot

Wow, I can’t believe @esa’s Schiaparelli Mars probe crashed because of integer overflow. Write tests people!
#:bug
::: astrofrog

Telegram Launches Telegraph, An Anonymous Blogging Platform
#:Web, Internet
::: Slashdot

Scientists Create Battery That Charges In Seconds and Lasts For Days
#:innovazioni, futuro
::: Slashdot

cx8vkl_xaaeatte

Debian is moving /bin, /sbin, /lib* being symlinks to their counterpart in /usr
#:sistemi operativi
::: ChicagoLUG

Meet the Pinebook, a $89 ARM Laptop That Runs Ubuntu
#:hardware
::: OMG! Ubuntu!

Right-Wing and Fake News Writers Are Now Going After Elon Musk
#:Web, Internet
::: Slashdot

App interattiva che mostra come funziona il prodotto tra due matrici
#:Web, Internet
::: daw985 ::: daw985

cyotaocviaabgjs-jpglarge

Having Fun With Functional Programming
#:programmazione funzionale
in’intro facile, chiara, completa😀
::: Medium

Character Encodings For Modern Programmers
#:storia
::: GT!Blog ::: GT!Blog

Edward Snowden Loses Norway Safe Passage Case
#:sicurezza, spionaggio, virus
::: Slashdot

Buttate via gli smartphone
#:Web, Internet
::: Siamo Geek

cat

Octave – E poi… – 114

grant-snider

Continuo da qui.

A questo punto se dovessi continuare come finora (ehi! quanti post, quanta roba, quante funzioni!) dovrei parlare di matrici diagonali e permutazioni delle stesse.

Che sarebbe tutto un argomento lungo, da trattare in più post. Ma sarebbe molto specifico e personalmente ho visto che i miei utenti di riferimento ormai hanno capito tutto e seguono il manuale invece dei miei post. No, qui ci sono esempi, anche loro, come visto di recente.

Allora basta; quasi. Per rendere meno traumatica la fine della telenovela ecco una scorsa a cosa mi perdo.

Dopo le matrici c’è il capitolo sull’integrazione numerica per una o più variabili: Octave comes with several built-in functions for computing the integral of a function numerically (termed quadrature).

Poi si passa alle equazioni differenziali: Octave has built-in functions for solving ordinary differential equations, and differential-algebraic equations.

Segue un capitolo su ottimizzazioni varie: Octave comes with support for solving various kinds of optimization problems. Specifically Octave can solve problems in Linear Programming, Quadratic Programming, Nonlinear Programming, and Linear Least Squares Minimization.
Sono argomenti che certamente interesseranno i miei contatti.

Il capitolo successivo tratta la statistica.
Per la statistica ci sono anche altri strumenti, da quelli semplicissimi (ma usati) come il foglio di calcolo tipo Excel (sì, mi auto-censuro ma di usa) a cose molto specialistiche R (ma non solo).

Poi seguono i sets: Octave has a number of functions for managing sets of data. A set is defined as a collection of unique elements and is typically represented by a vector of numbers sorted in ascending order. Any vector or matrix can be converted to a set by removing duplicates through the use of the unique function. However, it isn’t necessary to explicitly create a set as all of the functions which operate on sets will convert their input to a set before proceeding.
Vale lo stesso discorso per la statistica, imho.

Si arriva poi al trattamento dei polinomi: In Octave, a polynomial is represented by its coefficients (arranged in descending order). For example, a vector c of length N+1 corresponds to the following polynomial of order N: p(x) = c(1) x^N + ... + c(N) x + c(N+1).
Qui troviamo anche una funzione (in Finding Roots) simile a quella proposta dalle mie collaboratrici😀
Il capitolo è da studiare, come il successivo sull’interpolazione.

Specialistico il capitolo Geometry, roba di cui so molto poco (anzi niente).
E anche il successivo, Signal Processing.
Dubbi sulla gestione delle immagini dentro Octave, ma c’è tutto un capitolo.
Come pure c’è un capitolo relativo all’audio.

Il capitolo 34 rappresenta un altro problema per me. Object Oriented Programming.
Per quel che ho visto Octave viene usato interattivamente, usando funzioni predefinite e creandone nuove sempre (relativamente) semplici. Magari per utenti più esperti…
Lo stesso, con l’aggravante che davvero dubbioso se serva GUI Development. O sono solo io?

Le utilità di sistema del capitolo 36 a volte potrebbero essere utili; ma sono da valutare con l’uso interattivo di Octave.

o630

c’è molta roba ma non tutta per cui nel modo con cui si usa  –OOPS! già detto.

Specialistico e fuori dei miei interessi i capitoli Packages, External Code Interface e tutte le appendici che seguono.

Ahemmm… c’è ancora un po’ di cose, mi sa che c’è materiale per almeno un altro post…😉
:mrgreen:

Octave – Equazioni non lineari III – 113

twin-lakes-wisconsin

Continuo da qui, copio qui.

Ricerca di minimi (e massimi)

Often it is useful to find the minimum value of a function rather than just the zeroes where it crosses the x-axis. fminbnd is designed for the simpler, but very common, case of a univariate function where the interval to search is bounded. For unbounded minimization of a function with potentially many variables use fminunc or fminsearch. The two functions use different internal algorithms and some knowledge of the objective function is required. For functions which can be differentiated, fminunc is appropriate. For functions with discontinuities, or for which a gradient search would fail, use fminsearch. See Optimization, for minimization with the presence of constraint functions. Note that searches can be made for maxima by simply inverting the objective function (Fto_max = -Fto_min).

Function File: [x, fval, info, output] = fminbnd (fun, a, b, options)
Find a minimum point of a univariate function.
fun should be a function handle or name. a, b specify a starting interval. options is a structure specifying additional options. Currently, fminbnd recognizes these options: "FunValCheck", "OutputFcn", "TolX", "MaxIter", "MaxFunEvals". For a description of these options, see optimset.
On exit, the function returns x, the approximate minimum point and fval, the function value thereof.

info is an exit flag that can have these values:

  • 1 The algorithm converged to a solution.
  • 0 Maximum number of iterations or function evaluations has been exhausted.
  • -1 The algorithm has been terminated from user output function.

Notes: The search for a minimum is restricted to be in the interval bound by a and b. If you only have an initial point to begin searching from you will need to use an unconstrained minimization algorithm such as fminunc or fminsearch. fminbnd internally uses a Golden Section search strategy.

o627

Function File: fminunc (fcn, x0)
Function File: fminunc (fcn, x0, options)
Function File: [x, fval, info, output, grad, hess] = fminunc (fcn, ...)

Solve an unconstrained optimization problem defined by the function fcn.
fcn should accept a vector (array) defining the unknown variables, and return the objective function value, optionally with gradient. fminunc attempts to determine a vector x such that fcn (x) is a local minimum.
x0 determines a starting guess. The shape of x0 is preserved in all calls to fcn, but otherwise is treated as a column vector.
options is a structure specifying additional options. Currently, fminunc recognizes these options: "FunValCheck", "OutputFcn", "TolX", "TolFun", "MaxIter", "MaxFunEvals", "GradObj", "FinDiffType", "TypicalX", "AutoScaling".
If "GradObj" is “on”, it specifies that fcn, when called with two output arguments, also returns the Jacobian matrix of partial first derivatives at the requested point. TolX specifies the termination tolerance for the unknown variables x, while TolFun is a tolerance for the objective function value fval. The default is 1e-7 for both options.
For a description of the other options, see optimset.
On return, x is the location of the minimum and fval contains the value of the objective function at x.

info may be one of the following values:

  • 1 Converged to a solution point. Relative gradient error is less than specified by TolFun.
  • 2 Last relative step size was less than TolX.
  • 3 Last relative change in function value was less than TolFun.
  • 0 Iteration limit exceeded—either maximum number of algorithm iterations MaxIter or maximum number of function evaluations MaxFunEvals.
  • -1 Algorithm terminated by OutputFcn.
  • -3 The trust region radius became excessively small.

Optionally, fminunc can return a structure with convergence statistics (output), the output gradient (grad) at the solution x, and approximate Hessian (hess) at the solution x.
Application Notes: If the objective function is a single nonlinear equation of one variable then using fminbnd is usually a better choice.
The algorithm used by fminunc is a gradient search which depends on the objective function being differentiable. If the function has discontinuities it may be better to use a derivative-free algorithm such as fminsearch.

o628

Function File: x = fminsearch (fun, x0)
Function File: x = fminsearch (fun, x0, options)
Function File: [x, fval] = fminsearch (...)

Find a value of x which minimizes the function fun.
The search begins at the point x0 and iterates using the Nelder & Mead Simplex algorithm (a derivative-free method). This algorithm is better-suited to functions which have discontinuities or for which a gradient-based search such as fminunc fails.
Options for the search are provided in the parameter options using the function optimset. Currently, fminsearch accepts the options: "TolX", "MaxFunEvals", "MaxIter", "Display". For a description of these options, see optimset.
On exit, the function returns x, the minimum point, and fval, the function value thereof.

o629

:mrgreen:

cit. & loll – 19

Anche se piove ecco che arriva puntuale il solito post settimanale😉

accozzaglia

I have summed up our Instagram account as a JavaScript function
::: ThePracticalDev

Software testing types: Hammering nails
::: Google+

Google e Facebook, è guerra alle bufale: niente pubblicità per i siti di notizie false
::: ArsenaleKappa

Non Sequitur
::: GoComics

Command line advertising: coming to a terminal near you!
::: ThePracticalDev

cxzx0scxuaa21uo

Oslo airport: taxi for @Snowden?
::: arusbridger

In Unix there is a “man” command and a “cat” command… so why no “dog” command???
leggete anche il commento di Olaf😀
::: Google+

Debian Linux is the operating system used in most terminals in the International Space Station
::: fermatslibrary

DSSP was not invented. It was found.
::: johnregehr

cx7ox7txeaigmeu

POTUS awards Margaret Hamilton, who helped create software for NASA’s Apollo command modules, the Medal of Freedom
::: ABC ::: lenajfc ::: ThePracticalDev

Made a Windows Notepad clone, started as joke, keep adding to it
::: _le717

My Chrome is hungry, pls send more RAM
Firefox (for me) too.
::: ThePracticalDev

Artificial intelligence has arrived. We’re all doomed
::: joelcomm

gbdzay

Octave – Equazioni non lineari II – 112

nikon-small-world-cross-section-of-a-lily-of-the-valley

Continuo da qui, sempre su quanto detto qui, un approfondimento su fzero.

Ottima la fsolve (del post precedente) ma ho trascurato la nota:

Note: If you only have a single nonlinear equation of one variable, using fzero is usually a much better idea.

L’argomento interessa, da approfondire. Comincio con l’esempio precedente che usa fsolve, questo:

o613

usando fzero si può scrivere

o616

OK, bravo. L’idea viene dall’esercizio svolto qui. Da rifare:

o617

L’approssimazione è buona

o618

Racket nel post citato dava il valore (approssimato) 4.555532271, con la procedura fixed-point di SICP:

o619

Risulta quindi che fzero (e fsolve) funziona, con l’usuale approssimazione, molto migliore di quella usata praticamente (quando faccio i calcoli a mente per l’ordine di grandezza assumo π = 1 (non ditelo a nessuno)).

Sarebbe molto bello poter passare parametri alla F(x), così:

o620

😦 purtroppo no. Ma forse sono io che dimentico qualcosa:

o621

quindi provo fzero

o622

L’esempio era troppo banale, eccone uno più reale:

o623

È stata dura… (colpa mia). In pratica  si può usare così

o624

Ma c’è un passo ancora: mettere la funzione (con un nome più significativo, p.es. js3) nel file js3.m

function t = js3(x)
    global a;
    t = a(1) * x^3 + a(2) * x^2 + a(3) * x + a(4);
endfunction

Sarà così sufficiente dichiarare il vettore a in 2 tempi e chiamare fzero:

o625

Inoltre tutti –tranne me– usano l’ambiente integrato

o626

:mrgreen:

Octave – Equazioni non lineari I – 111

italy

Capitolo nuovo, qui proseguendo da qui.

Equazioni non lineari
È solo una pagina di smistamento, passo subito qui.

Risolutori
Octave can solve sets of nonlinear equations of the form F (x) = 0 using the function fsolve, which is based on the MINPACK subroutine hybrd. This is an iterative technique so a starting point must be provided. This also has the consequence that convergence is not guaranteed even if a solution exists.

Function File: fsolve (fcn, x0, options)
Function File: [x, fvec, info, output, fjac] = fsolve (fcn, ...)

Solve a system of nonlinear equations defined by the function fcn.
fcn should accept a vector (array) defining the unknown variables, and return a vector of left-hand sides of the equations. Right-hand sides are defined to be zeros. In other words, this function attempts to determine a vector x such that fcn (x) gives (approximately) all zeros.
x0 determines a starting guess. The shape of x0 is preserved in all calls to fcn, but otherwise it is treated as a column vector.
options is a structure specifying additional options. Currently, fsolve recognizes these options: "FunValCheck", "OutputFcn", "TolX", "TolFun", "MaxIter", "MaxFunEvals", "Jacobian", "Updating", "ComplexEqn", "TypicalX", "AutoScaling" and "FinDiffType".
If "Jacobian" is “on”, it specifies that fcn, called with 2 output arguments also returns the Jacobian matrix of right-hand sides at the requested point. "TolX" specifies the termination tolerance in the unknown variables, while "TolFun" is a tolerance for equations. Default is 1e-7 for both "TolX" and "TolFun".
If "AutoScaling" is on, the variables will be automatically scaled according to the column norms of the (estimated) Jacobian. As a result, TolF becomes scaling-independent. By default, this option is off because it may sometimes deliver unexpected (though mathematically correct) results.
If "Updating" is “on”, the function will attempt to use Broyden updates to update the Jacobian, in order to reduce the amount of Jacobian calculations. If your user function always calculates the Jacobian (regardless of number of output arguments) then this option provides no advantage and should be set to false.
"ComplexEqn" is “on”, fsolve will attempt to solve complex equations in complex variables, assuming that the equations possess a complex derivative (i.e., are holomorphic). If this is not what you want, you should unpack the real and imaginary parts of the system to get a real system.
For description of the other options, see optimset.
On return, fval contains the value of the function fcn evaluated at x.

info may be one of the following values:

  • 1 Converged to a solution point. Relative residual error is less than specified by TolFun.
  • 2 Last relative step size was less that TolX.
  • 3 Last relative decrease in residual was less than TolF.
  • 0 Iteration limit exceeded.
  • -3 The trust region radius became excessively small.

Note: If you only have a single nonlinear equation of one variable, using fzero is usually a much better idea.

Note about user-supplied Jacobians: As an inherent property of the algorithm, a Jacobian is always requested for a solution vector whose residual vector is already known, and it is the last accepted successful step. Often this will be one of the last two calls, but not always. If the savings by reusing intermediate results from residual calculation in Jacobian calculation are significant, the best strategy is to employ OutputFcn: After a vector is evaluated for residuals, if OutputFcn is called with that vector, then the intermediate results should be saved for future Jacobian evaluation, and should be kept until a Jacobian evaluation is requested or until OutputFcn is called with a different vector, in which case they should be dropped in favor of this most recent vector. Segue esempio che non riporto.

The following is a complete example. To solve the set of equations

-2x^2 + 3xy + 4 sin(y) = 6
3x^2 - 2xy^2 + 3 cos(x) = -4

you first need to write a function to compute the value of the given function

o611

Then, call fsolve with a specified initial condition to find the roots of the system of equations. For example, given the function f defined above,

o612

A value of info = 1 indicates that the solution has converged.

Vediamo se ho capito…

o613

😀

When no Jacobian is supplied (as in the example above) it is approximated numerically. This requires more function evaluations, and hence is less efficient. In the example above we could compute the Jacobian analytically as

o614

Function File: fzero (fun, x0)
Function File: fzero (fun, x0, options)
Function File: [x, fval, info, output] = fzero (...)

Find a zero of a univariate function.
fun is a function handle, inline function, or string containing the name of the function to evaluate.
x0 should be a two-element vector specifying two points which bracket a zero. In other words, there must be a change in sign of the function between x0(1) and x0(2). More mathematically, the following must hold sign (fun(x0(1))) * sign (fun(x0(2))) <= 0.
If x0 is a single scalar then several nearby and distant values are probed in an attempt to obtain a valid bracketing. If this is not successful, the function fails.
options is a structure specifying additional options. Currently, fzero recognizes these options: "FunValCheck", "OutputFcn", "TolX", "MaxIter", "MaxFunEvals". For a description of these options, see optimset.
On exit, the function returns x, the approximate zero point and fval, the function value thereof.

info is an exit flag that can have these values:

  • 1 The algorithm converged to a solution.
  • 0 Maximum number of iterations or function evaluations has been reached.
  • -1 The algorithm has been terminated from user output function.
  • -5 The algorithm may have converged to a singular point.

output is a structure containing runtime information about the fzero algorithm. Fields in the structure are:

  • iterations Number of iterations through loop.
  • nfev Number of function evaluations.
  • bracketx A two-element vector with the final bracketing of the zero along the x-axis.

:mrgreen:

SICP – cap. 1 – procedure come metodo generale – esercizio – 46

14344

Continuo da qui con il prossimo esercizio, qui.

Exercise 1.36.  Modify fixed-point so that it prints the sequence of approximations it generates, using the newline and display primitives shown in exercise 1.22. Then find a solution to xx = 1000 by finding a fixed point of x log(1000)/log(x). (Use Scheme’s primitive log procedure, which computes natural logarithms.) Compare the number of steps this takes with and without average damping. (Note that you cannot start fixed-point with a guess of 1, as this would cause division by log(1) = 0.)

Mi sa che –al solito– seguo Bill, mio tutor virtuale, presente anche su Twitter.
Serve average, come già definita in passato:

(define (average x y)
  (/ (+ x y) 2))

fixed-point resta come quella dell’esecizio (e post) precedente con il solo inserimento delle 2 istruzioni indicate con ;; *** mod.

(define tolerance 0.00001)
(define (fixed-point f first-guess)
  (define (close-enough? v1 v2)
    (< (abs (- v1 v2)) tolerance))
  (define (try guess)
    (display guess)   ;; *** mod
    (newline)         ;; *** mod 
    (let ((next (f guess)))
      (if (close-enough? guess next)
          next
          (try next))))
  (try first-guess))

La sola istruzione nuova è (fixed-point (lambda (x) (/ (log 1000) (log x))) 2.0).

s98

Non fa parte di SICP ma un paio di considerazioni relative all’ambiente Linux (vs. quell’altro di cui non riesco a ricordare il nome).
Eseguo una verifica rapida della bontà del risultato.
Il tool bc in genere ottimo qui si dimostra insufficiente:

s99

OOPS!😳 l’esponente dev’essere intero, vedi p.es. qui:

expr ^ expr
The result of the expression is the value of the first raised to the second. The second expression must be an integer. (If the second expression is not an integer, a warning is generated and the expression is truncated to get an integer value.) The scale of the result is scale if the exponent is negative. If the exponent is positive the scale of the result is the minimum of the scale of the first expression times the value of the exponent and the maximum of scale and the scale of the first expression. (e.g. scale(a^b) = min(scale(a)*b, max(scale, scale(a))).) It should be noted that expr^0 will always return the value of 1.

Per valutazioni al volo il mio tool preferito resta Calc:

s100
😀 buono vero? Una cosa OT ma è saltata fuori recentemente: attenzione alla funzione log(): non è sempre la stessa per tutti i linguaggi e può generare confusione:

s101

uh! dimenticavo Python

s102

dove, ovviamente

s103

:mrgreen: