I noticed it has to do with the 0=y testing in S. Instead of producing a zero at a certain point it gives a small value 4.4....e_16 and then starts filling theĀ  stack.

Op 11-04-18 om 22:05 schreef Jose Mario Quintana:
You might like to look also at Arie Groeneveld's message,

[Jprogramming] Crash calculating large hyper operations
http://www.jsoftware.com/pipermail/programming/2015-November/043351.html

Unfortunately, running on the latest stable release,

    JVERSION
Engine: j806/j64nonavx/windows
Release: commercial/2017-11-06T10:01:33
Library: 8.06.09
Qt IDE: 1.6.2/5.6.3
Platform: Win 64
Installer: J806 install
InstallPath: j:/program files/j
Contact: www.jsoftware.com

the following,

S=: 1 :0
:
if. 0= y do. 0
   else. 'q r'=. (0,m) #: y
         ( r *(1+m) ^ (0 (m S) x)) + (1+x) m S q
end.
)

G=: (>:@[ $: _1+ 4 : '0 (x S)y')`[@.(0=])

2 G"0 i.4

now produces a crash ("J has stopped working") instead of,

2 3 5 7

As far as I can see, the code should run on J804 but I do not know if it
runs on J805 (or on the latest and greatest j807).

Anyway, in theory, 2 G"0 i.5 should include the additional number,

_1 + 3 * 2 ^ 402653211x

in practice, of course, it cannot (even trying to execute the sentence _1 +
3 * 2 ^ 402653211x produces a limit error).



On Wed, Apr 11, 2018 at 9:15 AM, 'Jon Hough' via Programming <
programm...@jsoftware.com> wrote:

My first answer was actually comletely wrong, and only works for the
simplest cases. This is a more robust and correct solution

goodstein=: 4 : 0"0 0
if. y = x do.
   x+1 return.
elseif. y = 0 do.
   0 return.
end.
s=. I. x (|.@:((>:@:>.@:^. # [) #: ])) y
d=. (x+1) ^ (x:x) goodstein x: s
+/d
)

G=: <:@:goodstein

NB. generates sequence
genSeq=: 3 : 0"1
'base val its'=. y
c=. 0
vals=. val
whilst. its > c=. c+1 do.
   val=. base G val
   vals=. vals,val
   base=. base+1
end.
vals
)

genSeq 2 4 10
  4 26 41 60 83 109 139 173 211 253 299

genSeq 2 19 3
  19 7625597484990 134078079299425970995740249982
058461274793658205923933777235614437217640300735469768018742
98166903427690031858186486050853753882811946569946433649006084099
191101259794547752035640455970396459919808104899009433713951
27892465205302426158030...


--------------------------------------------
On Wed, 4/11/18, 'Jon Hough' via Programming <programm...@jsoftware.com>
wrote:

  Subject: [Jprogramming] Goodstein Sequences and Hereditary base-n notation
  To: "Programming Forum" <programm...@jsoftware.com>
  Date: Wednesday, April 11, 2018, 5:14 PM

  Goodstein's theorem: https://en.wikipedia.org/wiki/Goodstein%27s_theorem
  This states  that every Goodstein
  sequence eventually terminates at 0.
  The wikipedia page defines Goodstein
  sequences in terms of Hereditary base-n notation
  one such sequence is 4,26,41,60...

  Copying verbatim from wikipedia:
  ==============
  The Goodstein sequence G(m) of a number
  m is a sequence of natural numbers. The first element in the
  sequence G(m) is m itself. To get the second, G(m)(2), write
  m in hereditary base-2 notation, change all the 2s to 3s,
  and then subtract 1 from the result. In general, the
  (n + 1)-st term G(m)(n + 1) of the Goodstein
  sequence of m is as follows:

  Take the hereditary base-n + 1
  representation of G(m)(n).
  Replace each occurrence of the
  base-n + 1 with n + 2.
  Subtract one. (Note that the next term
  depends both on the previous term and on the index n.)
  Continue until the result is zero, at
  which point the sequence terminates.
  ===============

  The sequences take an impossibly long
  time to terminate for most inputs, so there is no use
  writing a verb that iterates until convergance. This is my
  verb that will calculate the first N elements of the
  sequence,
  starting with a given base and val. the
  base should start at 2, to conform to the above definition.


  goodstein=: 3 : 0
  'base val its'=. y
  vals=. ''
  c=: 0
  whilst.its> c=: c+1 do.
    if. val = 0 do. vals return.
    else.
      t=: ((1+
  >.base^.val)#base) #: val
      if. base < # t do.
        if. 0 < base {
  |.t do.
          tr=: 0
  (base}) |.t
          if.
  (base+1) < # tr do.
            ts=:
  (1+(base+1){tr) ((x+1)}) tr
            ts=:
  |.ts
          else.
            ts=:
  tr,1
            ts=:
  |.ts
          end.
        else. ts=: t end.
      else.
        ts=: t
      end.
      val=. <:(base+1) #.
  ts
      vals=. vals,val
      base=. base+1
    end.
  end.
  vals
  )



  NB. example
  goodstein 2 4 9
  26 41 60 83 109 139 173 211 253
  NB. continues to very large numbers.

   goodstein 2 3 5
  3 3 2 1 0   NB. terminates after 6
  iterations

  Is was hoping the goodstein verb could
  be defined tacitly, but my verb is clearly a bit of a mess.
  Just for fun, any elegant solutions?

  Thanks,
  Jon
  ----------------------------------------------------------------------
  For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm

----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm

----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm

Reply via email to