From J Wiki
Jump to navigation Jump to search

The j807 beta cycle started in mid Feb 2018. The j807 stable release was available Oct 8 2018.

For installation, see Installation.

Changes to the J engine

J807 release-d maintenance release of 20190318, fixes the following bug:

  • sort of floating-point lists shorter than 3000 atoms long was slow

J807 release-c maintenance release of 20190224, fixes the following bugs:

  • Crash on non-AVX systems in members of the i.-family when the item was an array with more than one atom and a length of 2 or 8 bytes
  • Incorrect type of empty result sometimes when u;.1 etc had no frets
  • Crash sometimes when a recursive explicit definition executed return. inside a select. or for.

J807 release-b maintenance release, fixes the following bugs:

  • Crash when hook/\ or fork/\ executed
  • Error in processing D.
  • Loop in x ;: y when state machine very short
  • Memory corruption in f\ when result of f had different shape from {:y
  • Memory corruption in x ;.3 y when y is an indirect datatype and x has more than 1 column
  • Incorrect results during partitioning modifiers (such as [x] u"n y) when an argument cell was made the base of a virtual block and then later modified in place

J807 release

  • x +/@:*"1 y is now supported as a primitive with Integrated Rank Support. The new version is 2x faster than before on long vectors, 4x on sets of 60-long, 20x on sets of 6-long. Details here
  • x +/@:* y faster on floating-point arguments
  • [x] ".@'name' y improved. This is the best way to defer the evaluation of (name) until a verb is executed.
  • 7 o. y faster
  • x p. y improved. Does not scan y for infinities, supports inplace operation, has integrated rank support, and has special cases for linear, quadratic, and cubic polynomials
    • coefficient-form polynomials now give an infinite result (rather than NaN error) for an infinite argument, with the sign of the infinity chosen based on the coefficients.
  • Rank-0 loops over arguments rewritten to use the new result-assembly code and virtual blocks. These loops include u"0 and u@v, u&v, and u&.v, and the system names each and every.
    • Boxing overhead is avoided for the following forms. These are now as fast as u&.> was in earlier versions (for unboxed arguments, they are faster because they avoid an initial step of boxing the arguments):
      • <@f
      • f@>
      • f&.>
      • <@(f@>)
      • f&.>
      • (<@:f)@>
      • (<@f)@> when the rank of f is infinite
      • and also the above when @ is replaced by &
    • If u is one of the forms above that opens its argument, and v is a form that boxes its result, the compounds u@v and u&v can pass virtual blocks from v to u.
  • u&.v now calculates the inverse immediately if it does not contain names (previously it waited until receiving the verb arguments). u^:_1 behaves similarly, for the monadic valence only.
    • if u or v contain names, you can use f. on either that argument or the whole compound to remove the names
    • erroneous inverses, like +&.i. and i.^:_1, are detected earlier
  • x u/. y recoded yet again to collect input cells faster
  • 6!:3 y has millisecond accuracy on all systems

J807 beta-g

  • Name search rewritten. Will make a difference for programs with long search paths

J807 beta-f (withdrawn, do not use; the changes are in beta-g)

Incompatible change

  • If you use a synonym for the Cap verb ([:), the synonym must be defined before it is used to create a capped fork.

Work Done for This Beta

  • x u/. y recoded to collect input cells faster
  • The result of an explicit definition can be operated on in place (provided the value was not assigned to a name within the explicit definition)
  • u/ y, [x] u"r y, x u/. y, and [x] u;._2 _1 1 2 y allow inplace operation of u on cells of inplaceable arguments
  • ,/"r y (merge two axes of y) produces a virtual result
  • u/\. y uses virtual blocks and the new Result Assembly. Special forms detected are:
    • <@f/\. y
    • <@f/\ y
    • forms using raze:
      • ;@:(<@f/\.) y
      • ;@:(<@f/\) y
  • u/ y uses virtual blocks for the cells
  • Startup overhead for atomic dyads (+ * % etc) reduced by almost 50%. Noticeable for small arrays.
  • x (<"1@[ { ]) y, which avoids boxing x, is faster if x is nonnegative (almost 2x improvement for y with integer atomic cells). This is the fastest way to scatter-read from an array.

J807 beta-e

  • Features no longer supported
    • Mapped boxed arrays
    • Old-style argument names x. y. u. v. m. n.
  • Work Done for This Beta
    • Cuts u;._2 _1 0 1 2 use virtual blocks and the new RA code. Generally faster, especially for homogeneous non-boxed results, and for u in the form <@f.

      x f;.0 y is now as fast for any f as it used to be for ];.0

    • x f;.0 y uses a virtual block whenever x has 1 column, regardless of the rank of y
    • Prefix and infix ([x] f\ y) use virtual blocks and the new RA code
      • _2 f/\ y is now supported by special code, like 2 f/\ y
    • New case added to the i.-family: x i. y where the rank of an item of x is no less than the rank of y. Uses sequential search rather than hashing: about 2x faster, if there are few searches. Previous versions recognized this situation only when y had rank<2.
    • raze (; y) is detected in some partitioning compounds and processed more efficiently:
      • ;@:(<@v)
      • ;@:(<@v"r)
      • ;@:(<@:v;.0) also &:
      • ;@(<@:v;._3 _2 _1 1 2 3) also &:
      • ;@:(<@f\)
      • 2 ;@:(<@(f/)\) y also _2
        • If the raze is omitted, the rest of the form is still detected for faster processing
    • Transpose ([x] |: y) polished, about 3x faster for arrays that fit in L2 cache (e. g. integer matrices up to 200x200), 20% faster for large arrays
    • Virtual Blocks and Recursive Usecounts are now available for extended-numeric and rational precisions

J807 beta-d

  • cd is changed to avoid troubles arising from virtual blocks
  • more primitives produce virtual blocks:
    • , y
    • x ($,) y when the atoms of y are not repeated and there is no fill
    • x $ y when the atoms of y are not repeated and there is no fill
    • x { y when x is unboxed and the selection returns an array of contiguous atoms of y
  • Code for Result Assembly (RA) is being consolidated. This is the code that collects the results of execution on multiple cells into a single result array with framing fill. Versions of this code with differing levels of sophistication have been scattered around the JE. As primitives are modified to support virtual blocks, they are being upgraded to use the new common RA code. The new code for RA has the following features:
    • never executes a verb on a cell more than once (some of the former RA code restarted the whole execution of a primitive if a result did not match the shape/type/precision of the first result)
    • handles changes of precision without falling back to the code for dissimilar shapes
    • fills results of dissimilar shapes without copying fill to the entire result area first
    • creates boxed results as having recursive usecounts, which are more efficient
    • detects verbs that always produce an atomic box (<@:f for example) and avoids boxing each individual result of f
    • allows relaxation of virtual-block restrictions when the result of the operation feeds into a primitive that immediately opens it (; y, > y, &.> (each), @> (every))
    • frees intermediate memory blocks as quickly as possible
  • New RA code is used in
    • [x] u"r y
    • [x] f@g y
    • [x] f&g y
      • the main RA loop for dyadics is quadruply-nested. Sequences of u"r, f&g, and f@g are consolidated where possible to minimize the number of RA operations required.
    • IRS support within the JE
    • [x] u;.3 y and [x] u;._3 y
  • [x] u;.3 y and [x] u;._3 y are completely rewritten to use virtual blocks for the subarrays. Much faster on general arguments.
    • incompatible change: Previously, if the number of columns of x was less than the rank of y, x was extended with columns that selected the axis in full and these added axes appeared in the shape of the result. Now the new axes do not appear in the result-shape.

J807 beta-b

  • Virtual blocks introduced, whereby the result of a block may reside within another block. The result must be copied to a real block if it is assigned to a name or put into a box.
  • Virtual blocks used in:
    • {. y
    • {: y
    • }. y
    • }: y
    • atom {. y
    • atom }. y
  • JGetR gets JDo formatted output. Used in new addons/api/python3.

J807 beta-a

  • reworked memory allocator to allow for virtual blocks
  • smaller header makes better use of cache lines
  • Foreigns 9!:48 and 9!:49 (allow use of old names x. y. etc) removed

Changes to the base system

  • Update regex to PCRE2 with standard (not POSIX) interface. This also fixes multiline bugs that had been reported. Documentation at Regular Expressions.
  • Move most of the Help|User Manual to the wiki.

Changes to the Qt IDE

For Qt IDE 1.7.7 or later.

  • fix segfault on exit on some linux systems
  • add support for case-sensitive drives and folders in Windows, see Windows case-sensitive
  • add QWebChannel support for webview (full Qt 5.6 or later), see demo at Help|Studio|Showcase|webview
  • add webview load event (full Qt 5.6 or later)
  • add Form resize event
  • add edit control textchanged event
  • add wd 'pmoves [x y w h]' (to save/restore form position and size, see pmoves
  • add wd 'sm profont {fontspec}' command to set proportional font
  • add TabWidth config option
  • add CursorWidth config option to set cursor width in session windows
  • add open image and pdf files from editor
  • add menu item show|hide
  • add set backgroundcolor for webview
  • add listbox drag and drop, see Help|Studio|Qt Demos|drag and drop
  • add support for themes, see Help|Studio|Qt Demos|theme for an example with the dark theme
  • add Open in File Manager and Open in Terminal to the Edit|Project menu, both starting in the current project directory
  • enable add new tab (with no contents)
  • enable HighDpiScaling on Windows
  • improved textview, with zoom/line numbers/full screen/word wrap, see Ctrl+H in a textview window
  • support external links in static controls