What's New in Frink

Documentation * FAQ * Download * Frink Applet * Web Interface * Sample Programs * Frink Server Pages * Frink on Android * Donate

Get Notified

Frink follows a rapid release schedule and is updated often. That doesn't mean that old programs will be invalidated, but that new, useful features and optimizations are added all the time.

While this page is the most detailed and constantly-updated source of information about changes in Frink, I also announce new features on Twitter at @frinklang. If you want to follow Alan's personal ramblings for some reason, those are on Twitter at @aeliasen.

2024-11-30

• Added string functions startsWith[string, prefix], startsWith[string, prefix, startPos], and endsWith[string, suffix] to test if a string starts or ends with the specified substrings. For more information, see the Substrings section of the documentation.
• Added a couple algorithms to Graph.frink
  • countConnected[startNode] which simply counts nodes connected to the specified node.
  • shorten[] which simplifies a graph that has lots of long runs (like a maze with long hallways) to only include the decision points. This greatly simplifies finding shortest paths in some instances.

2024-11-10

• Released a new version of Frink: The Next Generation (version 2024-11-10). This merges all changes from the main branch.

2024-11-08

• Rewrote the code for U.S. historical currency conversions to handle the new, even sillier changes in the file here. The maintainers of the site changed the efficient, easily-parsed text file into a useless HTML file that is 10 times larger and will cost everyone more time and money to download. And now only half of the table is populated by JavaScript for some weird reason. They said this is "to make the table more accessible for our users."

2024-10-24

• Updated the Deducer framework which helps you write a program to deduce information and solve puzzles. The change is one new method on DeducerMove that can be implemented to enable smarter guesses. The classes wordleDeducer.frink, nerdleDeducer.frink, and mastermindDeducer.frink have been updated to give smarter guesses.

2024-10-22

• Added a function nthPrime[n] which returns the nth prime number (indexed from 1, that is, nthPrime[1] returns 2 and nthPrime[2] returns 3.)
• Fixed the chunks function when there isn't even enough data to fill a single chunk.
• Released a new version of Frink: The Next Generation (version 2024-10-20). This merges all changes from the main branch.

2024-10-12

• Added Cache-Control headers to the output of Frink Server Pages to help break unwanted caching of pages (and especially graphics) whose output changes each time they are loaded even if there is no input.

2024-10-07

• Greatly reduced the memory usage and increased the performance of the charList function. It now uses a cache to efficiently return results.
• Released a new version of Frink: The Next Generation (version 2024-10-07). This merges all changes from the main branch.

2024-10-03

• Added joinstr function to join elements of an array with no space separating elements. This is equivalent to join["", array]

2024-09-29

• Added chunks functions to break an enumerating expression into a series of chunks of the specified size. See the Enumerating Expression Functions sections of the documentation for more.

2024-09-27

• Added a new function byColumns[array of int] which allows you to easily sort a multi-dimensional array based on multiple columns. That is, if the first column compares equal, it then tries sorting by a second column, etc. For example, sort[list, byColumns[[0,1]]]. See the sorting section of the documentation for examples.
• Increased the performance and decreased the memory usage of the byColumn and byColumns functions.

2024-09-09

• Added function hypotenuse[array] to return the hypotenuse or Euclidean norm of an array of values. This also works with symbolic values.

2024-09-03

• Added experimental vectorized functions to add, multiply, divide, subtract vectors of numbers. Their behaviors might change so they're not documented yet.
• Released a new version of Frink: The Next Generation (version 2024-09-03). This merges all changes from the main branch.

2024-08-19

• Enhanced the sample program wordleDeducer.frink which plays or solves a Wordle puzzle. It now has four modes to play or solve the game. This uses the Deducer framework which helps you write a program to deduce information and solve puzzles.

2024-08-04

• New public constructors and lots of methods for ComplexArray and ComplexArray2D. These are not documented yet but are used in image transformations.
• Redesign of the internal security framework inheritance hierarchy.

2024-07-21

• Improved the performance of the function sqrtNearestInteger[x].
• Released a new version of Frink: The Next Generation (version 2024-07-21). This merges all changes from the main branch.

2024-07-16

• Added a function sqrtNearestInteger[x] which is a fast function that takes a non-negative integer and returns the largest integer less than or equal to the square root of x.
• Released a new version of Frink: The Next Generation (version 2024-07-16). This merges all changes from the main branch.

2024-07-11

• The lexicalSort and lexicalCompare functions now compare the elements of sub-arrays to help sort them. For example, [1,2,3] sorts before [2,1,3].

2024-07-05

• Fixed inputForm output formatter for some multi-line anonymous functions, especially those containing a single if statement.

2024-07-01

• Functions that request data from HTTP and HTTPS URLs will now try to request that the remote server performs compression when possible. This possibly helps mitigate the new, larger U.S. historical currency conversion file, but should help all compressible HTTP requests. This includes functions like read, lines and readLines when called with an HTTP or HTTPS URL.
• Released a new version of Frink: The Next Generation (version 2024-07-02). This merges all changes from the main branch.

2024-06-30

• Rewrote the code for U.S. historical currency conversions to read from a new location, specifically here. The maintainers of the site changed the efficient, easily-parsed text file into a useless HTML file that is 10 times larger and will cost everyone more time and money to download. They said this is "to make the table more accessible for our users."
• Made a fix to reallow reading URLs from internal resources in the .jar file, even when in restrictive security mode.
• Released a new version of Frink: The Next Generation (version 2024-06-30). This merges all changes from the main branch.

2024-06-29

• The image.ANSI[columns=60] methods to display an image as ANSI graphics has been improved to not widen an image beyond its original width (which might make way-too-long images if the original was tall and narrow.)
• Added a sample program, lsim.frink which allows you to display the (low-res) contents of images in a text window that has ANSI full-color graphics compatibilty (e.g. most any modern Linux terminals, ConnectBot on Android, etc). It's like the ls program (which lists files) but displays the contents of images in a command terminal! This is very useful for someone who works on the command-line.
• Fixed the calculation of the bounding box for a supertoroid in frink.graphics.VoxelArray.makeSupertoroid when rx != ry. See Frink's 3-D routines for more.
• Added a sample program, supertoroidTest.frink, which generates arbitrary supertoroids for 3-D printing. This can make any kind of smooth ring-shaped object you can imagine (and more!)

2024-06-24

• Added graphics.ANSI[columns=60] and image.ANSI[columns=60] methods to display a graphics object or an image as ANSI graphics. The terminal must support true-color ANSI and Unicode block characters. This allows you to preview a graphic even over an SSH connection with no graphics capability.

2024-06-06

• Added method image.toColorChannels[] to turn an image into an array of 4 ComplexArray2D objects representing the red, green, blue, and alpha channels of an image. The class returned may change in the future. This array can be turned back into an image using the constructor new image[array].

2024-05-14

• Added more restrictions on accessing URLs when restrictive security is enabled (e.g. the eval function). All URLs are now restricted (previously, some types were allowed, while file URLs have always been restricted.)
• Added functions nth0[expr, index] and nth1[expr, index] which return the nth item of a list. nth0 treats the first element as element 0, while nth1 treats the first element as element 1. nth0 was formerly called nth which is still there but deprecated.

2024-05-09

• Added built-in functions for calculating the mean (mean[list]), mean and standard deviation (meanAndSD[list, sample]), and mode(s) (modes[list]) of a list. These preserve units of measure and can even be used symbolically. See the Other Functions section of the documentation for details.
• The implementation of the function meanAndSD has been removed from several sample programs where it had been cut-and-pasted, as it is now part of Frink's built-in functions. This includes curveFit.frink, LeastSquares.frink, and statistics.frink.
• Released a new version of Frink: The Next Generation (version 2024-05-09). This merges all changes from the main branch.

2024-05-04

• Added image.circularBlur[radius] which performs a circular blur on an image and returns a new image.

2024-05-03

• Added a two-argument version of image.applyKernel[matrix, normalize]. The boolean argument normalize allows the user to specify if the brightness levels in an image will be normalized. If normalize is false, values outside the range 0 to 255 will just be clamped to fit in that range. This may result in a blank image! However, some implementations of, say, edge detect filters do not normalize their output and this allows results to look more like other implementations. If normalize is true, the ranges will be normalized to fit into the range 0 to 255, possibly decreasing contrast.
• Released a new version of Frink: The Next Generation (version 2024-05-03). This merges all changes from the main branch.

2024-04-29

• Added image.normalize[] to normalize the brightness levels of an image so that color brightnesses range from 0 to 255.
• Improved image normalization so that the normalization won't attempt to read from nor alter the alpha (transparency) channel.

2024-04-28

• Update to image.applyKernel[matrix]: After the image has been filtered, it previously underwent a normalization of the brightness of the channels so that they fit within the range [0,255]. That normalization process has been improved and modified. Previously, each color channel was normalized independently, which distorted relative colors (and made images "grayer".) Colors are now normalized in a way that preserves relative colors.

  Note: If the elements of the matrix sum to (approximately) 1, then the average brightness of each pixel in the result should be about the same as in the original image, and pixel values outside the range [0,255] will be clamped to that range instead of being normalized. This preserves the color range of most pixels. However, if the elements of the matrix do not sum to 1, the color channels will be normalized so that they fall within the range [0,255] so the result is displayable. The relative brightness of each color channel is now preserved so colors are less uniform and gray.

2024-04-21

• Fixed a "The frame is decorated" error that seems to be generated in newer versions of Swing if the background color is set multiple times.

2024-04-20

• Added precision-preserving negate[x] function.
• Added two different exponential fit functions to curveFit.frink. These allow you two different ways to fit an exponential curve to a data series.

2024-04-19

• Added a new convenience method, graphics.caption[text, align="bottom", angle=0 degrees] to add quick text to the specified side of a graphics object. align is optional but defaults to "bottom". If specified, align must be one of the following strings: "top", "bottom", "left", or "right" indicating the side of the graphic where the text will be placed. See the Graphics with Text section of the documentation for more information.

2024-04-15

• Added new arbitrary-precision implementations of the gamma, beta, erf, and erfc functions to ArbitraryPrecision.frink. These are much faster and more accurate than previous implementations. Note that they are orders of magnitude faster with Frink: The Next Generation.
• The previous implementations of these functions in GammaByParts.frink and Gamma.frink have been removed and should be considered obsolete.

2024-04-12

• Added a function factorUnits[unit] which factors a unit into a array of [scale, dimensions] where scale is a dimensionless number indicating a scale and dimensions is a unit with scale of 1 and the basic dimensions of the original unit.

2024-03-29

• Added a function digitLength[num] to return the number of decimal digits in a number. It works on floating-point numbers which makes it useful for arbitrary-precision functions.
• Greatly improved the arbitraryExp and arbitraryLn functions in ArbitraryPrecision.frink to be much faster and more accurate. This improves the performance of other arbitrary-precision functions such as arbitraryPow. This requires the digitLength function above.
• Released a new version of Frink: The Next Generation (version 2024-03-29). This merges all changes from the main branch.

2024-03-18

• The output of the methods[expr] function is now sorted.
• Added a general image.applyKernel[array2d] method to apply an arbitrary filter / kernel to an image and return a new image. See the Image Methods documentation for more.

2024-02-27

• Added image.edgeDetect[] which applies an edge detect filter to an image and returns a new image.

2024-02-26

• Added image.unsharpMask[width, amount] which performs an unsharp mask on an image (sharpening the image) and returns a new image. Amount is usually 1 for 100% sharpening, but can be lower or higher.
• Updated the final conversion factor for the British pound for 2023.

2024-02-24

• Added image.gaussianBlur[width] which performs a Gaussian blur on an image and returns a new image.

2024-02-06

• Fixed certain cases of VoxelArray.makeSupertoroid where the eccentricity of the smaller circle was a floating-point number that triggered numerical instability of the underlying algorithm. This often manifested as the inner part of the toroid not being rendered. See Frink's 3-D routines for more.

2024-02-03

• Added methods img.mirrorX[] and img.mirrorY[] to flip an image horizontally or vertically. See the images documentation for more.

2024-01-21

• Updated the sample program GeometricMedian.frink to find the point that minimizes the sum of the distances to other points.

2023-12-31

• Updated copyright dates for 2024. Happy New Year!
• Updated sanity checks to 2024 for economic routines.
• Updated calculations and predictions for deltaT for 2024. It is currently hardcoded to 69.175 s.
• Released a new version of Frink: The Next Generation (version 2023-12-31). This merges all changes from the main branch.

2023-12-28

• The sample programs LeastSquares.frink and Matrix.frink have been enhanced to allow units of measure in least-squares fits and QR decomposition. This is especially cool because it will derive and provide the correct units of measure for the coefficients!

2023-12-21

• Added allShortestDistances[startNode] algorithms to Graph.frink, which finds all possible distances from the start node to all reachable nodes.

2023-12-20

• Added Writer.printAndClose[expr] method to quickly write and close a file.

2023-12-10

• Added function allEqual[list, target] Returns true if all of the items in the EnumeratingExpression list are equal to target. See the Enumerating Expression Functions sections of the documentation for more.

2023-12-02

• Added string functions lastIndexOf[str, substr] and lastIndexOf[str, substr, startPos] . For more information, see the Substrings section of the documentation.

2023-11-27

• Added set methods .copyAndPut[value] and .copyAndRemove[value]. For more information, see the Sets section of the documentation.

2023-11-26

• Added algorithms for topological sort and all topological sorts to to Graph.frink, allowing you to create topological sorts or dependency graphs.
• Updated the sample program GraphTest.frink with tests of topological sort and all topological sorts.

2023-11-18

• Fixed the definition of the sverdrup. Thanks to Ken Mankoff for the report.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2023-11-13

• Added permutationCount[m,n] function which returns the number of permutations of m things being taken n at a time, with order being important. This is sometimes called "mPn". This is equivalent to m!/((m-n)!) but calculated efficiently by calling factorialRatio[m,m-n] internally.

2023-10-30

• Fixed a possible error in VoxelArray.makeSphere when coordinates were just so in Frink's 3-D routines.

2023-09-20

• Added getBitBool[num, bit] function to return the specified bit of an integer as a boolean value.

2023-08-18

• Added several functions for querying Unicode properties of characters and strings, for example, querying the Unicode block property. See the Unicode Properties section of the documentation for details.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2023-07-31

• Added new dimension names electric_resistivity with dimensions ( ohm m ) and its reciprocal electric_conductivity with dimensions 1 / (ohm m) for use of bulk properties of materials (which is relevant to the current "superconductor" discussion.)

2023-07-04

• The VoxelArray.union methods now allow you to pass in up to 1 undef argument in which case the non-undef object will be copied. This makes it easier to make unions of multiple objects. See Frink's 3-D routines.
• Added the sample program caltrops.frink to generate a caltrops for 3-D printing. Don't step on it.

2023-07-01

• Added a new, much more flexible planarEmboss method to Frink's VoxelArray class. These allow you to emboss a bitmap into the top of an object and add or remove from the surface of the object with variable depth based on the gray level of the pixels.. This lets, you, say, etch text or images or textures into an object. See Frink's 3-D routines. Also see the sample programs planarEmbossTest.frink for an example of its use.

2023-06-14

• The parseInt[str, base] function can now take an array (or other enumerating expression) of strings as input.

2023-06-12

• Fixed a problem in the jar file so the constraint solver classes could be constructed by name. Thanks to Hakan Kjellerstrand for the report.
• Added a new, much more flexible sphericalEmboss method to Frink's VoxelArray class. These allow you to "wrap" a bitmap around any object and add or remove from the surface of the object with variable depth based on the gray level of the pixels.. This lets, you, say, etch text or images or textures into an object. See Frink's 3-D routines. Also see the sample programs sphericalEmbossGrayTest.frink for an example of its use.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.
• Released a new version of Frink: The Next Generation (version 2023-06-12). This merges all changes from the main branch.

2023-06-11

• Added a new, much more flexible cylindricalEmboss method to Frink's VoxelArray class. These allow you to "wrap" a bitmap around any object and add or remove from the surface of the object with variable depth based on the gray level of the pixels.. This lets, you, say, etch text or images or textures into an object. See Frink's 3-D routines. Also see the sample programs cylindricalEmbossGrayTest.frink for an example of its use.
• Added an unzip function to seperate the columns of an array or other enumerating expression into seperate arrays.

2023-05-24

• Fixed some formatting in MathML.frink which raised a ConformanceException when formatting some multiplication and exponentiation expressions which had units with dimensions as their first argument.

2023-05-23

This is a large release that includes many improvements that couldn't be released without some internal infrastructure changes. Apologies for the delays.

• Added a first cut at a rudimentary Constraint Programming solver! This will be extended in the future. It is already able to solve some interesting constraint problems:
  • constraintAllDifferent.frink - Tests the allDifferent constraint.
  • constraintSudoku.frink and constraintSudokuTest.frink - Uses the allDifferent constraint to solve any Sudoku problem, no matter how difficult (and find all possible solutions if there are multiple solutions) in just a few lines of code.
  • constraintNQueens.frink - a solver for an arbitrarily-large N-queens problem.
  • constraintSorter.frink - demonstrates less than, greater than, equals constraints, etc.
• Added the MathML.frink library to format Frink expressions in "standard" mathematical notation using the MathML standard (including stuff like square root symbols, stacked fractions, raised exponents, etc.) MathML Presentation has been supported in Firefox for a long time and was recently added to Google Chrome.
• The amazing Frink system-of-equations solver and, to a lesser extent, the single-equation solver can now typeset equations in standard mathematical form using MathML and the above library! Just click the "MathML" button if your browser supports it!

  For example, see this quadratic equation solver.

• Added floodFill method to Frink's VoxelArray class. This allows you to fill an object and, say, compute its volume. See Frink's 3-D routines. Also see the sample program floodFillTest.frink for an example of its use.
• Added cylindricalEmboss and sphericalEmboss methods to Frink's VoxelArray class. These allow you to "wrap" a bitmap around any object and add or remove from the surface of the object where the pixels in the bitmap are dark. This lets, you, say, etch text or images into an object. See Frink's 3-D routines. Also see the sample programs cylindricalEmbossTest.frink and sphericalEmbossTest.frink for an example of their use.
• Added multiple coordinate transformations to Frink's graphics libraries. These allow you to convert between alt-azimuth, spherical, and cylindrical coordinates.
• The Matrix.frink sample program has added and improved algorithms for calculating many decompositions of matrices including QR decomposition and calculating least-squares fit to a system of equations, allowing you to perform a best-fit algorithm to a curve.
• Added sample programs LeastSquares.frink and LeastSquaresTest.frink to demonstrate fitting curves to arbitrary equations, and calculating the goodness of their fits.
• Added a fast version of Floyd's algorithm to Graph.frink, allowing you to calculate the lengths of all shortest paths between all nodes in a graph in an efficient fashion.

2023-03-18

• The initial value of all of the elements of a new Java array can be specified with the three-argument version of the function: newJavaArray[classname, length, initValue]

  This is much simpler than doing the same thing in Java, especially when initializing multidimensional arrays!

2023-02-10

• Added functions allSame[expr] and allDifferent[expr] functions to test if all the elements of an array or other Enumerating Expression are same or different respectively. See the Enumerating Expression Functions sections of the documentation for more.

2023-01-30

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.
• Updated final UK currency data for 2022.
• Refactored file-reading functions like read, readLines, and lines to allow reading from more Java data types including java.io.File, java.io.InputStream, and java.net.URL.
• Added getSymbolsAsSymbols[expr] function.

2023-01-05

• Added minmax[array] function to return the smallest and largest items in an array simultaneously. The return value is a two-item array [min, max]

2022-12-31

• Updated copyright dates for 2023. Happy New Year!
• Updated sanity checks to 2023 for economic routines.
• Updated calculations and predictions for deltaT for 2023. It is currently hardcoded to 69.164 s.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.
• Released a new version of Frink: The Next Generation (version 2022-12-31). This merges all changes from the main branch.
• Released a new version of the frink-tng.war file from Frink: The Next Generation (version 2022-12-31).

2022-12-13

• The International System of Units (SI) has been approved to have 4 new prefixes to extend beyond the yotta (10²⁴) and the yocto (10^-24). Frink now contains these prefixes in its standard data file:

  Factor	Name	Symbol
  1030	quetta	Q
  1027	ronna	R
  10-27	ronto	r
  10-30	quecto	q

  See Resolution 3 of the 27th CGPM (2022) (link opens in a new window) for more details.

2022-12-12

• Updated the new library for processing graphs (graphs in the graph-theoretical sense of an object with nodes and edges) called Graph.frink to have sanity checks for all of the findShortestPath... algorithms to ensure that the start node and end node are actually in the graph.
• In addition to the above, all of the findShortestPath... algorithms now reliably return undef if there is no path from the start node to the end node. Previously, they could loop forever or throw errors inside the methods.
• Updates to the Tree.frink sample library for tree manipulation and traversal include a dump method to print an indented text representation of a Tree's structure.

2022-12-08

• Important: Fixed a potential problem when calling from a class method to a function outside the class. In some cases, the class's internal variables could be accidentally modified. Please update as soon as possible.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.
• Released a new version of Frink: The Next Generation (version 2022-12-08). This merges all changes from the main branch.
• Released a new version of the frink-tng.war file from Frink: The Next Generation (version 2022-12-08).

2022-12-07

• Updates to the Tree.frink sample library for tree manipulation and traversal include a rename of fields from "value" to "name" and added a "data" field. Some functions have been renamed to avoid confusion.

2022-12-04

• array.transpose[] no longer fails on an empty array.
• Added knapsack.frink and knapsackTest.frink sample programs with solvers for various versions of the Knapsack Problems (which are about fitting the most valuable items into a knapsack of fixed capacity.)

  I have a feeling that the Advent of Code problems will have a knapsack-packing problem this year. Day 3 was about rucksacks...

• Updates to the Tree.frink sample library for tree manipulation and traversal include an API change for traversing trees.

2022-11-29

• The Matrix.frink sample program has added and improved algorithms for calculating many decompositions of matrices including QR decomposition and calculating least-squares fit to a system of equations, allowing you to perform a best-fit algorithm to a curve.

2022-11-20

• The Matrix.frink sample program has added and improved algorithms for calculating many decompositions of matrices including the Cholesky-Crout and Cholesky-Banachiewicz decompositions, and calculating transpose and conjugate operations.

2022-11-07

• Frink's web servers have been upgraded to much faster networking. Please let me know if you find anything that's not working.

2022-11-04

• Updated the definition of the unit gasoline to match U.S. EPA definitions for the MPGe (miles per gallon electric). The MPGe was defined to be the number of miles that can be traveled by an electric vehicle using 33.7 kWh of energy. This changes the energy density in the unit gasoline from 1.4e8 J/gallon (which is about 38.88 kWh/gallon) to 33.70 kWh/gallon.

  The previous definition may have been more accurate for very efficient combustion of gasoline, but this makes it match with EPA definitions and the MPGe. Please see the standard data file for more information about this change and to see current uncertainties and historical variations in the energy content of gasoline and other fuels.

• Added the MPGe and its synonym mpge (for symmetry with the existing all-lowercase mpg) to represent miles per gallon electric. This unifies the current definition of the unit gasoline to match the MPGe.

  For example,

  100 MPGe -> miles/(gallon gasoline)
100.0

2022-10-18

• The method array.shuffle[] now returns the shuffled array so methods can be chained.
• The trim[string] function can now be applied to arrays of strings.
• Improved the error message and removed an exception when trying to verify that a class implements an interface when the class implements no interfaces.

2022-10-17

• Added the array method array.get[index, altValue] which can be used to look up the value corresponding to the non-negative integer index or return the alternate value altValue if the array does not contain that index.

2022-10-10

• Updated sanity checks for Java 18 and 19.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-10-04

• Updated the new library for processing graphs (graphs in the graph-theoretical sense of an object with nodes and edges) called Graph.frink by fixing the breadth-first search algorithm (to use a queue instead of a stack) and adding a breadth-first traversal algorithm for user programs.

2022-09-28

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-09-18

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-09-12

• Added a readBytes[url] function to read to an array of byte.
• Made some (hopefully invisible) internal changes to the read function for better error-handling.
• Fixed three-argument function base64Encode[expression, encoding,lineLength] to work correctly when expression is a Java array of bytes and the encoding is undef.
• Released a new version of Frink: The Next Generation (version 2022-09-12). This merges all changes from the main branch.

2022-09-11

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-09-08

• Added getColumn and setColumn methods and functions for two-dimensional arrays. See the Column Operations section of the documentation for more details.

2022-09-04

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-08-31

• Updated the new library for processing graphs (graphs in the graph-theoretical sense of an object with nodes and edges) called Graph.frink with A* search.
• Updated the sample program GraphTest.frink with tests of A* search.

2022-08-28

• Updated the new library for processing graphs (graphs in the graph-theoretical sense of an object with nodes and edges) called Graph.frink with Prim's algorithm for finding a minium spanning tree and Kruskal's algorithm for finding a minimum spanning forest. This update also adds many new functions for iterating through edges in a graph and a copy constructor.
• Updated the sample program GraphTest.frink with tests of Kruskal's algorithm, and many improvements to readability of other tests.

2022-08-23

• Updated the new library for processing graphs (graphs in the graph-theoretical sense of an object with nodes and edges) called Graph.frink with the breadth-first algorithm for finding the shortest path in a graph that has all equal weights.
• Updated the sample program GraphTest.frink with tests of the breadth-first shortest-path algorithm.

2022-08-22

• Updated the new library for processing graphs (graphs in the graph-theoretical sense of an object with nodes and edges) called Graph.frink with the Bellmann-Ford algorithm for finding the shortest path in a graph that has negative weights for edges.
• Updated the sample program GraphTest.frink with a test of the Bellman-Ford shortest-path algorithm.

2022-08-19

• Added a new library for processing graphs (graphs in the graph-theoretical sense of an object with nodes and edges) called Graph.frink. This currently has algorithms to find shortest paths in a directed or undirected graph.
• The sample program GraphTest.frink demonstrates how to use Graph.frink to solve various problems such as mazes, adjacency matrices, and problems from various programming competitions.

2022-07-31

• Added functions mostCommon[vals] and leastCommon[vals] which are specializations of the countToArray[vals] that only return the most or least common item(s) in a collection. See the Enumerating Expression Functions sections of the documentation for more.
• Released a new version of Frink: The Next Generation (version 2022-06-09). This merges all changes from the main branch.

2022-07-25

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-06-30

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-06-11

• Added a missing class to the jar file.

2022-06-09

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.
• Released a new version of Frink: The Next Generation (version 2022-06-09). This merges all changes from the main branch.

2022-06-07

• Added columnize[array, columns] function which turns a one-dimensional array (or enumerating expression) into a two-dimensional array with columns number of columns. This can be used with the table formatting functions above to pretty-print a large array in columns for display. See the Formatting Tables section of the documentation for details.

2022-05-23

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-05-20

• Generalized more solvers to terms which contain both a cos[x]2 plus b sin[x]2 terms to the trignonometric solvers in solveTrigonometric.frink. These can now solve equations like cos[x]^2 - 13 sin[x]^2 = 10 tan[z/4].

2022-05-08

• Added more solvers to terms which contain both cos[x] and sin[x] terms to the trignonometric solvers in solveTrigonometric.frink.

2022-05-07

• Added a new Unicode character search sample Frink Server Pages page. This lets you search all Unicode character names for a pattern (specified as a case-insensitive regular expression.)
• Added a link to the amazing Frink system-of-equations solver to the Frink Server Pages document. Of all the things Frink has ever achieved, this solver is probably the pinnacle.

2022-05-05

• Updated links in the FAQ to more modern NIST Handbooks and fixed internal links in Special Publication 811. NIST Handbook 133 apparently supersedes NIST Handbook 44.
• Added paintAlongHull method to Frink's VoxelArray class. This allows you to move a tool along the hull of a 3-D object, adding or removing material from the object and making larger or smaller. This can be used to give a "rounded" shape and is similar to the Minkowski sum method in tools like OpenSCAD. See Frink's 3-D routines.
• Released a new version of Frink: The Next Generation (version 2022-05-05). This merges all changes from the main branch.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-04-27

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-04-18

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-04-01

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.
• Released a new version of Frink: The Next Generation (version 2022-04-01). This merges all changes from the main branch.

2022-03-16

• Added function URLDecode[str, encoding="UTF8"] to decode part of a URL.
• Added default encoding "UTF8" to the function URLEncode[str, encoding="UTF8"] to encode part of a URL.

2022-03-13

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.
• Added function lcm[array] which returns the least common multiple of an array (or enumerating expression) of integers.
• Added function gcd[array] which returns the greatest common denominator of an array (or enumerating expression) of integers.

2022-03-10

• The range operator can now take single-character strings as bounds:

  for c = "a" to "z"
   print[c]
abcdefghijklmnopqrstuvwxyz

  for c = "z" to "a" step -1
   print[c]
zyxwvutsrqponmlkjihgfedcba

2022-03-09

• Added a formatMatrixCompact function which can format a table with Unicode bracket characters making traditional matrix brackets surrounding it. This is smaller than formatMatrix. See the Formatting Tables section of the documentation for details.

2022-03-03

• Released a new version of Frink: The Next Generation (version 2022-03-03). This merges all changes from the main branch.

2022-03-02

• Fixed an issue in the cached currency file which caused currency conversions not to read from cache.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-02-21

• Updated Historical British Price Data for the final data for the year 2021.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-02-14

• Added a new constructor to construct a java.util.Comparator that uses a Frink function to perform the comparisons. See the Iterating over Java Collections section of the documentation for more.

2022-01-30

• Added method dict.get[key, altValue=undef] which be used to look up the value corresponding to the key or return the alternate value altValue if the dictionary does not contain that key. See the Dictionary Methods section of the documentation for more.
• Added samples of sorting dictionaries by key or value. See the Dictionary Methods section of the documentation for more.

2022-01-27

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2022-01-17

• Made an improvement to greatCircleMap.frink which draws world maps centered on your location. The names of the countries are now centered around the untransformed polygon, making country names closer to the edge of the map to be located better.

2022-01-11

• Fixed a null pointer exception in the nth function when requesting an item off the end of an enumerating expression.

2022-01-07

• Reverted the recent change to char[array] that changed its behavior by returning an array of separate characters.

2021-12-31

• Updated copyright dates for 2022. Happy New Year!
• Updated sanity checks to 2022 for economic routines.
• Updated calculations and predictions for deltaT for 2022. It is currently hardcoded to 69.294 s. USNO's servers that typically serve this information and predictions have been down for at least 27 months.
• Released a new version of Frink: The Next Generation (version 2021-12-31). This merges all changes from the main branch.

2021-12-23

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2021-12-19

• Made CoordinateTransformer3DFloat.IDENTITY public. This class was very useful in Advent of Code 2021 Day 19.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2021-12-11

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2021-12-04

• Added single-argument method dict.increment[key] which is similar to the two-argument dict.increment[key, increment] but which always increments by 1.

2021-11-29

• Released a new version of Frink: The Next Generation (version 2021-11-29). This merges all changes from the main branch.

2021-11-26

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2021-11-14

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2021-10-30

• Added multiple convenience methods for creating cylinders from frink.graphics.Point3DFloat objects in Frink's VoxelArray class. See Frink's 3-D routines.

2021-10-29

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2021-10-23

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2021-10-17

• Released a new version of Frink: The Next Generation (version 2021-10-17). This merges all changes from the main branch.

2021-10-14

• Added function toASCIIHigh[str] to convert a string to a 7-bit ASCII safe representation that can be passed as input to Frink. This differs from the existing toASCII[str] in that it keeps high Unicode codepoints (above \uFFFF) as a single Unicode codepoint in a format that looks like \u{1F384}.
• Added several functions for querying Unicode properties of characters and strings, for example, querying the Unicode General Category property. See the Unicode Properties section of the documentation for details.

2021-10-10

• Added isNegativeUnit[expr] function which returns true if the expression is a unit of any kind (including dimensionless numbers) with a negative sign, false otherwise.
• Updated the sample program formatEquation.frink to print subtraction operations more like standard mathematical notation.

2021-10-06

• Updated function formatBracketsCompact[expr] to format a table surrounded by Unicode square bracket characters, or ordinary square brackets if it fits into a single line. Brackets are now smaller (putting brackets only on the sides) and use better Unicode characters. See the FormattingTables section of the documentation for details.
• Updated the sample program, formatEquation.frink, which demonstrates using table formatting functions to format equations into standard mathematical format, to use more compact brackets and parentheses.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2021-09-30

• Added functions rotateLeft and rotateRight to rotate the bits of an integer left or right by a specified number of bits. See the Number Theory section of the documentation for more information.
• Released a new version of Frink: The Next Generation (version 2021-09-30). This merges all changes from the main branch.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2021-09-25

• Further updates to secant.frink to fix a divide-by-zero error in secant[x] in some cases. Thanks to Dr. Alberto Di Lullo for the bug report. Additional contributions to making these functions even more robust are welcome.
• If you always want to sort a multi-dimensional array by column number, you can easily get an appropriate sorting function that sorts by a specified column by calling byColumn[int] and passing that as a sorting function. The column number is zero-based. For example, sort[list, byColumn[1]]. See the sorting section of the documentation for examples.

2021-09-24

• Released a new version of Frink: The Next Generation (version 2021-09-24). This merges all changes from the main branch.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2021-09-22

• Fixes to the exactSeasons program that calculates the equinoxes and solstices to high accuracy by adding a new function to secant.frink that works more correctly when finding angles around zero. This was causing autumnal equinox calculations that were off by exactly one hour.
• Performance improvements for VoxelArray.makeSphere in Frink's VoxelArray class. See Frink's 3-D routines.

2021-09-17

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.
• Added libraries to generate screw threads for 3-D printing. These are available in the following files:
  • screwThreadsTest3Start.frink (generates a 3-start thread)
  • screwThreadsTest.frink (generates standard garden hose fittings)
  • screwThreads.frink (contains routines to parametrically generate screw threads)
  • parametric3D.frink (contains smart algorithms to move a tool based on a parametrized function in 3D.)

2021-08-24

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2021-08-15

• Added function formatBracketsCompact[expr] to format a table surrounded by Unicode bracket characters, or ordinary parentheses if it fits into a single line. See the FormattingTables section of the documentation for details.
• Added a sample program, formatEquation.frink, which demonstrates using table formatting functions to format equations into standard mathematical format.

2021-08-12

• Added function getOperatorSymbol[expr] which returns the symbol for an expression that represents a mathematical operator like "+" or "*" as a string. See the Other Functions section of the documentation for details.
• Added functions formatParens[expr] and formatParensCompact[expr] to format a table surrounded by Unicode parenthesis characters. See the FormattingTables section of the documentation for details.

2021-08-10

• Added functions isOperator[expr] and getOperatorPrecedence[expr] to determine if an expression represents a mathematical operator like + or *. See the Other Functions section of the documentation for details.
• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.

2021-07-27

• If you are using a Java data structure that puts Frink or Java data types into a data structure that needs a java.util.Comparator to perform the comparisons (e.g. java.util.PriorityQueue,) you can get Frink's default Comparator (which follows the same semantics as Frink's <=> three-way comparison operator,) by calling getDefaultComparator[]. Frink's default comparator will also compare Java objects that implement the java.util.Comparable interface so it can be used for Frink and Java data types.
• Added new methods for creating solids of rotation to Frink's VoxelArray class to create a variety of shapes. See Frink's 3-D routines.
• See the sample program VoxelSolidOfRotation.frink for a demonstration of making solids of rotation. This program makes nice little 3-D nameplates or chopstick rests for 3-D printing.

2021-07-03

• Updated the currency conversion source to work again. As always, the availability of internet-based sources cannot be guaranteed and this fix may be temporary.
• Note: Currency conversions will probably not work in Java 1.6 and before because they do not support Diffie-Hellman key exchanges larger than 1024 bits and the internet-based source uses 3072-bit keys.
• Released a new version of Frink: The Next Generation (version 2021-07-03). This merges all changes from the main branch.

2021-07-02

• Note: The currency conversion source that Frink uses has gone away and probably won't return. Currency conversions will not work correctly until a new source is found. Please let me know if you know a free currency conversion source.
• Updated the currency conversion cache.

2021-06-25

• Fixed some VoxelArray functions to correctly use the new extended range allowed by the new BiggerBitSet implementation.
• Added getNextSetBitIndex and getPreviousSetBitIndex methods to VoxelArray.
• Added getMinSetZ and getMaxSetZ methods to VoxelArray.

2021-06-13

• Released a new version of Frink: The Next Generation (version 2021-06-13). This merges all changes from the main branch.

2021-06-11

• Rewrote many of the internals of VoxelArray for 3-D printing. Most importantly, it was rewritten to use an improved BitSet, called BiggerBitSet.
• BiggerBitSet is an improvement on Java's java.util.BitSet class in a few ways:
  • BiggerBitSet uses long instead of int to address bits in its API which greatly increases the size of bits addresable. The implementation of BitSet allows a maximum number of pixels of (2^31 - 1) or 2147483647, which is about 2 billion pixels. If 3-D printing at a resolution of 0.1 mm/pixel, this gives a maximum size of about 5.07 inches on a side.

    ((2^31-1))^(1/3) 0.1 mm -> in

    This is not quite big enough to fit a modern 3-D printer's bed.

    With this class's API, the number of pixels is increased by a factor of 64. The calculation is:

    ((2^31-1) * 64)^(1/3) 0.1 mm -> in

    which gives a cube of about 20 inches on a side. This is enough of an improvement to warrant the class.

  • BiggerBitSet does not not allow itself to be dynamically resized; this should give a performance improvement over BitSet. BitSet takes a lot of effort to check dynamic ranges, to validate invariants and resize with every set operation.
  • BiggerBitSet is constant across Java releases and implements functions (especially those to set a range of values quickly and efficiently) which did not exist in earlier versions of Java's BitSet.

2021-06-09

• A dictionary is now hashable; this means that you can use a dict as the key in a dictionary, add it to a set, etc. Be sure not to modify the dictionary after inserting it into another data structure, or results will be undefined (and probably wrong.)
• Released a new version of Frink: The Next Generation (version 2021-06-09). This merges all changes from the main branch.

2021-06-02

• Added new functions for extruding while scaling and rotating polygons to Frink's VoxelArray class, to create a variety of shapes. See Frink's 3-D routines.

2021-05-30

• Fixed writing of some special characters when writing graphics to HTML canvas format. For example, the ampersand character & was encoded incorrectly using HTML encoding rules instead of the necessary JavaScript encoding rules.

2021-05-21

• Added several classes and functions for drawing parametric curves to Frink's VoxelArray class, to create a variety of shapes. See Frink's 3-D routines.
• Added a new program, parametric3D.frink to demonstrate drawing 3-D curves for 3-D printing using parametric equations. This allows drawing of screw threads, for instance.
• Fixed a problem with the definition of earthvolume in the standard data file.

2021-04-22

• Fixed the charName and charNames functions to return an empty string (rather than a null or crashing) if a Unicode codepoint is undefined or if the Java Virtual Machine does not know its name (JVMs lag far behind the latest Unicode definitions.)

2021-04-10

• Added a method, makeSupertoroid to Frink's VoxelArray class, to create a torus or other members of the toroid family. See Frink's 3-D routines.
• Revised the arguments to VoxelArray.construct to be double instead of float for flexibility. See Frink's 3-D routines.
• Improved error messages when parsing. If a program contains an unrecognized character, the error message also displays the Unicode name of the codepoint.

2021-03-28

• Added a method to Frink's VoxelArray class, to extrude an image or text onto a specific plane. See Frink's 3-D routines.
• Released a new version of Frink: The Next Generation (version 2021-03-28). This merges all changes from the main branch.

2021-03-23

• Added a method to Frink's VoxelArray class, fillCube which draws a 3-D cuboid. See Frink's 3-D routines.
• Added a fabulously powerful yet simple program, graph3D.frink, which graphs arbitrarily-complicated 3D equations and creates a file for 3-D printing.

2021-03-22

• Added function img.getPixelGrayInt[x,y] to return the color of a pixel as a grayscale from 0 to 255 inclusive. This is meant for quick processing and does not perform any perceptual encoding. See the images documentation for more.
• Added a method to Frink's VoxelArray class, strokeZTapered which allows drawing in 3-D along a polyline or polygon with a tapered tool. See Frink's 3-D routines.
• Updated Historical British Price Data for final data from 2020.
• Added polygon.isInside[x, y] method to test if a point is inside a polygon using the even-odd rule. See Polygon Methods for more information.

2021-03-17

• Modified the table formatting functions so that centered text is biased toward the right so that numbers and negative signs line up better.
• The Matrix.frink sample program has added and improved algorithms for matrix inversion, calculating the adjugate of a matrix, and improved determinant calculations. The Matrix class is still woefully incomplete but feel free to contribute unimplemented functions!

2021-03-12

• Fixed the order of rotations in VoxelArray.rotateXYZ. When composing 3-D matrix transforms, you have to multiply them in reverse order! See Frink's 3-D routines.

2021-03-11

• Added functions to produce the Unicode names of characters from either strings or arrays of integers. See the Unicode in Strings sections of the documentation for the charName and charNames functions. For example:

  charNames["\u{1f63a}!"]
[SMILING CAT FACE WITH OPEN MOUTH, EXCLAMATION MARK]

• Additions and changes to Frink's 3-D routines, including extrusion of polygons and rotations.

2021-03-05

• Lots of additions and changes to Frink's 3-D routines, including extrusion of polygons, scaling routines, and more.

2021-02-03

• Added the function symmetricDifference[a, b] which calculates the "symmetric difference", also known as the "disjunctive union" of sets a and b. In other words, the new set contains only the elements that are in either set a or b but not in both. For example, the symmetric difference of the sets {1,2,3} and {3,4} is {1,2,4}.

  For more information, see the Sets section of the documentation.

2021-02-02

• Fixed an issue that manifested as a NoClassDefFoundError for frink.graphics.FrinkImage. The problem was caused by the obfuscator. Thanks to Ty Boyack for the report.
• Released a new version of Frink: The Next Generation (version 2021-02-02). This merges all changes from the main branch.

2021-01-28

• Added a formatTableInput function to format a 2-dimensional table into Frink's inputForm so that it can be parsed by Frink, passed to the eval function, pasted into a Frink program, etc. See the Formatting Tables section of the documentation for details.
• Added some cool examples of recursive table formatting to format equations and Frink source code to the Formatting Tables section of the documentation.

2021-01-10

• Fixed a bug in calling functions like addLeap that manifested as a NoClassDefFoundError for frink.date.LeapSeconds. The problem was caused by the obfuscator. Thanks to Tobias Jordan for the report.
• Released a new version of Frink: The Next Generation (version 2021-01-10). This merges all changes from the main branch.

2021-01-01

• Added new startup options for Frink:
  • When using the frink.gui.FrinkStarter class, the -1 command-line option will start Frink in one-line input mode (default is two-line input mode). This is similar to starting Frink and choosing the menu item Mode | One-Line or hitting Ctrl-1.
  • When using the frink.gui.FrinkStarter class, the -3 command-line option will start Frink in multi-line input mode (default is two-line input mode). This is similar to starting Frink and choosing the menu item Mode | Multi-Line or hitting Ctrl-3.
  • See the Running Frink section of the documentation for more details.
• Released a new version of Frink: The Next Generation (version 2021-01-01). This merges all changes from the main branch.

2020-12-31

• Updated copyright dates for 2021. Happy New Year!
• Updated sanity checks to 2021 for economic routines.
• Updated calculations and predictions for deltaT for 2021. It is currently hardcoded to 69.359 s (it has been 69.184 s for the past 3 years.) USNO's servers that typically serve this information and predictions have been down for at least 15 months.
• Released a new version of Frink: The Next Generation (version 2020-12-31). This merges all changes from the main branch.

2020-12-14

• Fixed a bug in the rest[array] function that produced a program crash.
• Added the function setBit[n, bit] which sets the specified bit of a number (least significant bit is 0) to 1 and returns a new number. This is equivalent to bitOr[n, shiftLeft[1, bit]]
• Added the function clearBit[n, bit] which clears the specified bit of a number (least significant bit is 0) to 0 and returns a new number. This is equivalent to bitAnd[n, bitNot[shiftLeft[1, bit]]]
• Added the function flipBit[n, bit] which flips the specified bit of a number (least significant bit is 0) and returns a new number. This is equivalent to bitXor[n, shiftLeft[1, bit]]
• Released a new version of Frink: The Next Generation (version 2020-12-14). This merges all changes from the main branch.

2020-11-27

• Added a convenience method to turn a graphics object into a bitmapped image:

  graphics.toImage[width, height]

  which is identical to the image constructor:

  new image[graphics, width, height]

• In both of the above functions to turn a graphics object into an image, now if exactly one of width or height are specified as undef, and the other is an integer, the size of the undefined axis will be calculated from the defined width or height and the aspect ratio of the graphics that is being drawn.
• Released a new version of Frink: The Next Generation (version 2020-11-27). This merges all changes from the main branch.

2020-11-17

• Added the ability to rotate a VoxelArray to Frink's 3-D routines. See the VoxelRotateTest.frink sample program. This makes almost feature-completeness to 3D modeling.
• Released a new version of Frink: The Next Generation (version 2020-11-17). This merges all changes from the main branch.

2020-11-10

• Added a rounded cube primitive to Frink's 3-D routines. See the roundedCubeTest.frink sample program.

2020-11-09

• Improved the Frink-Java mapping to allow a FrinkImageExpression to be used where a FrinkImage is required. This enables some features in 3-D printing, notably extruding an image to 3 dimensions.
• Added provisional Javadocs for Frink's 3-D routines. These will change and are intended for use in 3-D printing, and not realtime 3-D rendering. The class you want to look at is VoxelArray which contains a lot of methods for drawing primitives (like cubes, spheres, cylinders, capped cylinders, tapered cylinders,) performing constructive solid geometry (that is, taking the intersection of two objects, the union of two objects, or the difference of two objects,) extruding images and text, and more.
• To see samples of Frink's increasing support for 3-D printing, search the sample programs for voxel. For older programs that render Wavefront .obj file formats directly, search for wavefront.
• Added an extrude method to the VoxelArray class which allows you to extrude the black pixels of an image as a 3-D object. See extrudeTest.frink for a sample of its usage.

2020-10-31

• Released a new version of Frink: The Next Generation (version 2020-10-31). This merges all changes from the main branch.

2020-10-29

• Added a formatMatrix function which can format a table with Unicode box-drawing characters making traditional matrix brackets surrounding it. See the Formatting Tables section of the documentation for details.

  b = [[1,2], [3,10]]
println[formatMatrix[b, "right"]]

  ┌     ┐
│1   2│
│     │
│3  10│
└     ┘

2020-10-25

• Updated the SSL/TLS certificates for https://frinklang.org/. Let me know if you have any trouble connecting.

2020-10-20

• Fixed a build problem that made the 2020-10-17 release not work on some platforms. Sorry about that.

2020-10-17

• Added a formatTableBoxed function which can format a table with Unicode box-drawing characters separating the cells. See the Formatting Tables section of the documentation for details.

  b = [[1,2], [3,10]]
println[formatTableBoxed[b, "right"]]

  ┌─┬──┐
│1│ 2│
├─┼──┤
│3│10│
└─┴──┘

• Added lots more code for 3-D modeling and 3-D printing (which has not been documented and is currently changing).

2020-10-01

• Improved the performance of the approxLn function in ArbitraryPrecision.frink (and all the functions that depend on it. This performance will be most evident in Frink: The Next Generation.
• Added lots of code for 3-D modeling and 3-D printing (which has not been documented and is currently changing).

2020-08-23

• Added the method image.autocrop[] which automatically crops the sides of an image where the pixels are approximately equal. This returns a new image.

2020-08-17

• Fixed an error in Frink-Java mapping which produced the error "cannot fit in a float" when in fact the number could fit into a float. This manifested for zero and negative numbers.
• Released a new version of Frink: The Next Generation (version 2020-08-17). This merges all changes from the main branch.

2020-08-09

• Modified the planets.frink astronomy libraries to optionally allow filling in the shape of Jupiter when drawing its moons and also optionally filling in the shape of Saturn.
• Added a new sample program, drawJupiterSaturn.frink which draws Jupiter and Saturn as they would look in the sky relative to each other. This is for the great Jupiter-Saturn convergence of 2020 where Jupiter and Saturn will gradually close from August 29, 2020 to be about 0.11 degrees away (about 1/5 the diameter of the full moon) from each other on December 21, 2020. This requires the updated planets.frink library described above.
• Some minor HTML fixups.

2020-08-04

• Fixed a bug in the zero-argument Writer.println[] method which may have caused the error message "AbstractExpressionFormatter.formatUnknown passed null expression!" to be displayed to the user and possibly written into the file.

2020-07-30

• Fixed a silly error in the planets.frink astronomy libraries where the radius and mass of Planet.Mars were accidentally the radius and mass of planet Earth. Please update.

  This did not affect anything about the orbit or position of Mars, nor did it affect the constants marsradius nor marsmass in the standard data file; it just exposed itself when accessing the planets.frink library and requesting the fields Planet.Mars.radius or Planet.Mars.mass

• Added a drawVenus.frink sample program that draws Venus as it appears from Earth.
• Added a drawPlanets.frink sample program that draws the illuminated parts of planets as they appear from Earth. This currently draws random colors and will be updated.

2020-07-28

• Released a new version of Frink: The Next Generation (version 2020-07-28). This merges all changes from the main branch.

2020-07-27

• Added dictionary methods dict.keys[] and dict.values[] to let you enumerate through the keys and values of a dictionary. (There was already a keys[dict] function.) See the Dictionary Methods section of the documentation for more.

2020-07-25

• Released a new version of Frink: The Next Generation (version 2020-07-25). This merges all changes from the main branch.

2020-07-24

• Refactored the sun.frink and planets.frink astronomy libraries. If you update one of these, update both!
  • Added functions for drawing Saturn and its rings.
  • Function SaturnRingPosition was renamed to SaturnEphemeris and calculates more parameters.
  • Unified drawing of illuminated fraction of moon and planets.
  • Added several function for drawing Jupiter and its moons in different orientations.
  • Refactored and unified axis drawing routines.
• Added a sample program, JupiterSaturnConvergence.frink to calculate the great convergence of Jupiter and Saturn that peaks in December 2020.
• Added a sample program, plotConvergence.frink, to plot the output of the convergatron.frink program which predicts planet and moon alignments.
• Added a sample program, drawSaturn.frink, to draw the orientation of Saturn and its rings.

2020-07-15

• Added a new function rest[expr, num] returns everything after the first num elements of an array or enumerating expression. If the expression passed in is an array, the result is an array, otherwise it is a (possibly-infinite) enumerating expression. This is the opposite of first[expr, num]

  See the Slicing Arrays and Enumerating Expression Functions sections of the documentation for more.

2020-07-14

• Updated the following mathematical transformation rule libraries for better solving:
  • solvingTransformations.frink
  • solveTrigonometric.frink
  • derivatives.frink
• Fixed the definition of the trit in the standard data file. It was incorrectly listed as dimensionless, and should have had dimensions of bits. Thanks to Adam Haun for the correction.

2020-07-13

• In Frink: The Next Generation, full Unicode character classes and full Unicode case folding is enabled by default. This fixes the broken behavior of the Java 1.6 release when running on Java 1.7 and later and makes the /uU regex options essentially unnecessary and obsolete.
• Documented that Frink: The Next Generation no longer uses the POSIX character class codes that look like [[:Alpha:]] and [[:Digit:]] are no longer available and have been replaced with Unicode regular expression classes as specified in Unicode Technical Standard 18: Unicode Regular Expressions. See the Regular Expression Replacement documentation of Frink:TNG.
• Released a new version of Frink: The Next Generation (version 2020-07-13). This merges all changes from the main branch.
• Added a new sample program, TaylorSeries.frink which generates a symbolic Taylor series for a function.

2020-07-07

• The functions wordList, lineBreakList, and sentenceList now have two-argument versions that allow you to specify a language specifier which uses different human language's rules for detecting words, sentences, and places to break lines. See the Correct String Parsing section for details.
• Added an Additional Array Functions section to the documentation which makes it clear that other many functions will work on arrays.

2020-07-04

• Released a new version of Frink: The Next Generation (version 2020-07-04). This merges all changes from the main branch.

2020-07-03

• Added countToArray[expr] and countToDict[expr] functions that count the number of times that each element occurs in an array or other enumerating expression and returns the number of occurrences of each item. The array version returns an array with the most common items first. These can be used to easily build frequency tables. See the Enumerating Expression Functions for more details.

2020-07-03

• Added calculation of the second and third virial coefficients to water.frink which calculates properties of water and steam according to the IAPWS model. See the comments to find out just what the heck "virial coefficients" are.

2020-06-26

• The formatTable function now can take any enumerating expression, instead of just an array as its input. See the Formatting Tables section of the documentation for details.
• The formatTable function can format a one-dimensional array into column form. See the Formatting Tables section of the documentation for details.
• The Swing and AWT GUIs now have the option for using a monospaced font. This can be selected from the View | Font menu item. This is helpful when using the above formatTable functions.
• Added array methods array.isEmpty[] and array.peek[] which are useful when using an array as a stack. See the Pushing and Popping section of the documentation for details.
• Released a new version of Frink: The Next Generation (version 2020-06-26). This merges all changes from the main branch.
• The Matrix.frink sample library has new methods like matrix.formatMatrix[] which use the new formatTable function to format a matrix that really looks like a matrix, complete with efficient use of space and Unicode box-drawing brackets. The Matrix class is still woefully incomplete but feel free to contribute unimplemented functions!
• Fixed a bug in the Matrix.frink sample library when creating a matrix from a non-square array.

2020-06-15

• Documented some new date/time formatting options such as numerical day of week, new AM/PM options, etc. These may require an up-to-date Java Virtual Machine. See the defining new date/time formats section of the documentation for more.

2020-06-13

• Added functions for formatting tables. See the Formatting Tables section of the documentation for details.

2020-05-31

• Added array.dimensions[] method to return the dimensions of a possibly-multiple-dimension array. See the Dimensions array method documentation for details.

2020-05-23

• The following formatting functions can now take an array, set, or most other enumerating expressions was the first expression, making it much easier to format a collection of data to a specific format. If the value is an array or other collection, these functions return an array of strings, which can then be formatted using other functions like join, joinln, etc.
  • formatSci[value, divideBy, decPlaces] (Scientific notation)
  • formatEng[value, divideBy, decPlaces] (Engineering notation)
  • formatSig[value, divideBy, decPlaces] (Significant figures)
  • formatFixed[value, divideBy, decPlaces] (Fixed decimal places)
• Updated some sanity checks for the new Java 15.
• Released a new version of Frink: The Next Generation (version 2020-05-23). This merges all changes from the main branch.

2020-05-20

• Reordered the search order for function names. This should slightly improve execution speed.

2020-05-09

• Released a new version of Frink: The Next Generation (version 2020-05-09). This merges all changes from the main branch.

2020-05-05

• Added an inputFormUnicode formatter that is like inputForm but assumes you have a working Unicode environment and does not escape non-ASCII characters.

2020-05-02

• Added a concat[array1, array2] function that concatenates the elements of two arrays (or other enumerating expressions.) For now, the result is always an array, but this may change to be more memory-efficient by letting arbitrary enumerating expressions to follow each other.

2020-04-27

• Made several fixes to make regular expressions in Frink and Frink: The Next Generation work more to the same. These were primarily fixes to the original version of Frink:
  • Unified the behavior of \uHHHH which matches a specified Unicode character, where HHHH is a 4-digit hexadecimal code indicating a Unicode codepoint.
  • The left- and right-hand side of a substitution expression can now accept high Unicode characters in both Frink and Java format, that is in the format \u{h...h} (Frink notation) and \x{h...h} (Java regex notation) where h...h represents from 1 to 6 hexadecimal digits that represent the desired Unicode codepoint.
  • The right-hand side of a substitution expression can now contain character escapes in the format \xhh where hh represents exactly 2 hexadecimal digits that represent the Unicode character. These previously worked in the left-hand side but not the right-hand side.
  • The right-hand side of a substitution expression currently expressly can not contain some of the antiquated and problematic character escapes defined in Java's Pattern class. The unsupported patterns are:
    • Octal escapes beginning with \0 (that dangerous notation dies with me!)
    • The alert (bell) character \a (use \u0007 instead)
    • The escape character \e (use \u001B instead)
    • The escape sequence for control characters \cX (specify it with its Unicode character instead.)
• Released a new version of Frink: The Next Generation (version 2020-04-26). This merges all changes from the main branch.

2020-04-22

• There is a new 3-argument version of makeArray[dimensions, function, data] which allows you to pass in arbitrary additional data to a function when creating an array. See the Initializing Arrays section of the documentation for examples.
• Updated the Matrix.frink sample library to easily create identity matrices or diagonal matrices using the new makeArray functions. The Matrix class is still woefully incomplete but feel free to contribute unimplemented functions!

2020-04-19

• The makeArray[dims, value] function can now take a function as the value parameter. The function will be called to provide the value of each cell. See the Initializing Arrays section of the documentation for examples.
• Released a new version of Frink: The Next Generation (version 2020-04-19). This merges all changes from the main branch.

2020-04-18

• Added a new program to approximate the factorial of a number using Stirling's approximation, Stirling.frink. This program gives a naïve calculation of Stirling's approximation, along with better calculations and corrections, and Gosper's formula.
• Updated the file Pochhammer.frink, to calculate the "rising factorial" function. Also added functions in that program to calculate the "falling factorial" function and a generalization of the binomial theorem that works for non-integer values.

  I also added a huge diatribe about the so-called "Pochhammer function" and whether it means a rising or falling factorial, which is ambiguous through history and across fields of study. The new preference is to call risingFactorial[x, n] or fallingFactorial[x, n]

• The program Pochhammer.frink now contains a generalization of the binomial theorem to arbitrary bases as the function generalizedBinomial[r, k] It basically generalizes it as:

  generalizedBinomial[r, k] := fallingFactorial[r, k] / k!

• Added a new program, StirlingCoefficients.frink, which calculates the "correction" terms to Stirling's approximation for the factorial of a number, and makes Stirling's approximation much more accurate, especially for large exponents. This is not currently used in Stirling.frink, but it should be someday.

2020-04-08

• Made some workarounds due to Java 13's disastrous "module" system to "fix" code that has worked for 20 years.
• Released a new version of Frink: The Next Generation (version 2020-04-08). This merges all changes from the main branch.

2020-04-01

• Added arbitrary-precision square root functions:
  • sqrt[x, digits]: Arbitrary-precision square root to the specified number of digits. This can take arbitrarily-large and small arguments. This function only works with real-valued inputs.
  • sqrtExact[x, digits]: Arbitrary-precision square root to the specified number of digits. This can take arbitrarily-large and small arguments. If the input is an integer, this attempts to return an exact integer result when possible. This function only works with real-valued inputs.
• Released a new version of Frink: The Next Generation (version 2020-04-01). This merges all changes from the main branch.

2020-03-31

• Fixed a problem in regular expressions and search-and-replace operations where a literal backslash was not consistently representable with two backslashes.
• Released a new version of Frink: The Next Generation (version 2020-03-31). This merges all changes from the main branch.

2020-03-19

• Updated the secant.frink file to invert a function more reliably (hopefully eliminating divide-by-zero errors) in the really cool secantInvert function.
• The exactSeasons program that calculates the equinoxes and solstices to high accuracy uses secant.frink, but does not itself need to be updated. It also says that today is the first day of spring in the northern hemisphere!

2020-03-18

• Added an until loop and a do...until loop which work just like the while loop and the do...while loop, except that they iterate until the condition becomes true.

  i=0
until i>1000000
{
   i = i+1
}


  i=0
do
{
   i = i+1
} until i == 1000

  This means that until is now a reserved keyword.

2020-03-14

• Added a FrinkGeneration[] function that returns an integer indicating the generation of Frink. 0=Frink original, 1=Frink:The Next Generation.

  Programs can use this flag to warn that, say, calculating thousands of digits will be slow in the original version, or even switch behavior (e.g. use an integer-based routine in original Frink and a floating-point routine in Frink:TNG.)

  If you don't know what Frink:The Next Generation is, it's a new version of Frink that runs on Java 1.6 and higher, but you should use it on Java 1.8 and higher because Java 1.8 has algorithms that Frink contributed to Java which makes its floating-point numbers orders of magnitude faster for numbers with lots of digits. You should be using it unless you have an old or broken Java implementation.

  To support old versions of Frink before this function exists, you should probably wrap it in a call to eval:

  if eval["FrinkGeneration[]"] != 1
   println["""Note: this program will be orders of magnitude faster with Frink:The Next Generation, available at: https://frinklang.org/experimental.html"""]

• Released a new version of Frink: The Next Generation (version 2020-03-14). This merges all changes from the main branch.

2020-03-11

• Added a sample library, water.frink which calculates properties of water and steam according to the IAPWS model.

2020-03-06

• Important: Fixed an incorrect optimization in algebraic simplification of power expressions like (x^y)^z which did not work correctly in some cases if z was a non-integer. It is highly recommended to update as soon as possible.
• Released a new version of Frink: The Next Generation (version 2020-03-06). This merges all changes from the main branch.
• Released a new version of the frink-tng.war file from Frink: The Next Generation (version 2020-03-06).

2020-03-02

• Added joinln[list] function which takes an array and returns its result as a single string joined by newline characters, that is, it puts each element of list on its own line with no trailing newline.

2020-02-29

• Released a new version of Frink: The Next Generation (version 2020-02-29). This merges all changes from the main branch.
• Released a new version of the frink-tng.war file from Frink: The Next Generation (version 2020-02-29).

2020-02-26

• Added the isEnumerating[expr] to test if an expression is an enumerating expression.
• Added documentation to the ternary conditional operator condition ? trueClause : falseClause in the If / Then / Else section of the documentation.

2020-02-22

• Further improved the flexibility of the numerator, denominator, and numeratorDenominator functions. These functions now take two optional parameters which allows you to select how rational numbers and units of measure are split between the numerator and denominator. See the description of the numeratorDenominator function in the Other Functions section of the documentation for details.

2020-02-17

• Greatly improved the power of the numerator[expr] and denominator[expr] functions. They can now return the numerator and denominator of arbitrary symbolic expressions. denominator[expr] works by collecting multiplicative terms that are obviously divisions or have negative exponents, and numerator[expr] works by collecting the other parts.
• Added a new numeratorDenominator[x] function which returns the numerator and denominator of an expression as a two-item array [numerator, denominator] This works on rational numbers, integers, units, and arbitrary symbolic expressions. It is better to use this function than to call numerator and denominator separately, as it's more efficient.

  [n,d] = numeratorDenominator[noEval[1/4 G^-1 a^-1 c^4]]
[c^4, 4 G a]


2020-02-12

• Added a Constraining Viewport section to the documentation which describes how to set the viewport that is visible in a graphics object. Normally, Frink's graphics are automatically scaled and centered in the display. All of the graphics that you draw will automatically be visible, no matter what coordinate system you use. However, sometimes you may want to have fine-grained control over the region that is displayed, even if you don't fill it entirely, or if you want to draw outside the region, or if you want to "zoom in" on just part of a graphic.

2020-02-11

• Fixed a problem in the map["funcname", list] function when the first parameter was a string indicating a function name. This is a convenience function that tries to look up an appropriate function by name, based on the length of the first entry in list but may not have found an appropriate function if list was a list of non-list items. This may have manifested in an error message like:

  MapFunction: No function found named 'funcname' with 0 arguments.

  The function worked correctly if passed an anonymous or named function as the first argument (which is probably a more robust solution.)

  Thanks to Chris Hansen for the bug report.

2020-02-10

• Added more general rules for solving exponential/logarithmic relations that require the Lambert W function to powerTransformations.frink. This includes the forms:
  • a = n ln[n]
  • a = n ln[c n]
  • a = n ln[c n^x]
  • a = n^y ln[c n^x]
  • a = n / ln[n]
  • a = n / ln[c n]
  • a = n / ln[c n^x]
  • a = n^y / ln[c n^x]
  • z = w e^w
  • z = w e^(d w)
  • z = w^x e^(d w^y)
  • z = w b^w
  • z = w b^(d w)
  • z = w^x b^(d w^y)

  In these, the exponents y and x can be negative, which indicates division by n.

2020-02-05

• Released a new version of the frink-tng.war file from Frink: The Next Generation (version 2020-02-05). This attempts to fix some compilation issues from the last version. As a result, the Java Servlet API version compiled against had to be increased from 2.5 to 3.1.

2020-02-02

• Released a new version of Frink: The Next Generation (version 2020-02-01). This merges all changes from the main branch.
• Fixed a problem in sqrtWayne.frink where a value that only needed to be calculated to a few digits could be calculated to maybe millions of digits. This slowed down programs like piChudnovskyNew.frink.

2020-02-01

• Further enhanced the functionUtils.frink to add functions helpful for finding derivatives of an equation
• Enhanced the functionUtilsTest.frink to include a sample of getting the derivative and integral of either a function defined in Frink or one defined in Java.

2020-01-30

• Fixed a couple more issues in the log[x, base] function (which takes logarithms of the number x to the specified base base.) These did not return wrong results, but could throw ArithmeticExceptions or cause slowdowns.

2020-01-27

• Added the splitLines[str] function which splits a string on newline characters and returns an array of strings with the newlines removed. See the split section of the documentation for an example.

2020-01-26

• The primes[begin, end] function can now take the undef parameter for either argument. If begin is undef, the enumeration begins with 2. If end is undef, the enumeration is potentially infinite.

2020-01-24

• Released a new version of Frink: The Next Generation (version 2020-01-24). This merges all changes from the main branch.
• Removed the unit mohm as a synonym for the strange unit mobileohm. This conflicted with the milliohm. Thanks to Enon Harris for the catch.

2020-01-22

• Added functions to work with (possibly infinite) enumerating expressions:
  • first[expr] returns the first element of an array or enumerating expression as a single expression.
  • first[expr, count] returns the first count elements of an array or enumerating expression. If the expression passed in is an array, the result is an array, otherwise it is a (possibly-infinite) enumerating expression.
  • rest[expr] returns everything after the first element of an array or enumerating expression. If the expression passed in is an array, the result is an array, otherwise it is a (possibly-infinite) enumerating expression. This is the opposite of first[expr]
  • last[expr] returns the last element of an array or enumerating expression as a single expression.
  • last[expr, count] returns the last count elements of an array or enumerating expression. The result is an array.
  • slice[expr, begin, end] returns a slice of an array or enumerating expression starting with index start and ending before index end. If the indices are beyond the ends of the array, only existing items will be returned. If begin or end is the value undef, the results will include the beginning or end of the expression respectively. If the expression passed in is an array, the result is an array, otherwise it is a (possibly-infinite) enumerating expression.
  • sliceLength[expr, begin, length] returns a slice of an array or enumerating expression starting with index start and having length items. If the expression passed in is an array, the result is an array, otherwise it is an enumerating expression.
  • nth[expr, index] returns the specified (zero-based) element of an array or enumerating expression. For example, to return the millionth prime (again, indexing is zero-based,) nth[primes[], million-1]
• Added an Enumerating Expressions section to the documentation.

2020-01-18

• Added the last[expr] function to return just the last element of an array or enumerating expression.
• Added a primes[begin] function which returns an infinite enumerating expression of the prime numbers greater than or equal to begin and increasing. Note that this will produce infinite output if you even try to print it, so you probably want to call it from a for loop or from something like first[primes[3], 100]
• Added a primes[begin, end] function which returns a finite enumerating expression of the prime numbers greater than or equal to begin and less than or equal to end.
• Fixed calculation of meanAndSD function in statistics.frink

2020-01-14

• Added lineWrapper.frink library that wraps lines to a specified number of columns.

2020-01-12

• Added the arg[z] function that returns the argument (that is, the phase) of a complex (or real) number. For a complex number z = x + i y, this is equivalent to arctan[y,x].

2020-01-11

• Released a new version of Frink: The Next Generation (version 2020-01-11). This merges all changes from the main branch and fixes a class of Next-Generation-specific bugs:
  • When the right-hand-side of a substitution expression (that is, the %s/from/to/modifiers construct) contained character escapes, (for example, \u2090) the character escapes were not properly turned into the actual characters.
  • The left- and right-hand side of a substitution expression can now accept high Unicode characters in both Frink and Java format, that is in the format \u{h...h} (Frink notation) and \x{h...h} (Java regex notation) where h...h represents from 1 to 6 hexadecimal digits that represent the desired Unicode codepoint.
  • The right-hand side of a substitution expression can now contain character escapes in the format \xhh where hh represents exactly 2 hexadecimal digits that represent the Unicode character. These previously worked in the left-hand side but not the right-hand side.
  • The right-hand side of a substitution expression currently expressly can not contain some of the antiquated and problematic character escapes defined in Java's Pattern class. The unsupported patterns are:
    • Octal escapes beginning with \0 (that dangerous notation dies with me!)
    • The alert (bell) character \a (use \u0007 instead)
    • The escape character \e (use \u001B instead)
    • The escape sequence for control characters \cX (specify it with its Unicode character instead.)

    These problematic patterns are still allowed on the left-hand side of a substitution expression, but that may change.

• Released a new WAR file for Frink: The Next Generation for running Frink Server Pages.

2020-01-10

• Added an experimental frink-tng.war file to allow you to easily run Frink: The Next Generation on your webserver to run Frink Server Pages. It's built with Java 1.6 and the Servlet 2.5 API, which means it should be backward-compatible with many servlet containers.

2020-01-05

• Added programs to draw U.S. states. These include programs to draw the United States in both rectangular coordinates and more correct sinusoidal coordinates.
  • mapStates.frink
  • mapStatesSinusoidal.frink
• Fixed a bug in graphics.invertGrays[] when a graphics object contained other graphics objects.

2020-01-04

• The sample startup script for Frink on Linux now can use the rlwrap program to allow you to use the up/down arrows to repeat and edit calculations, and even to autocomplete units and functions. Download the updated file and its associated files from the Running Frink section of the documentation.

2020-01-02

• Released a new version of Frink: The Next Generation (version 2020-01-02). This merges all changes from the main branch.
• Released new versions of Frink for Android. These are available in Google Play and the Amazon App Store.

2020-01-01

• At some point, Google Play silently reinstated the Frink app. Thank their benevolence in protecting you from programming languages.

2019-12-31

• Added the rest[expr] function to return everything after the first element in a list.
• Updated copyright dates for 2020. Happy New Year!
• Updated sanity checks to 2020 for economic routines.

2019-12-27

• Updated Frink's water vapor and absolute humidity and relative humidity calculation library waterVapor.frink with some calculations about how much water you have to vaporize to get a house or room to a particular humidity (inspired by my super-dry lungs in a high-altitude dry climate.)

2019-12-21

• Frink's equation solvers now recognize and solve cubic equations (that is, equations in the form of a x^3 + b x^2 + c x + d === 0)! It even now solves in the cases where b or c are zero and those terms disappear. These updates are located in solvingTransformations.frink.

2019-12-19

• On 2019-12-19, Google Play, in its infinite wisdom, removed the Frink app for two random unrelated reasons. These are under appeal. See below.

  The first weird "reason" was that "something something...your app may appeal to children." This made no sense but if Frink makes children enjoy programming and getting physics answers right, then I'M ALL IN.

  The second random banning was Google saying "something something... let's say billing policy violations." This was especially weird because:

  • Frink on Android has never been charged for. In any way. It has always been 100% free to download and use, with all features always enabled.
  • Frink has no way to bill you or charge you for anything. There is no way to pay me for any features. Everything all just works. It has always just worked. You don't have to buy some Candy Crush level to find out what 2+2 is. There is no "pi is 3.1... HAHAHA PAY ME TO SEE THE REST OF THE DIGITS."
  • 100% of all Frink's features have always been available for free in the app. You couldn't pay it to do anything different in any way.
  • Frink has always been 100% free of ads, of spyware, of phone-home behavior, of privacy violations. It all runs on your phone. It does not touch your address book like most of Google Play's better-paying (to Google) apps do. Frink collects nothing about you in any way. Frink doesn't care who your friends are, nor what you buy, unlike other apps.
  • The Frink on Android app is just a thin wrapper around a Frink interpreter. It runs the programs you write. That's all. It doesn't try to monetize you in any way.
  • There have never been any payment APIs nor ads in Frink. Never. Not a single one. There has never been an ad nor a tracker on any page in the Frink websites. Never once. Just use Frink and make yourself smarter. That's all I want.
  • None of this has ever changed in 10 years of the app being on the Google app store, or Google Play, or whatever they call themselves at the minute, which makes this all the more baffling.
  • LOL they tell me that someone will address this "within 2 business days."
  • Update 2019-12-21: They haven't addressed it within 2+ business days.

2019-12-18

• Fixed the calculation of the correlation coefficient of a quadratic fit in curveFit.frink.

2019-12-15

• The syntax highlighter now highlights function definitions. See it in use at Frink Sample Programs.
• Added more comments and analysis to cambridgetempFourier.frink. This is useful to help understand Fourier transforms, especially with units of measure.

2019-11-30

• Added more simplifying solvers to the trignonometric solvers in solveTrigonometric.frink.

2019-11-27

• Fixed a couple of issues in the log[x, base] function (which takes logarithms of the number x to the specified base base.) These would manifest as a divide-by-zero error or an "exponent is too large" error when trying to take the logarithm of a rational number that was very close to 1. Incorrect values were never returned. The errors were in the code that tries to return exact rational or integer results when possible.
• Extended the new relativity.frink library that performs relativity calculations. The additions include black hole calculations, relativistic Doppler shift, relativistic escape velocity, potential energy, and kinetic energy.

2019-11-17

• Added hyperbolic sin, cos, and tan solvers to the trignonometric solvers in solveTrigonometric.frink.
• Added the first cut at a new relativity.frink library to perform relativity calculations. These currently include Lorentz transformations, relativistic rocket calculations, and will soon include black hole calculations, relativistic Doppler shift, relativistic velocity and other coordinate transformations, etc.

2019-11-13

• Added more general rules for solving exponential/logarithmic relations that require the Lambert W function to powerTransformations.frink

2019-11-03

• The Frink webservers have had their software updated. Please let me know if you find anything that's not working.
• Greatly improved the power and generality of the trignonometric solvers in solveTrigonometric.frink.

2019-10-31

• Added the first[expr] function to return just the first element of an array or enumerating expression.

2019-10-29

• Added functions to enumerate through Gray codes. These can have an arbitrary number of states.
• Updated the MercuryTransit.frink sample program to draw the 2019-11-11 transit of Mercury in front of the Sun.

2019-09-27

• The Frink Sample Programs Search page will now search the filenames, and not just the bodies of all the Frink sample programs.

2019-09-26

• The sqrtWayne.frink sample program that performs fast square roots to arbitrary precision has been improved to handle arbitrarily-large and arbitrarily-small numbers and negative numbers.
• The JSON parser has been slightly modified to allow any value as the top-level type.

2019-09-20

• The function bytesToString[bytes, encoding="UTF-8"] can now take an array of Frink integers that will fit into bytes, as well as an array of Java bytes.
• The sample RSA.frink has been updated to use the fix for bytesToString above.
• Added a function last[expr, num] to take the last num items from an expression (which can be an array or enumerating expression.) The result is returned as an array.
• Released a new version of Frink: The Next Generation (version 2019-09-20). This merges all changes from the main branch.

2019-09-16

• Added dictionary methods dict.addToList[key, value] and dict.addToSet[key, value]. See the Dictionary Methods section of the documentation for more.

2019-09-15

• Added rules for solving exponential/logarithmic relations to powerTransformations.frink. Specifically, this solves equations in the form n / ln[c n] === a for n and equations of the form w e^(c w) === z for w, both of which require solutions in terms of the Lambert W function. This makes dependencies on LambertW.frink, ArbitraryPrecision.frink, and sqrtWayne.frink, and pi.frink These dependencies may change. In addition, you can comment out the use LambertW.frink statement without problems; you just won't be able to get a numerical result for the LambertW function; it will just give a symbolic result.
• Added a rule to solvingTransformations.frink for transforming rules in terms of log base 10 into equations of natural log. This makes a lot of different types of equations more readily solved by already-existing rules: for example, LambertW rules and eliminates the need to rewrite all of these rules in multiple forms. to powerTransformations.frink.

2019-09-05

• Added functions to convert to/from galactic coordinates to the sun.frink astronomy library.

2019-08-22

• Made some fixes when using Custom Timezone specifications. This improves Frink's ability to parse these custom timezones, but especially to convert to these timezones, which was not reliable.

2019-07-23

• Released a new version of Frink: The Next Generation (version 2019-07-23). This merges all changes from the main branch.

2019-07-22

• Fixed currency conversions to work again.

2019-07-15

• Added a new program, e.frink to calculate the constant e using binary splitting. This is efficient and resumable and maintains a cache; when you need more digits, the previous calculation is resumed, rather than restarted from scratch.
• Added functions to draw the moon's rotational axis to the sun.frink astronomy library.
• Extended the Moon position calculator to draw the rotational axis of the moon.

2019-07-11

• Added calculations for libration of the moon and the moon's axis angle to the sun.frink astronomy library.

2019-07-09

• Fixed some rules for solving exponential/logarithmic relations to powerTransformations.frink so they don't interfere with more specific rules in solvingTransformations.frink

2019-07-08

• Added several more rules for solving exponential/logarithmic relations to powerTransformations.frink and solvingTransformations.frink
• Removed some errors when evaluating functions like isRational or isInteger in symbolic mode when evaluating conditions in a transformation rule.

2019-06-28

• Happy Tau Day! (6-28 is often called "Tau Day" because it's the same as the first 3 digits of 2 pi, often called "Tau".) There's a new sample program to efficiently calculate the digits of pi (or Tau,) cache them, and return them on demand: pi2.frink

  This is an improvement on the previous pi.frink sample program in that it can resume the binary splitting and square root, rather than starting over when a larger number of digits is requested.

  This file is intended to be used with Frink: The Next Generation.

2019-06-27

• The library that calculates the Lambert W function, LambertW.frink, can now also calculate the secondary branch function, often called W_-1(z).

2019-06-26

• Created the first cut at a rudimentary Frink Sample Programs Search page, where you can search the bodies of all the Frink sample programs.
• Added a function to calculate the Lambert W function, which is what you get when you try to solve z = w ew for w. It can be found at LambertW.frink

2019-06-14

• The functions for converting a FFT-transformed image to/from an image file have been altered to take an (optional) boolean flag that allows the DC (zero-frequency) component to be centered in the middle of the image. See the FourierImage.frink and FourierImageTest.frink sample programs for examples of its usage.

2019-06-04

• Added isReal[expr] function which returns true if the argument is a real number (with or without dimensions, and not an interval,) false otherwise.
• Added unitsWithValues[] function which returns an enumeration of [unitName, value] pairs.
• Added unitsWithValues[expr] function which takes returns an enumeration of [unitName, value] pairs that match the specified dimensions.

2019-05-27

• Released a new version of Frink: The Next Generation (version 2019-05-27). This merges all changes from the main branch.

2019-05-26

• Fixed a bug where the new units for the impedance of vacuum (Z0 or impedanceofvacuum) and admittance of vacuum (Y0 or admittanceofvacuum) were swapped with each other. Again, thanks to Alain Fontaine for bringing these changes to my attention.

2019-05-24

• Frink's standard data file is now internally expected to be encoded in UTF-8 format, and is read as if it is encoded in UTF-8. This may change back, (the previous files have used ASCII escapes for Unicode characters) but some Unicode characters from the 2019 SI redefinitions have crept in for readability. Expecting an encoding prevents weird platform-specific bugs when parsing the standard data file. External data files can still use any encoding. But you should probably always use UTF-8 in this day and age.
• Frink's standard data file has been updated to more exactly match the redefinition of the kelvin (K) based on the 2019 SI redefinition:
  • Under the 2019 redefinition, the Kelvin is now tied to the exactly-defined Boltzmann constant k.
  • The unit zerocelsius is now defined as an exact rational number.
  • As a result of the above, more conversions between temperature scales may now yield exact rational numbers. To format, say, a Fahrenheit temperature as a floating-point number with a fixed number of decimal places, you can use something like:

    format[F[0 K], 1, 2]
-459.67
    

  • Comments in the data file have been updated. All of the new base units contain their new 2019 SI definitions. Comments about the triple point of water have changed, as the triple point of water is now an experimentally-measured quantity, and not an exactly-defined value.
  • Again, thanks to Alain Fontaine for bringing these changes to my attention.
  • Units for the impedance of vacuum (Z0 or impedanceofvacuum) and admittance of vacuum (Y0 or admittanceofvacuum) have been added.

2019-05-21

• Frink's standard data file changed again in a couple of ways:
  • Improved the description of several units, and noted the changes between the pre-2019 definitions and the current definitions. Comments were updated and modernized.
  • Fixed the definitions of mu0 and epsilon0, the permeability and permittivity of vacuum (respectively) to match the changes made in the 2019 SI redefinitions. These are no longer "exactly-defined" values, as they were before, but are now "experimentally-measured" quantities. Their values changed very slightly, and they now have uncertainties. Thanks to Alain Fontaine for bringing these changes to my attention.
• Fixed a possible crash on Android when Frink doesn't have permission to access an external data directory. This may not completely fix all problems when Frink can't write to external storage. I'm currently evaluating fallback behaviors.

2019-05-20

• Happy World Metrology Day! And welcome to the first day of the new International System of Units!
• Frink's standard data file has been updated again to incorporate the new 2018 CODATA values that were released by NIST yesterday. These change some physical constants to the newest best-known values, such as the gravitational coefficient and particle masses. In addition, several constants were redefined in terms of the new fundamental constants, including making some exact, like the gas constant R.
• Released a new version of Frink: The Next Generation (version 2019-05-20). This merges all changes from the main branch.

2019-05-19

• World Metrology Day is May 20! This is one of the most important Metrology Days ever because it marks the release of the new International System of Units (SI). The new version of the SI fixes some (but not nearly all) of the fundamental problems of the old SI by re-defining some units in the SI as exact constants, and letting other units be defined in terms of these exact values.

  (Since Frink version 2018-12-11, you can specify floating-point numbers to be exact using the "exact exponent" indicator which will turn them into exact rational numbers or integers. For example, the new exact SI value for Avogadro's number 6.02214076ee23 will become an exact integer. The exponents can also be negative, which will usually lead to an exact rational number, such as 6ee-1 which produces the exact rational number 3/5 (exactly 0.6). Previously, only integer mantissas could be specified with the exact exponent indicator.)

  The new exact values are:

  • The Planck constant h: Now exactly 6.62607015 * 10^-34 joule-second (J s). This is now represented in Frink as an exact fraction, 6.62607015ee-34 J s
  • The elementary charge of an electron or proton, used in Frink as the unit elementarycharge, or similarly electroncharge (negative) or protoncharge (positive), is now defined as exactly 1.602176634 * 10^-19 coulombs, or, in Frink notation, 1.602176634ee-19 s A (a coulomb is an ampere times a second.)
  • Boltzmann's constant k is now defined as exactly 1.380649 * 10⁻²³ J/K, or, in Frink notation, 1.380649ee-23 J/K
  • Avogadro's constant, the number of items in a mol, is now defined as exactly 6.02214076 * 10²³ / mol, which is an exact integer, or, in Frink notation, 6.02214076ee23 mol^-1
• Some constants have been redefined due to the above definitions. In the Frink standard data file, many definitions have been changed to turn them into their new exactly-defined values. For example, the electron-volt (which is the energy of an electron accelerated through a potential of one volt) is now an exactly-defined value.
• Some units in the data file have been revised if they could be defined in terms of exactly-defined units. In the future, this should make it easier to keep the units exactly defined, and not require updating with new CODATA values every 4 years.
• Standards bureaus like NIST and BIPM have been slow in adjusting their official values for constants. I'm not sure if they're going to switch everything over on May 20, or what. Right now they have the 2014 CODATA values (which are updated every 4 years) of the constants, with no notices about how this will change with the new SI.

  Update: Since I posted this last night, the NIST site now states that it has the 2018 CODATA values of the constants! Frink's standard data file will change again with the new values.

  The units that will change further include things like the gravitational constant G, masses of fundamental particles, etc., all of which are updated both because of new SI definitions and new experimental results. Watch for more Frink updates soon!

• The Grid.frink sample program which allows you to automatically (or manually) add grid coordinates to a graphics object has been improved to fix a bug in horizontal labels with a customized formatting function.
• The daylight.frink sample program which calculates sunrise and sunset and hours of daylight for any location has been improved to graph the times of sunrise and sunset, to not jump forward and backward a day on some dates, and to better handle timezones. It now requires the Grid.frink sample program to label its axes.

2019-05-03

• The functions read and lines and readLines can now take a java.io.Reader as an argument. Previously, they could take a URL or a java.io.InputStream. See the Reading Entire Files section of the documentation for more.

2019-05-02

• The Fourier.frink sample program now contains routines for plotting Fourier transforms (or ordinary arrays) as a magnitude and phase diagram, and for determining the frequency of a particular element of a Fourier transform. The location of these routines may change.

2019-05-01

• Improved the parser to allow "exact exponent" for integer mantissas to allow a + sign in the exponent, e.g. 1ee+1000. The + sign was previously allowed if the mantissa included a decimal point, but if it didn't, this wasn't parsed correctly (and could even produce parser crashes.)
• Added a three-argument version of mapList[function, list, data] which allows arbitrary data to be passed to a function used in the mapList function. In this case, the function passed to mapList must take two arguments instead of one. See the map section of the documentation for more details.

2019-04-21

• Released a new version of Frink: The Next Generation (version 2019-04-21). This merges all changes from the main branch.

2019-04-18

• Improved logarithm functions:
  • The function log[x] (which takes logarithms to base 10) now returns exact integers or rational numbers in cases when arguments are integers and results are integers or 1 divided by an integer.
  • Added the log[x, base] function (which takes logarithms of the number x to the specified base base.) This returns exact integers or rational numbers in most cases when arguments are integers or 1 divided by an integer.

    Note that the ordering of the arguments may be different from other programming languages! This order was chosen because log[x, base] can be rewritten as log[x] / log[base] for any logarithmic function that takes a logarithm to any base.

    This follows the precedent set by functions like arctan[y, x] which is equivalent to arctan[y/x] except the former corrects for ambiguities in the quadrants. Similarly, it's simple to change log[x] / log[base] to log[x, base] without errors.

    Some programming languages have taken the opposite approach, where the first argument is the base and the second argument is the number. This seems like a bad design choice, so be careful when transliterating mathematical expressions from other programming languages.

• Fixed a bug in Java Introspection when working with a Java object that implements java.lang.Iterable. Previously, this eagerly fetched the Iterator from the object and returned the iterator, rather than the whole object itself. This was fine if you just wanted to iterate over the contents of the object, but bad if you wanted to call any of its other methods. You can once again call its methods or use it in a for loop.
• Did more work to partially work around the 21-year-old (I'm not kidding) Java Bug 4071957 and Java Bug 4071593 and Java Bug 4283544 (and the dozens of related bugs) which causes method invocation to fail on classes that are declared private, even if the methods are public and access would be allowed from normal Java code.

  This fix takes a stronger approach to work around these bugs and to mitigate the damage done by Java 9 and later's not-really-useful "module" system (that can never work right in the face of this bug and similar others). The code tries very hard to search for accessible method calls in the class, in its superclasses, and in its implemented interfaces to find and call a method, (that you would be able to call from compiled Java,) but if that fails, it will take the stronger step to call Java's AccessibleObject.setAccessible(true) on the method, and then try calling it again. This fixes a lot of poor design in Java's libraries, especially com.sun.internal classes, and works around the aforementioned bugs that Java has been promising to sorta think about 2 decades ago.

  In Java 9 and later, you might get warnings about "illegal reflective access" if you call a method that has to be called using the stronger methods listed above (to work around the aforementioned Java bugs.) For now, the java command allows you to pass the --illegal-access flag:

  --illegal-access=value : permit or deny access to members of types in named modules by code in unnamed modules. value is one of deny, permit, warn, or debug. "This option will be removed in a future release."

  You might be able to see what extended options your Java Virtual Machine has by executing java -X. You may have to add one of the options, especially --illegal-access=permit to your Frink startup script if you invoke methods that touch these Java bugs in Java 9 or later and you need these warnings silenced.

2019-04-10

• Added the conjugate[x] function to return the complex conjugate of a complex number or array of numbers.

2019-04-04

• Added a copyStream[inputStream, outputStream] function to copy the contents of one java.io.InputStream to a java.io.OutputStream. See the I/O Functions section of the documentation for more details.
• Improved the ZipFile.frink sample program to unzip the contents of a zip file.

2019-03-25

• Updated the floatingPointBase.frink sample program which does base conversions on floating-point numbers. The new version has more correct internal precision calculations to produce more correct digits, and has new options for both parsing and formatting. The updated parseFloat function can produce exact rational numbers or a number with approximately the same number of significant digits as the string being parsed.

2019-03-13

• Released a new version of Frink: The Next Generation (version 2019-03-13). This merges all changes from the main branch.

2019-03-11

• Added method image.show[title] to show an image with the specified title.
• Rewrote the code that writes Fourier-transformed images into a logarithmic magnitude-phase plot and reconstructs them from the aforementioned plot. This removes some numerical instability with larger images that caused large images to fail. See the FourierImage.frink sample program for sample usage.
• The function to resize images, image.resize[width, height] method has been rewritten to use a much better area-averaging filter. This makes scaling of images much cleaner and less random, especially for strong downscaling.
• Added ComplexArray2D.subtract[ComplexArray2D] method to create, say, difference between two images (after calling their .toComplexArray[] methods.) This can be turned back into an image by calling the toImage[] method on the result.

2019-03-10

• Added some solving rules (and removed and generalized some rules) in the experimental powerTransformations.frink to handle equations that included ex and ln[x], and log[x]. These now solve many more equations. It is frankly amazing how adding a single transformation rule makes the solver able to solve huge classes of new equations.
• Added more simplifications for expressions involving ex and ln[x], and log[x] to solvingTransformations.frink. These rules may move. See below.
• Solving transformations may be reorganized and moved around. It is recommended that you include allTransforms.frink and its dependent libraries when writing symbolic solvers.
• The systemSolver2.frink library (that powers amazing stuff like the Frink System Solver) was changed to use allTransforms.frink as mentioned above, instead of including a lot of separate libraries.
• The Grid.frink sample program which allows you to automatically (or manually) add grid coordinates to a graphics object has been improved to provide better labels on the y axis when an "up is positive" orientation is chosen.
• The solve.frink sample program now provides evaluated results for more expressions.

2019-03-08

• Added some solving rules in the experimental powerTransformations.frink to handle equations that included ex and ln[x].
• Updated the Frink Solver page to improve the display when "show work" is enabled. Previously, it could repeat equations that were visually identical but internally different in Frink.

2019-03-07b

• Fixed a bug in the 2-dimensional FFT function when padding to the next power of 2. This caused aliasing or ringing artifacts on one axis of the transformation.

2019-03-07

• Implemented Fast Fourier Transforms (FFT) natively in Frink. (These were previously only available in the Fourier.frink external file) These are drastically faster than the existing DFT functions. The speedup for processing a 2048 by 2048 image is about 334 times. The functions behave similarly, but the FFT functions pad their input to the next largest power of 2, which can give different results.

  See the Fourier Transforms section of the documentation for details.

• Added a sample program, FourierImage.frink, which demonstrates using Fourier transforms to process an image, obtain its Fourier transform, display the Fourier transform in a logarithmic scale, and then invert the transform to produce the original image.
• Released a new version of Frink: The Next Generation (version 2019-02-27). This merges all changes from the main branch.

2019-03-05

• Added toUnicodeSubscript[int] to turn an integer into a Unicode subscript string.

2019-03-04

• Added the dictionary.increment[key, increment] method to allow you to easily use a dictionary to count items. See the Dictionary Methods section of the documentation for more.

2019-03-02

• Fixed the graphics.invertGrays[] method that makes your graphics objects invert their grayscales. Previously, if a graphics object contained other graphics objects, the sub-objects would not have their colors transformed.

2019-03-01

• Updates to several sample libraries:
  • The Grid.frink sample program allows you to automatically (or manually) add grid coordinates to a graphics object. This has been improved in many ways, including adding coordinates based on the new Calendar Functions.

    See sample usage in manhattanhengemoon.frink and simplegraph5.frink.

  • Updated manhattanhengemoon.frink sample program to create an exactly-correct grid using Grid.frink.
  • Updated the amazing simplegraph5.frink program that graphs any function, implicit graph, or inequality. It now automatically adds better coordinates using the Grid.frink library.

2019-02-27

• Released a new version of Frink: The Next Generation (version 2019-02-27). This merges all changes from the main branch.
• Updated Historical British Price Data documentation to indicate that it no longer needs access to the internet. (This has been true for quite a while, but the documentation didn't reflect it.)
• Updated Historical British Price Data with final data for 2018.

2019-02-25

• Added 35 new functions for handling calendar dates. These functions let you handle our world's strange and random calendar dates, including functions to:
  • Given a date, find the beginning of a calendar year, month, day, hour, minute, second, or millisecond. These can use all current and historical timezone rules for the planet to find the rules for that timezone, and that specific date.
  • Given a date, find the beginning of a calendar timestep like a year, month, day, hour, etc., and incrementing or decrementing that timestep by an integer value. For example, find the beginning of the next year, the beginning of the previous year, or the beginning of the year 10 years from now. These are often quite complex and handle timezone offset rules for any timezone and historical period.
  • Added functions to calculate the length of a specific calendar year, month, or day. You would think this is easy but all of these functions produce surprising results. Under some timezone rules, some days (and months) may be an hour longer or shorter than you expect due to Daylight Saving / Summer Time rules! For example, in most US timezones, March is one hour shorter than 31 days because the clocks are set forward one hour (at 2:00 AM on the second Sunday of March)! Similarly, November, 2019 is 31 days, 1 hour long! In other timezones, (like UTC) this shift may not occur. Handling the varying lengths is necessary for consistency in date/time math.
  • Added functions to calculate the length of a specific calendar year, month, or day with leap seconds taken into account! Leap seconds are not taken into account in some calculations for performance (and the element of surprise) but these calculations give the length of a year, month, day with leap seconds considered.
  • Described some algorithms to iterate, through, say, the beginning of each calendar month or day.
  • Updated some sample programs to use these iterators. An example is the mithengesun.frink sample program which now iterates through this year and the next year.

  All of these functions are described in detail in the Calendar Functions section of the documentation.

• Added a new mapList function which performs like the map function but is better for working with lists. It does not have map's behavior of breaking its input into named arguments. Discussion of how to choose the appropriate function is contained in the map section of the documentation.

2019-02-14

• Released a new version of Frink: The Next Generation (version 2019-02-14). This merges all changes from the main branch.

2019-02-13

• Improved the isStrongPseudoprime[num, base(s)] function in several ways:
  • The base can now also be an array of integer bases, in which case all of the bases are tested, bailing out when the number is known to be composite. This may be slightly faster (and easier to code) in some cases. You may be able to use this along with minimal sets of bases (link opens in new window) to make an even faster primality test for smaller numbers.
  • The function now is more careful to work with sets of bases like these minimal sets of bases (link opens in new window). Previously, the test could skip over bases which were larger than the number to be tested.
• Add, Multiply, and Power expressions are now HashingExpressions, and can now be put into sets, dictionaries, etc.
• Function calls are now HashingExpressions, and can now be put into sets, dictionaries, etc.
• The typename of a function call has been changed from Function to FunctionCall.

  This means that when constructing a function call from functions like constructExpression, the typename must be changed in code from Function to FunctionCall. The relevant sample programs have been changed, notably Solver.frink, functionUtils.frink and systemSolver2.frink.

• Added function getFunctionCalls[expr] to return all of the function calls called directly from a specific expression. This does not return functions called recursively, nor resolve the specific function that may be called. This behavior may change.

2019-01-28

• Released a new version of Frink: The Next Generation (version 2019-01-28). This merges all changes from the main branch and fixes one Next-Generation-specific bug:
  • When substitution regular expressions contained the /e modifier (to treat the substitution as a Frink expression,) exceptions could be thrown if the substitution contained a backslash or a dollar sign. The error message was possibly "character to be escaped is missing." This has been fixed.

2019-01-22

• The intersection[arg1, arg2] now behaves better when two interval arguments are passed in. If only one of the arguments has a "main" value, then that main value is preserved in the result.

2019-01-11

• Added an isFunction[expr] function to test if an expression represents a (named or anonymous) function.

2019-01-02

• Fixed a problem in formatting some unit expressions with dimensions, such as (240 m^2 s^-3 kg A^-2)^(1/2) (previously, the left-hand side of the exponentiation operator would not have been parenthesized correctly.)

2018-12-31

• Updated copyright dates for 2019. Happy New Year!
• Updated sanity checks to 2019 for economic routines.
• Updated calculations and predictions for deltaT for 2019. The earth's rotation hasn't been slowing down as much as predicted in the past, and future predictions may need to be researched and updated if new predictions are available.

2018-12-15

• Added a sample program, RiemannPrime.frink, to estimate the number of prime numbers less than n. This gives asymptotically better estimates than LogIntegral.frink, which also gives really good estimates.

2018-12-11

• Added a primes[] function which returns an infinite enumerating expression of the prime numbers starting with 2 and increasing. Note that this will produce infinite output if you even try to print it, so you probably want to call it from a for loop or from something like first[primes[], 100]
• Allowed floating-point numbers to be specified using the ee "exact exponent" indicator, which will turn them into exact rational numbers or integers. For example, the new exact SI value for Avogadro's number 6.02214076ee23 will become an exact integer. The exponents can also be negative, which will usually lead to an exact rational number, such as 6ee-1 which produces the exact rational number 3/5 (exactly 0.6). Previously, only integer mantissas could be specified with the exact exponent indicator.
• Updated the secant.frink file to invert a function more reliably (hopefully eliminating divide-by-zero errors) in the really cool secantInvert function.

2018-12-03

• Added a function first[expr, num] to take the first num items from an expression (which can be an array or potentially infinite enumerating expression.) The result is returned as an enumerating expression.

2018-11-17

• For Android: Fixed a problem that the program would be restarted when the screen was rotated or resized. The implication of this is that Frink must now target API level 13 (Android 3.2). The Frink app in the Google play store reflects this fix.

  Technical Reasons: This is due to the fact that the Google Play store now requires that all applications target API level 26, but API level 13 introduced some not-backwards-compatible changes to the AndroidManifest.xml files. After API level 13, Android fires a screenSize change that needs to be handled when the screen is rotated. However, this property does not exist before API level 13, and updating the target API level breaks application handling of screen rotates. Previously, Frink targeted API level 3 (Android 1.5) and before.

• For old Android devices which are still running from API level 3 (Android 1.5) to API level 12 (Android 3.1,) a frinkold.apk file is downloadable directly from this website.
• Added a clamp[num, min, max] function to limit a number to lie between a minimum and maximum value. This function also works correctly when num is an interval.

2018-11-09

• Rewrote Chinese Numbers class to use more class-level methods. This means you don't have to construct an instance of the class, but rather call class-level methods like ChineseNumbers.formatCasual[123]
• To match the above changes, fixed Chinese number drill Frink Server Page which tests your recognition of Chinese numbers.
• To match the above changes, fixed Chinese number worksheet Frink Server Page to make printable worksheets to test your recognition of Chinese numbers.

2018-11-06

• Added a new library file, curveFit.frink, which performs linear and quadratic curve fitting on an array of points, It also works with units of measure, creates curve-fit functions, and even produces purely symbolic results.

2018-11-05

• Various additions for sun.frink astronomical library, primarily for star positions:
  • apparentPosition: Now can optionally correct for radial velocity and distance in proper motion calculations. This changes the order of arguments to this function.
  • raDeclToEcliptical: This performs conversions from right ascension and declination to ecliptical coordinates. This is symmetric to the eclipticalToRADecl function.
• Updated the mithengeSirius.frink program to calculate with radial velocity. This really doesn't have any appreciable effect.

2018-10-23

• Fixed currency conversions to work again.
• For Android: Updated target platform to Android API 26, as Google is requiring. (Frink still remains 100% compatible with older devices.) This changed lots of colors in the GUI so version 2018-10-23b was released with new colors, padding, and margins. The tool buttons are still too large, though.
• For Android: Graphics are now rendered at a larger size, allowing you to use your device's screen to its fullest!

2018-09-30

• Algorithm dispatcher now detects the upcoming Java 11 and 12.
• Released a new version of Frink: The Next Generation (version 2018-09-30) which merges all changes since 2018-09-04.

2018-09-25

• Frink is now available as "Frink Programming Language" for Kindle Fire in the Amazon App Store.
• Added links to download Frink via the Amazon App Store on the Frink for Android page.
• Added tips about programmers' keyboards and file managers to the Programming Tips section of the Frink for Android documentation.
• Many significant improvements to the Frink Solver page:
  • Shows an error if the "solve for" variable does not exist in the equation being solved for.
  • Flattens out multiple solutions when there are more than 2 solutions.
  • Fixes over-encoded HTML in errors.
  • Separates multiple solutions with blank lines for readability.
  • Fixes HTML errors in unclosed anchors.

2018-09-24

• Removed an incorrect newline that was produced by the code formatters when printing the else part of an if block when the then part of the block has multiple lines. This caused invalid if statements to be generated by the code formatters.

2018-09-12

• Frink is now available (for free!) in the Amazon app store as Frink Programming Language. You can turn your Kindle Fire into a cool programming environment or the most useful calculator ever!

2018-09-10

• Updated the Frink Solver page to better pretty-print some solutions, and made the option to output in raw Frink format work consistently in all output fields.

2018-09-09

• Enabled the HTTP/2 protocol in the Frink servers. This should improve performance for modern web browsers and under heavy load conditions. Please let me know if you have trouble connecting.

2018-09-05

• Released a new version of Frink: The Next Generation (version 2018-09-05) which merges several things:
  • Multiplication fixes that were in the main branch. This also helps solving of systems of equations.
  • GUI fixes that try to work around issues in Java 9 and 10. These handle more code on a separate thread.

2018-09-04

• Added a fixup rule to improve solving some addition expressions. This fixes some issues in solving systems of equations, like one triggered by McKellarPuzzle.frink.
• Improved formatting of code blocks.

2018-09-03

• Made some changes to how bases are chosen in the isPrime[n] primality-testing function's Rabin-Miller implementation for very large numbers. It now again performs some trial division and always tests against bases 2 and 3 first before testing random bases.

2018-09-02

• Released a new version of Frink: The Next Generation which merges all of the current functionality from the main branch.
• Created a new release (2018-09-01) for Android.

2018-09-01

• Updated the isPrime[n] primality-testing function's Rabin-Miller prime test to use 78 random bases instead of 78 deterministic bases. This helps mitigate the impact of adversarially-chosen numbers which are not actually prime.

  See Prime and Prejudice: Primality Testing Under Adversarial Conditions for more about primality-testing weaknesses in software under adversarial conditions. This paper is genius and describes heroic computations to find composite numbers that many modern software packages will mistakenly declare to be prime.

  In some cases, the computations took "a total of 33,885 core-hours (3.87 core-years) of computation in parallel on 872 cores running at 2.4GHz" (p. 13) to find these counter-examples. That's impressive.

  It is a wonderful paper that summarizes a lot of previous results in adversarial primality testing. Read it. Especially read the classic paper François Arnault. Constructing Carmichael numbers which are strong pseudoprimes to several bases. Journal of Symbolic Computation, 20(2):151-161, 1995.

• Added a test program, PrimeAndPrejudice.frink, which tests against the specific numbers found in the above paper. Frink's implementation could mistakenly declare prime the specially-constructed composite numbers in appendices F, G, and H. These specially-constructed numbers are now correctly identified as being composite.

2018-08-30

• Updated the SSL/TLS certificates for https://frinklang.org/. Let me know if you have any trouble connecting.

  Note that Java 1.6 and earlier cannot use Diffie-Hellman key exchange parameters longer than 1024 bits (the site uses 4096 bits.) You should still be able to access the site through any modern web browser, or through Java 1.7 or later.

2018-08-29

• Added an expression constructor to create a pattern that matches anything. For example, to construct a pattern called _n:

  constructExpression["AnythingPattern", ["n"]]
_n

2018-08-28

• Fixed a solving rule in the experimental powerTransformations.frink transformation library to not (sometimes!) conflict with better rules for rational numbers defined in solvingTransformations.frink.
• Revised the experimental powerTransformations.frink transformation library to use the natural log instead of log₁₀ in its solutions, allowing simplification of expressions that use the natural log. For example: this thermodynamics problem.
• Updated the Frink Solver page to display multiple solutions better. Its solutions are once again more correct by the fixing of the above-mentioned rules.
• Added a library, deBruijn.frink, to calculate de Bruijn sequences. When you need them, you'll know.
• Canonicalized a bunch of URLs in sample programs to point to https://frinklang.org/.

2018-08-07

• Made the parser more efficient in some cases.
• Forward-compatibility fixes of the lexer for newer versions of JFlex.
• Released a new version of Frink: The Next Generation with fixes for parsing Unicode identifiers. Previously, you might see error messages for Unicode identifiers, especially when they are represented by two Unicode surrogate characters at the beginning of a line after a line break or semicolon.

2018-07-14

• Released a new version of Frink: The Next Generation with an updated version of the JavaCUP parser generator (version 11b-20160615). This should not contain any user-noticeable changes, but paves the way for such features as syntax completion, improved error messages, fixes potential parser size problems, and more.

2018-05-30

• Released a new version of Frink: The Next Generation (version is called 2018-05-29.) This is still experimental, but you can download and use it now. Improvements include:
  • Improved performance of the floor, ceil, round, and truncate functions. These were significant in some programs.
  • Improved performance of writing graphics to HTML, SVG, and SVGZ formats. Some programs are now up to 13 times faster when writing these files.

2018-05-29

• Added a sample program, Pochhammer.frink, to calculate the Pochhammer function. This function is closely related to the gamma function, which is closely related to the factorial. The implementation also extends the Pochhammer function to negative values of k and even works with symbolic arguments.

2018-05-26

• Updated the Frink Solver page to allow the user to specify the units of measure used to display the result. This page is getting pretty cool.

  Try this ballistics example of a particle being shot upward which lets you calculate for initial height (h0), initial velocity (v0), time (t), gravitational acceleration (gravity) and solve for any one of these variables, both symbolically and numerically. It is neat. It even integrates for you!

2018-05-10

• Updated statistics.frink in a few ways:
  • Fixed a bug in poissonProbability[k,expected] function when k was exactly 1. The function was also simplified and comments were improved.
  • Renamed some variables and comments to be more internally consistent.
  • Added comments describing how the binomial distribution approximates the Poisson distribution in certain cases.

2018-05-08

• There have been some rewrites to the Swing GUI to attempt to work around problems with scrolling and repaint (and weird colors or invisible text) that appeared when running under Java 10 (sigh). It's unclear if this will fix all of the problems, but it seems to eliminate occasional Swing repaint problems in test environments on Fedora.
• If you're running on Java 10, please let me know if you are having repaint troubles in the Swing GUI. Make sure you are using this latest release. Also include information on how you started Frink and your graphics card configuration. In my experience, most GUI weirdnesses are fixed by installing updated graphics drivers from your vendor.
• Suggested command-line for starting Frink:

  java -cp /path/to/frink.jar frink.gui.FrinkStarter --swing

• If your computer runs OpenGL, you can get improved graphics performance (and maybe fewer bugs on Java 10?) by enabling OpenGL rendering with the following command-line option to Java:

  -Dsun.java2d.opengl=True

  (If you write "True" with a capital T then you get debug information that indicates if OpenGL is actually being used. With a lowercase "true" then it's silent.)

  Thus, the command-line becomes:

  java -Dsun.java2d.opengl=True -cp /path/to/frink.jar frink.gui.FrinkStarter --swing

• These changes have not attempted to alter the AWT user interface, but a user reported that running the AWT interface on Ubuntu did not exhibit the same problems. (This was opposite of the experience on Fedora. Double sigh.) To run Frink in AWT mode (which is not recommended; Swing mode is now preferred in general,) try:

  java -cp /path/to/frink.jar frink.gui.FrinkStarter --awt

• Here is a (probably brittle) link from Java on diagnosing rendering issues. It describes how to turn on and off graphics acceleration for various platforms.

2018-05-02

• Fixed currency conversions to work again.

2018-04-26

• Added functions to allow you to compress or decompress files using the GZIP format on the fly. See the Compressing/Decompressing Files section of the documentation for more.
• Added constructors for the Writer class that take java.io.OutputStream or java.io.Writer, so you can easily write to an already-existing stream. This enabled the GZIP compression above.

2018-04-14

• Added isString[expr] function.

2018-04-04

• Updated the Frink Solver page to allow numerical evaluation of the solved equation.
• Added the experimental powerTransformations.frink transformation library to help solve equations with exponents. Note that this only gives real-valued solutions.

2018-03-18

• Frink: The Next Generation has been announced! It's still in testing, but you can download and use it! New features include:
  • Faster floating-point operations, especially with thousands or millions of digits! You can now calculate values with huge numbers of digits in seconds instead of hours or days! (Requires Java 1.8 to get the benefits, as the improvements I contributed to Java to make this possible were first included in Java 1.8.)

    For example, when multiplying two 10-million-digit floating-point numbers, the time is reduced from over 9 days down to 62 seconds!

    When calculating 3 million digits of pi, it used to take about a day. Now it can be calculated in just over 3 minutes! Try it with piChudnovskyNew.frink!

  • Modernized regular expressions with better Unicode support and lots of new features, including named matches!
  • JFlex upgrade to 1.6.1 which gives improved Unicode support in the parser, including better emoji support, better subscript support, and performance improvements.

  See the new Experimental Frink Features for detailed information on all these features!

• Note that Frink: The Next Generation requires at least Java 1.6 to run, and Java 1.8 to take advantage of the faster numerics.
• The Experimental Frink Features page has been officially announced. Read that page for lots of details on these new features! And watch it for documentation of powerful features that may have existed in your version of Frink but were never officially documented!

2018-02-28

• Dictionaries can now be tested for equality with each other.
• Improved equality tests for all hashing expressions.
• Dictionaries are now pretty-printed more nicely in the default formatter. They are now printed on multiple lines and properly indented, making them easier for a human to understand.

2018-02-20

• No major new features, but fixed a build issue that might have affected people running on Java 1.6 or 1.7.
• Fixed a problem when printing a regular expression.

2018-02-13

• Fixed a bug in the command-line options that didn't set the window width or height correctly. See the GUI Options section of the documentation for more.
• Made the --width and --height command-line options also work with SwingInteractivePanel.
• Added a command-line option --fontsize int to set the font size of frink.gui.InteractivePanel or frink.gui.SwingInteractivePanel or frink.gui.FullScreenAWTStarter.
• Made changes to the mod operator to improve containment, specifically when using imprecise floating-point arguments in the cases where numeric precision is being lost (such as when one argument is much bigger than the other.) When no meaningful result can be given, this can now return 0.

2018-01-28

• For Android: Fixed a bug where text in graphics may have been rendered at the wrong size. Please update.
• For Android: Normalized font names so that programs will work the same on Java and Android.

2018-01-14

• Added some performance optimizations:
  • Improved calling functions that are called by a variable name.
  • Optimized calling of blocks with empty bodies.
  • These reduced the runtime of some programs by 40%.

2018-01-09

• Important: Fixed a bug in the range operator (that is, any loop that contains the to keyword) that might have caused infinite loops when the ends of the loop were near or exactly 2³¹-1 or, when counting downwards, around -2³¹.

2018-01-02

• Added isDate[expr] which returns true if the expression is a date/time, false otherwise.
• Updated prediction of deltaT to be constantly 69.184 s through the end of 2018 (previously, this was only the prediction through July 1, 2018. It has not yet been announced if a leap second will be added on that date, but an announcement is expected within the next 6 days. Update: It was announced on 2018-01-09 that there would be no leap second introduced at the end of June 2018. (link opens in new window.)
• Fixed a crash when calculating deltaT around the year 1988.
• Future predictions of deltaT will probably use a variety of data sources, including:
  • Curve fits by Espenak and Meeus (link opens in new window) which were last updated about 2005 and may diverge from current best predictions.
  • U.S. Naval Observatory historical tabulations of deltaT from 1973-(approximate) present (link opens in new window) which are supposed to be updated "quarterly" but are now more than 6 months out of date.
  • USNO predictions for the next 8 years (link opens in new window) Note that these have rather large error margins (about 5 seconds in the next 8 years.)
  • It should be noted, however, that these data sources do not and will not always agree with each other. It's apparently difficult to predict the future.

2017-11-31

• Updated copyright dates for 2018. Happy New Year!
• Updated sanity checks to 2018 for economic routines.

2017-11-30

• Allowed graphics objects to control their antialiasing behavior. The antialiasing behavior of graphics and text can now be controlled (separately.) This allows better-looking rendering of many adjacent rectangles to look more like pixels, without lighter lines connecting them.
• Added an image.makeMono[] method to the image class. This allows an image to be converted to a 1-bit monochrome image, if supported by your platform. Android currently does not support monochrome Bitmaps so this does nothing on Android.

2017-11-16

• Rewrote the internals of the mod and div operators for better performance, especially for integer values.

2017-11-15

• Fixed a build issue where the TAI timezone class might not have been included in the build.
• Improved parsing and formatting of Julian Day (JD), Modified Julian Day (MJD), and Julian Day Ephemeris (JDE), especially when intervals of dates are passed in.
• Improved construction of date intervals. Construction of date intervals now follows the collapseIntervals function's directives for degenerate intervals. Sanity checks were also improved.
• Improved automatic mapping of Frink types to/from Java's BigInteger and BigDecimal.

2017-11-14

• Important: Fixed a bug in constructing rational numbers when the numerator or denominator is exactly -2³¹. Please update as soon as possible.
• This bug could also affect the div operator when one of its arguments was exactly -2³¹.
• Removed some unused code.

2017-11-01

• Rewrote the incomplete time zone definition TAI (also called International Atomic Time) which was hiding in the code and hard-coded to an old offset. The new definition takes into account not only historical and announced future leap seconds, but also interpolates for the period from 1961 January 1 to 1972 January 1 where the difference between TAI and UTC was constantly and linearly interpolated. For more information see the Leap Seconds section of the documentation.

2017-10-23

• Behavior change: Modified the GeneralPath.addPoint[x, y] method to more closely match polygon or polyline. If the point added is the first point, this does a moveTo the specified point. If there are previous points, this does a lineTo the specified point. This may simplify code by eliminating the initial moveTo call and allows easy migration from polygon or polyline to GeneralPath.
• Behavior change: The GeneralPath.close[] method now explicitly forces you to add a moveTo or addPoint before starting a new curve. This how the documentation always insisted that you do things, but the code might have implicitly allowed the previous point to be used.
• Improved error messages when something goes wrong in JSON parsing.
• Fixed a potential performance problem in the floor, ceil, trunc, and int functions.
• Many Frink Server Pages examples are now more mobile-friendly.

2017-09-30

• Extended the select[list, substr] function to allow a substring as the second argument. This will return items which contain the specified substring (with an exact match.) If you need a case-insensitive match, the second argument should be a regular expression.
• A new function, timezones[pattern] was added, allowing you to list timezones that match any pattern that match the specified pattern. The pattern can be anything matched by the select function: that is, a function (that returns true for matches,) a regular expression, or an exact substring.

2017-09-13

• Further improvements to the JSON parsing function, including improvments when empty arrays are encountered.
• Graphics can now be rendered to the SVGZ format, (which is the existing Scalable Vector Graphics (SVG) format that Frink could render to before,) but compressed using the GZIP compression algorithm. Since SVG files usually contain a lot of repetition, using this format will significantly reduce file size and should be parseable by most programs that can handle SVG files.

  Unfortunately, when testing this, I found out that the common image viewer "Eye of Gnome" (eog) or "Eye of Mate" (eom) chokes on large SVGZ files with a "huge input lookup" error. (It opens the same uncompressed file just fine.) I have filed a bug here.

2017-09-07

• Fixed problems with the JSON parsing function JSONParse[str]:
  • Floating-point numbers can now be negative. This threw a parsing error before.
  • Arrays can now be empty.
  • Improved error messages when parsing errors occurred.

2017-08-19

• Fixed the eclipse.frink sample program that calculates solar and lunar eclipses in several ways:
  • Fixed drawing of the moon and sun, especially near the zenith. Previous drawings got worse the higher in the sky the eclipse occurred.
  • Now calculates the percentage of solar eclipse.
  • The program now renders an animation of the path of the moon and sun.

2017-08-17

• Implemented some missing hyperbolic trigonometric functions:
  • csch[x]: Hyperbolic cosecant of x, equivalent to 1/sinh[x], or 2/(e^x - e^-x). For some reason, arccsch[x] was already implemented.
  • sech[x]: Hyperbolic secant of x, equivalent to 1/cosh[x], (which was already implemented,) or 2/(e^x - e^-x)
  • arcsech[x]: Inverse hyperbolic secant of x, or ln[sqrt[1/x - 1]*sqrt[1 + 1/x] + 1/x]
  • coth[x]: Hyperbolic cotangent of x, (e^2x + 1) / (e^2x - 1)
  • arccoth[x]: Inverse hyperbolic cotangent of x, or 1/2 ( ln[1 + 1/x] - ln[1 - 1/x] )

2017-08-15

• Behavior change: Made the Writer class try harder to use platform-specific newline characters in its println method.
• Added zero-argument writeln[] and println[] methods to simply append a newline to the file.
• There are also subtle internal changes to buffering:
  • A buffer is now always used by default, even when a buffer size is not specified, so you may need to call flush more often if you need data to be written immediately.
  • If you do not specify a buffer size, the file is still flushed on each println. If you do specify a buffer size, you will need to flush manually (this is to let you squeeze out a bit more performance.)

2017-07-08

• Behavior change: Fixed some handling of command-line arguments in the GUI, especially in programming mode. Note that this may change behavior of some programs, depending on how you launch Frink:
  • Specifying your own units file using the -u filename command-line option now also applies to programming mode in the GUI, and not just to interactive mode. Be warned if you're loading a custom units file.
  • This change applies to all command-line options. Options which were previously only applied to interactive mode are now applied to programming mode also.
  • Eliminated some possible error messages when launching Frink using the -open filename option. (This is how double-clicking a .frink file works in Windows or some Linux environments with the proper file association set.)
• Fixed the definition of paper areal densities like poundbookpaper which had incorrect dimensions.

  If you wanted to estimate the mass of a U.S. letter page of "20 pound bond" paper, you could calculate it as:

  20 poundbondpaper * 11 in * 8.5 in -> "grams"
4.5359237 grams

• Added the dimension combination area_density to describe the mass density per area of a sheet of something, such as kg/m^2.
• Thanks to Nathan Schiffer for an excellent bug report on most of the previous issues (and some that I have yet to research.)
• Improved the error message when a user-defined sorting function does not return integer values.
• Fixed a problem when using a custom data file that defines the radian as a fundamental dimension. (You really don't ever want to do this, unless you're having a really hard time debugging an example that uses angles.) The inverse trigonometric functions like arcsin and arccos were not returning the results with dimensions of radians, and possibly producing conformance errors.

2017-06-29

• Fixed the definition of specific_volume from its incorrect value m^3 kg to the correct m^3 kg^-1. Thanks to Benjamin Zax for the correction.

2017-05-27

• Further enhanced the functionUtils.frink to add functions helpful for solving an equation.
• Enhanced the functionUtilsTest.frink to include a sample of solving an equation both symbolically and obtaining a numerical solution or set of solutions.

2017-05-25

• Added an interesting new library, functionUtils.frink, which provides simple ways of manipulating parts of functions and expressions, including obtaining the body of a function and its argument list. It also has simple functions that, along with other libraries, will help you easily obtain the derivative and integral of a function.

  This will make it easier to perform symbolic transformations and calculus on functions and expressions that may not have been written with calculus or symbolic transformations in mind. It will also be useful in finding the minimum/maximum of expressions, graphing, inverting equations, and solving equations both numerically and with exact symbolic results. (Many of these are performed much more efficiently and exactly if you know the derivative of the function. For example, Newton's method requires knowing the derivative of a function.)

• As a demonstration of the above, added a test library, functionUtilsTest.frink, which demonstrates taking the derivatives and integral of functions.

2017-05-20

• Added a copy constructor for Polygons and Polylines. This makes it easier to do things like creating stroked and filled polygons.

2017-05-17

• Updated the stellarMagnitude.frink sample program to allow easier calculations of stellar magnitudes, power fluxes, and apparent brightnesses. It additionally adds functions to calculate photon energies, frequencies, or wavelengths given one of the other variables.

2017-05-09

• Added a ConvexHull.frink sample program to calculate (and optionally graph) the convex hull of a bunch of points using the Graham scan algorithm (which is O(n log n) ).

2017-05-06

• Reinstated translations to and from Polish and Greek.
• The graphics.write... methods now allow you to specify exactly one of the width or height as undef, the undefined axis will be calculated from the defined width or height and the aspect ratio of the graphics that is being drawn.
• Added --prog command-line option to start Frink in programming mode directly from the FrinkStarter class.
• Fixed a potential problem with the -open filename command-line option if passed a relative filename without a parent.

2017-04-26

• Added a cool new graphics.invertGrays[] function that makes your graphics objects invert their grayscales so you can easily make a single graphics object that looks like Wargames (black background, white lines) for on-screen display but doesn't waste your printer ink (white background, black lines) when printed. Shall we play a game?

  For more information, see the Showing Graphics section of the documentation.

2017-04-24

• Enhanced functionality for Polygons and Polylines:
  • The constructor for polygon, filledPolygon, and polyline can now take a list of points.

    a = [ [1,3], [7,4], [6,2] ]
p = new polygon[a]

• Added the following methods to polygon, filledPolygon, and polyline. See Polygon Methods for more information on any of these.
  • .getPoints[] returns a list of the points in a polygon.
  • .getArea[] calculates the area of the polygon.
  • .getCentroid[] returns the centroid of the polygon as an [x,y] array.
  • Added a .show[] method to easily display a polygon without adding it to a graphics object.

2017-04-18

• Improved the correctness of the experimental gamma function when a small number of digits is requested.

2017-04-13

• Added a previousPrime[n] to efficiently return the previous prime number less than n. This complements the existing nextPrime[n] function.

2017-04-12

• Drastically improved performance of parsing strings to integers. This introduces a divide-and-conquer algorithm of my own devising that improves Java's native parsing of strings to integers by several orders of magnitude for very large numbers. For example, parsing the largest-known Mersenne prime 2^74207281-1 went from 13124 seconds (that's about 218 minutes) down to 68.392 s (just over a minute), a factor of 192 times faster!
• This improvement makes parsing of giant numbers from Java's worse-than O(n²) to about O(n^1.513) at 10 million digits (with a good constant.)

  This improvement works whenever Frink parses a large integer.

• I may try to contribute these algorithms to Java. It took 11 years for Java people to check in my vastly improved algorithms for multiplication and base conversion for large integers, though. These are finally part of Java 8.
• Improved speed and memory usage of parsing integers from strings, with knowledge of each radix. When numbers between 6 and 9 digits are parsed (in base 10), parsing is now significantly faster and uses less memory. These improvements occur for all bases from 2 to 36.

2017-04-04

• Various performance improvements for factorials and binomial coefficients were added:
  • For very large factorials or binomial coefficients, performance has been increased by orders of magnitude.
  • Giant factorials (those over 10000! using either the ! operator or the factorial[n] function) now use a binary splitting algorithm which makes them significantly faster on Java 1.8 and later. (Did you know that Java 1.8's BigInteger calculations got drastically faster because Frink's internal algorithms were contributed to it?)
  • The function factorialRatio[a, b] was added, which allows efficient calculation of the ratio of two factorials a! / b!, using a binary splitting algorithm.
  • As of the 2017-04-04 release, functions that calculate binomial coefficients like binomial[m,n] that calculate binomial coefficients are more efficient because of the use of binary splitting algorithms.

    Note: binomial[m,n] is of the number of ways m things can be chosen n at a time, with order being unimportant. This is sometimes called "m choose n" or "m C n". This is equivalent to m!/(n! (m-n)!) although calculating that way often leads to way-too-big numbers. For example, binomial[10000, 9998] is equal to 49995000, but if you calculated it naively, you'd have to calculate 10000! which is a 35660-digit number, and divide it by another huge number, which could be inefficient and slow.

  • Added a section on the implementation of Factorials to the main documentation.

2017-03-13

• For Android: Fixed the call to getSensorService[type] which may not have worked on newer versions of Android. (It worked fine if you used the two-argument version getSensorService[type, updateFrequency].)

2017-03-12

• For Android: Several improvements to allow Frink programs (with the extension .frink) to be loaded from your device's file manager:
  • Files can now be opened from remote sources like Google Drive or other cloud-based filesystems.
  • Fixes to operate with Android 6 and 7's method of opening files by sending intents with a content: URI.
  • Warning: opening programs from a file manager may make use statements in your program not work correctly due to the opaqueness and security mechanisms built into content: URLs. Frink may make attempts to work around these issues in the future.
  • Fixes/workarounds for opening files from a file manager with the .frink extension. This works around some limitations of Android's pathPattern implementation.
  • Note: Your file manager has to actually try to open the file (that is, send an intent with the VIEW action for the file). Several file managers just keep their own useless list of file types that they try to open and refuse to actually try to open files that your device knows hows to open.

2017-02-17

• Improvements to the function suggester.
• Some units of volume are now made exact, including the jeroboam, rehoboam, nebuchadnezzar, etc.
• Improvements to the continuedFraction.frink sample library, including better detection of when working precision is exceeded. This will eventually become part of the standard distribution.
• Added a similarUnits.frink library which suggests units that are similar to a specified value. This may someday become part of the standard distribution.
• Algorithm dispatcher now detects the upcoming Java 10.

2017-02-08

• Fixed a bug when rendering HTML graphics. If the computer was set to certain locales (e.g. German), alpha channel opacity levels would be rendered with a comma decimal separator instead of a period. Thanks to Alexander Kosenkov for the report.
• Opacity levels in SVG files are now rounded to 3 decimal places.
• Improved performance of primality testing for mid-sized numbers. Thanks to the work of Sorenson and Webster, isPrime[n] is now guaranteed to prove primality for numbers up to 3,317,044,064,679,887,385,961,981, and uses a smaller number of pseudoprime tests up to this value, improving performance of both primality testing and factorization.

2017-02-07

• Fixed a bug that affected some functions that take other functions as arguments, such as sort[array, function]. If the passed-in function had multiple return statements instead of a single simpler expression, it might not behave correctly. (For example, in the case of sort the array might not be fully sorted.) This may have affected:
  • sort functions with user-defined comparison functions.
  • map
  • select
  • Constraint functions
• The internals of function calling have been revised and improved to prevent this type of error in the future.

2017-02-03

• Fixed a bug in the Web Interface that broke the ability to set variables persistently.

2017-01-14

• Added a rangeOf[array] which returns an enumeration of all the indices in an array:

  a = ["zero", "one", "two"]
for i = rangeOf[a]
   println["index $i contains " + a@i]
index 0 contains zero
index 1 contains one
index 2 contains two


2017-01-07

• If you try to call a function that doesn't exist, Frink will now try to suggest functions (and methods, if called from within a class) with similar spellings and argument lists:

  angles[]
No function match found for angles with 0 arguments.
Suggestions:
  Functions:
   Ingles[arg1]
   Inglês[arg1]
   Inglés[arg1]
   Engels[arg1]
   Inglese[arg1]
   Anglais[arg1]


• Made some improvements to the Web Interface to preserve some of the formatting that the Frink interpreter emits, especially for error messages.

2017-01-01

• Updated copyright dates for 2017. Happy New Year!
• Updated sanity checks to 2017 for economic routines.
• Researched future deltaT predictions for the year 2017 and later. The earth's rotation hasn't been slowing down as much as predicted in the past, and future predictions may need to be researched and updated if new predictions are available.
• Verified the leap second added at the end of 2016 is being calculated correctly. Frink has taken this into account since the date it was announced, 2016-07-06. For more information see the Leap Seconds section of the documentation.
• Internal changes to Frink Server Pages that will allow them to have their own function sources relevant to servlets.

2016-12-30

• Behavior change: Improved the behavior of the eval[expr] and unsafeEval[expr] functions to behave better when evaluating an expression containing an already-compiled list of statements (that is, a multi-line program compiled with parseToExpression[str].) It now behaves much more similarly to running that program directly. It now returns the same return value as running the program would, rather than the odd previous behavior of returning an array of results from each statement.

2016-12-21

• Improved the performance of the algorithm to calculate autocorrelation of a list of values in correlation.frink.

2016-11-29

• Improved some error messages, especially in the cases of class members with constraints.

2016-11-28

• Fixed a bug in getBit[n, bit] that affected n that would fit into a 32-bit integer and where the requested bit was outside of the integer. Thanks to Jeremy Roach for the research and bug report.
• Improved the error message for a function definition that incorrectly uses = instead of :=

2016-11-15

• Fixed currency conversions to work again.

2016-11-14

• Fixed a bug in the two-argument read[URL, encoding] function to read from a file or a URL where you specify the encoding of the file or URL. The encoding might have been ignored.

2016-11-06

• Enhanced the DiscreteDistribution.frink sample library (which allows you to choose between items with a specified probability distribution) to also allow efficient selection of a deterministic item from the distribution.
• Fixed the Bitcoin example in the documentation to match Coindesk's dropping of HTTPS access.
• Fixed the bitcoin.frink sample program to match Coindesk's dropping of HTTPS access.

2016-11-02

• Added the graphemeLength[str] function which returns the length of a string in graphemes, counting multiple Unicode codepoints that should be combined together as a single display glyph as a single character. See the Correct String Parsing section of the documentation for more details.
• Fixed obscure classloading problems that only seemed to manifest themselves when run on an odd configuration (e.g. Tomcat 4 with a custom classloader running on Java 1.4). These might show up as a failure to initialize something like class frink.text.c. This may also fix running on a Java 1.6 or 1.7 JVM.

2016-10-28

• Fixed the build for the experimental compiled Windows Frink binary. This is not the best way to run Frink at all, but there it is.
• Fixed the build of FrinkSamples.zip which contains all of the sample Frink programs available on the sample programs page.

2016-10-27

• To complement the lexicalSort functions, there are now similar methods that compare two strings using human language rules and Unicode normalization:
  • lexicalCompare[string1, string2]: Compares 2 strings using a comparison method that understands human languages. This version uses the default locale and language settings defined on your Java Virtual Machine to perform the comparison.
  • lexicalCompare[string1, string2, languageCode]: Like the previous function, this compares 2 strings using a comparison method that understands human languages. This version uses a specified language. The argument languageCode can be one of three types:
    • A string containing a 2-letter ISO 639-1 code for the language, such as "en" for English.
    • A java.text.Collator
    • A java.util.Locale
• See the Lexical Sorting section of the documentation for more details on how powerful these functions are.

2016-10-26

• Backward compatibility fix for Java before 1.4. (The constructor Locale(String language) did not exist, so if you're on a very old JVM, you'll have to construct Locales manually with a language and a country.)
• Improved error messages when strange characters are encountered in input.
• Removed information about obsolete technologies from the documentation (e.g. Mac dashboard widgets, google gadgets, Sherlock search plugins, Palm compatibility, browser keywords, Palm devices, etc.) Frink has outlived you all.

2016-10-25

• There is now powerful new functionality for sorting strings according to human language rules. These allow correct handling of accented characters and easy sorting according to the rules of many, many human languages. The sorting is mostly encapsulated into the new lexicalSort functions:
  • lexicalSort[array] sorts an array of strings using the default language and locale settings defined in your Java Virtual Machine.
  • lexicalSort[array, languageCode] sorts according to the rules of the specified human language. languageCode is the ISO 639-1 two-letter code for the language.

    If you need extreme control over the sorting order, languageCode can also be either a java.text.Collator or a java.util.Locale object which allows you very detailed control over creating custom sorting rules or locales. Please see the documentation for those classes for details on controlling sorting.

  • These allow Frink programs to sort many, many human languages correctly and easily, and allow correct internationalization and handling of strings, and make you look really smart.
  • See the Lexical Sorting section of the documentation for more details on these functions.
  • Some functions that sort their output (e.g. the "help" operator) that sort their output now sort them using correct lexical sorting order.
  • There is a huge amount of power and functionality hidden in these simple-looking functions. If you use them, you will be right more often than wrong if you choose the correct language.
• Made several usability and functionality improvements to the Swing and AWT user interfaces:
  • There are now quick keys (control-minus and control-equals) for increasing and decreasing the size of the fonts used.
  • Several improvements to focusing and scrolling.
  • The AWT output dialog from programming mode is now non-modal.
• Updated the source for U.S. historical currency conversions to read from a new location, specifically here.
• Added new named dimension combinations gravitational_constant and electric_force_constant so the -> operator could suggest their use in common calculations.

2016-10-20

• Frink's comparison operators, such as < , == , >= , including the three-way comparison operator <=> can now compare Java objects that implement the java.lang.Comparable interface. This includes numeric types, strings, and many other types.

2016-10-19

• Frink can now sort Java arrays directly and in-place if they implement the Comparable interface.
• Many improvements to sample libraries that provide arbitrary-precision calculations:
  • ArbitraryPrecision.frink: Added arbitrary-precision power function, improved natural log, cosine, sine, tangent, and exponentiation functions.
  • Gamma.frink: Contains a working arbitrary-precision calculator for the gamma function (a generalization of the factorial function) which works for large and small arguments.
  • pi.frink: Fixed cases where the number of digits requested is small.

2016-10-18

• Added normalizeUnicode[string, method="NFC"] function. This function normalizes the characters in a Unicode string using one of the methods described in the Unicode standard, specifically Unicode Standard Annex #15, Unicode Normalization Forms.

  A Unicode string can use various methods to encode what is essentially the same character/glyph. For example, the character ô can be represented as either "\u00F4" or "\u006F\u0302". The former is a "composed" character, "LATIN SMALL LETTER O WITH CIRCUMFLEX", and the latter is two Unicode codepoints, an o followed by "COMBINING CIRCUMFLEX ACCENT". (This is usually referred to as a "decomposed" representation.) This function can convert these "equivalent" encodings into a canonical representation, whether it be composed or decomposed.

  Unicode Standard Annex #15 currently defines four different methods of converting between these representations. (You might get the best idea of the differences between these by looking at figure 6 in the document.)

  See the Correct String Parsing section of the documentation for more details on this function.

2016-10-14

• Minor usability fixes to the AWT and Swing user interfaces:
  • When loading a program in programming mode, the file is scrolled to the top instead of the bottom.
  • Tried harder to keep output window scrolled to the bottom in AWT and Swing.

2016-09-29

• Behavior change: When converting from Java byte to Frink types, bytes are now always returned as positive, unsigned values. That is, you no longer see Java's weird negative bytes that nobody in the world has ever wanted. (You could always convert numbers up to 255 into bytes, so this behavior change is only on output. You can still put negative numbers from -128 to -1 into bytes, but they'll be made into positive values when converted back to Frink types. This does not change their representation in Java objects.)

  If your program did any of the following to work around signed bytes, it will still work fine:

  if (byte < 0)
   byte = byte + 256

  byte = (byte + 256) mod 256

• Possible behavior change: The messageDigest functions now force their input to be converted to bytes using the UTF-8 encoding before hashing. Previously, they used your platform's default encoding (which was likely UTF-8 already) but which may not have been portable from one system to another. See the Cryptographic Functions section of the documentation for more details on how to modify this behavior.
• The messageDigest functions have been improved in several ways:
  • All messageDigest functions can now take an array of Java bytes as input.
  • Added a messageDigestBytes[input, algorithm] function to return the message digest as an array of Java bytes. Note: Most of the underlying cryptography routines in Java work with arrays of bytes, as these are safer than Strings which are immutable after construction and are eventually garbage-collected. Using arrays of bytes means that you can zero-out input buffers as soon as you're done with them.
  • Internal changes to ensure more reliable operations on platforms with sketchy implementations or strange encodings that can't encode all characters.
  • See the Cryptographic Functions section of the documentation for more details.
• Added functions to convert strings to an array of bytes (with specified encoding) and vice versa:
  • stringToBytes[str, encoding="UTF-8"] turns a string into an array of Java bytes using the specified encoding. The encoding defaults to UTF-8, but can be a string indicating any encoding supported on your system.

    See the encodings.frink sample program to see how to list all character encodings (and their aliases) available on your system.

  • bytesToString[bytes, encoding="UTF-8"] turns a Java array of bytes into a string using the specified encoding. The encoding defaults to UTF-8, but can be a string indicating any encoding supported on your system.
  • See the Other String Functions section of the documentation for more.

2016-09-21

• Possible functionality change: Improved the behavior of parsing user-defined date/time formats.

  The new behavior is that user-defined date formats are given precedence when parsing. Frink will first attempt to match any user-defined date format, and, failing this, will attempt to match one of the formats in the default date formats file. This prevents ambiguity when two different patterns can match the same date. This usually happens only when a user-defined format uses a two-digit year (please don't do this, as even humans can't distinguish what format is intended in many cases. Learn from the lessons of Y2K, and prefer date formats like ISO-8601 where significant digits are first, like yyyy-MM-dd.)

  This should not change the behavior of any program that worked correctly before, but might change the behavior of a program which was spuriously matching patterns incorrectly. Thanks to Jerrett Townsend for the bug report.

• Frink can now parse Unicode superscript numbers as indicating exponentiation, such as 10⁻²³, which is equivalent to writing 10^-23, or x³, which is equivalent to x^3. See the Unicode Operators section of the documentation for more discussion and caveats.
• Added and documented several Unicode operators as synonyms for multiplication and division. This makes it easier to cut and paste mathematical expressions from other sources and do the right thing with them. See the Unicode Operators section of the documentation for more details.

2016-09-15

• Added function toUnicodeSuperscript[int] to turn an integer into a string containing the equivalent Unicode superscript digits in base 10.
• Added internal functions to more efficiently perform base conversions with custom alphabets, especially with smaller numbers.
• RingBuffer is now deep copyable with the deepCopy[expr] function.

2016-08-31

• Added RingBuffer.isFull[] method.

2016-08-30

• Added a RingBuffer class that is useful for making efficient limited-sized queues and caches.

2016-08-21

• Added a DiscreteDistribution.frink sample library which allows you to choose between items with a specified probability distribution.

2016-07-24

• For Android: Fixed a potential crash when trying to load from a partition that isn't actually there.

2016-07-18

• For Android: Frink now tries harder to request that your Android device does not auto-correct text in Frink's entry fields. Because that will make you insane when programming. Be warned that some third-party keyboards like SwiftKey will still autocorrect even though applications state that fields should not be autocorrected.

2016-07-11

• Added a demonstration of sending e-mails, SMS, or other messages from Android. See the Sending Intents section of the android documentation.

2016-07-08

• The padLeft[str, width, padChar] and padRight[str, width, padChar] functions can now take an arbitrary expression (instead of just a string) as the first argument. This makes it easier to pad numbers (but to be safe, you probably want to make sure that they're stringified correctly first.)
• The output of the timezones[] function is now sorted.

2016-07-07

• Fixed a case in the "help" operator when only functions were matched. This could cause NullPointerExceptions. Thanks to Louis Blaine for the bug report.

2016-07-06

• Behavior change: Output from the double-question-mark "help" operator is now correctly displayed. It was possible that one of the lines was incorrectly appended to the other. In addition, instead of returning a list of strings, the double-question-mark help operator now returns a single string. The single-question-mark's behavior remains unchanged, other than still being sorted.
• It was announced today that a leap second will be added at the end of December 2016. Validated that Frink's internal data file (loaded from the US Naval Observatory's tabulation of leap seconds) has the new leap second. For more information see the Leap Seconds section of the documentation.
• Updated deltaT calculations with the new leap second.

2016-06-25

• Output from the "help" operator is now sorted, first by unit names and then by function names.
• Function descriptors can now be sorted and compared.

2016-06-07

• Added the array.transpose[] method to transpose the elements of a 2-dimensional array, like in matrix calculations. This means that rows and columns are swapped. In other words, the element at array@i@j becomes the element at array@j@i.
• Updated the Matrix.frink sample library to use the above-mentioned transpose function.

2016-05-29

• Added the function lineBreakList[string] which returns an enumeration of the places that a line can be broken. It correctly handles punctuation, numbers, and hyphenated words. See the Correct String Parsing section of the documentation for more details.

2016-05-28

• Functionality Change: Improved the reverse[str] function which reverses a string. This is now a smarter reversal that follows Unicode rules to keep combining characters and graphemes together and properly ordered.

  For example, the string "g\u0308o" represents a g with combining diaeresis followed by the letter o. Or, in other words, "g̈o". Reversing this naïvely would cause the diaeresis to incorrectly show over the o instead of the g.

  As another example, the Devanagari string "\u0915\u094D\u0937\u093F" (shown as क्षि ) is recognized as a single grapheme and the 4 Unicode codepoints that make it up are kept intact and not reversed.

  If you, for some reason, need the old behavior, you can do something like:

  reverse[charList[string]]

  but keep in mind that this will still do many of the right things like keeping surrogate pairs ordered correctly. Don't do this. It's never right for Unicode strings. Frink tries to always work on Unicode strings, and not individual characters, as working on individual characters or codepoints is almost always the wrong thing to do when processing Unicode.

• Added methods to break up strings and iterate among their parts. Each of these returns an enumerating expression that allows you to loop through the parts of a string. See the Correct String Parsing section of the documentation for more details on the following:
  • graphemeList[string]: Enumerates through the graphemes of a string.
  • wordList[string]: Enumerates through the words of a string.
  • sentenceList[string]: Enumerates through the sentences of a string.

2016-05-04

• Added the ability to perform base conversions with custom alphabets.

  This allows you to both parse and format numbers in another base using a custom character set (as opposed to, say, the typical "0123456789abcdef" alphabet of base 16.) It also allows you to do custom base conversions well above base 36.

  The examples show how to format and parse numbers in Bitcoin address format, Devanagari, and Unicode Superscripts

2016-04-02

• Added image.resize[width, height] method to resize an image to the new specified width and height and returns a new image. It does not modify the original image. If either width or height are the special value undef or 0, then one dimension is constrained and the other dimension is calculated to preserve the aspect ratio of the original image.

2016-03-31

• Added multiplication by scalar to the Matrix.frink sample program.
• Added functions to calculate inverse transformation matrices in the geometry.frink sample program.
• Internal code additions to coordinate transforms and graphics views. These are intended to help pave the way for clickable, interactive graphics.

2016-03-30

• Added removeSlice[array, start, end] and removeSliceLength[array, start, length] functions to remove a "slice" from an array. These are the inverses of the previously-existing slice[array, start, end] and sliceLength[array, start, length] functions. See the Slicing Arrays section of the documentation for more.
• Reorganized the documentation for array methods to make it more readable.

2016-03-29

• Rewrote exponentiation of complex numbers where the power is an exact (positive or negative) integer. For example, (3 + 2i)^3 or (3 + 1/2 i)^4. Results are improved in several ways:
  • Results are now complex numbers made up of exact integers or rational numbers when possible. (Previously, they were just exact up to powers of 2.)
  • Much larger or smaller results can now be obtained (previously, results were limited to IEEE-754 exponent ranges.) This is true even if the base is not composed of exact integers or rational numbers.
  • Floating-point errors are decreased or eliminated.
  • Increased precision is available even when the base contains floating-point numbers.
• Thanks to Udi Finkelstein for the suggestions/bug report.

2016-03-01

• Various additions for sun.frink astronomical library, primarily for star positions:
  • apparentPosition: Calculates the apparent position of a star, correcting for proper motion, precession, nutation, and annual aberration.
  • longitudeOfEarthPerihelion: Calculates location of earth's perihelion
  • highAccuracyNutationInRADecl: Calculates nutation in right ascension and declination coordinates.
  • annualAberration: Calculates the effect of annual aberration.
  • precess: Calculates precession of the earth's axis.
• Added HMS functions to convert times to hours, minutes, and seconds, or to parse times given as hours, minutes, and seconds.

2016-02-10

• Minor fixes to historical currency calculations:
  • U.S. historical currency conversions now calculate the average for the previous year as soon as data for December is available.
  • Historical British Price Data is now updated with the recently-published 2015 figures.

2016-02-01

• Fixed a potential problem in the build of the frink.jar that might have prevented the use of high Unicode characters in Frink programs. This did not affect Android.

2016-01-14

• Completely rewrote the routines that provide Historical British Price Data. These should now work again, be more up-to-date, and initialize faster and more lazily.

2016-01-05

• Wrote a cool demonstration program greatCircleMap.frink which draws world maps centered on your location. This is based on the previous drawCountries.frink program which draws maps with different projections.
• Updated the Country.frink library containing country shapes to have the country's polygons sorted from largest to smallest. This simplified mapping above and is more logical.

2016-01-03

• Improved the eval[expr] and unsafeEval[expr] functions so they wouldn't totally die when evaluating an array in which an element throws an exception. Now, elements of the aray that throw exceptions are returned as the special value undef.
• Added positive[array] function to systemSolver2.frink which returns only positive results from a list.
• Made tvaspect.frink work consistently and only return positive results! Woo!

2016-01-02

• Fixed the deltaT function which did not take into account the leap second introduced at the beginning of 2015-07-01. It was handled correctly in the Leap Seconds calculations, though. The calculations for delta-T need to be unified with the (automatically updated, smarter) leap seconds functions to avoid this issue in the future.
• As a corollary of the above, my MIThenge predictions may be up to a second off for 2016 and may need recalculation. However, this error is much smaller than the current best uncertainty in the azimuth of the Infinite Corridor.
• Updated future deltaT predictions for the year 2016. The earth's rotation hasn't been slowing down as much as predicted in the past, and future predictions may need to be researched and updated if new predictions are available.
• Updated copyright dates for 2016. Happy New Year!
• Updated sanity checks to 2016 for economic routines.

2015-12-14

• Updated algebraic simplification of power expressions that have units of measure in the base like (1/2 meter)^(-1/2). For a while, these were not simplified. They are now again simplified correctly.
• Added the function realSignum[expr] which is a slightly-more-dangerous version of the signum[expr] function. This version only handles real numbers and returns -1, 0, or 1 depending on the number. All other values return the special value undef.

2015-11-05

• Important: Fixed a bug in algebraic simplification of power expressions like (1/2)^(-1/2) (which works correctly and transforms to 2^(1/2)) but did not work correctly in some cases if the base had units of measure and had a rational number for its scale and the exponent was a negative rational number.

  Due to the way this code is invoked, it only appears to happen when using Frink's (somewhat undocumented) symbolic transformation capabilities which triggered this case. That is, it only appears to occur when building a symbolic expression and then transforming it by substituting parts of the expression. However, in any case, it is strongly recommended that you update whether you are using symbolic transformations or not.

• Added a sample program to demonstrate Frink's symbolic solving capabilities which answers the question: If you dismantled the Great Pyramid of Giza, could you build a wall around France with the stone? And how big and thick could the wall be? GreatPyramid.frink

2015-10-22

• Added new expression constructors for several expression types. This allows them to be used in symbolic transformations.
• Added a sample of definite integration to integrals.frink. This still needs some support from new language features to work seamlessly and efficiently.

2015-10-08

• Improved many error messages, especially those for conformance exceptions such as adding two values with different dimensions.
• Updated all internal links to point to the new canonical Frink home, https://frinklang.org/

2015-10-04

• Added factorFlat[x] function to factor integers and return the results as a one-dimensional list instead of the two-dimensional list returned by factor[x]. This really isn't necessary, but makes some functional programs slightly easier to write.

  factorFlat[1000]
[2, 2, 2, 5, 5, 5]

2015-10-01

• Increased some internal cache sizes which should improve memory performance for certain types of programs.
• Improved error messages for some operations.

2015-09-23

• Added a VenusApparent.frink sample program to graph the apparent position of Venus as seen from Earth. This uses the amazing planets.frink sample program which calculates the locations of the planets to high accuracy.
• Added a function approximationsWithErrors to the continuedFraction.frink program to easily calculate the errors in continued fractions. This is demonstrated in the above program.

2015-09-10

• Changed the manifest in the frink.jar file to make the applet-based interface and the Java Web Start file work better from multiple hosts with modern Java security checks. (This is in anticipation of the upcoming move to the canonical site https://frinklang.org/ )

2015-08-23

• Fixes problem in the use statement on some platforms where the underlying system may throw a null pointer exception. This primarily affected Android 5.0.1 and higher. Thanks to Karel Šnajdr for the problem report and debugging.

2015-07-04

• Once again updated the code for U.S. historical currency conversions because my new data source evidently just switched to an HTTPS-only link. Thanks to Jesse Ira de Leon for letting me know that it was broken again.

2015-06-30

• The new 2014 CODATA values for the fundamental physical constants of the universe have just been published and Frink has been immediately updated! Be the first kid on your block to use the most accurate, authoritative, latest and greatest international research that has been compiled over the last 4 years!

  This includes changes in fundamental constants like Planck's constant (h), the gravitational constant (G), Avogadro's constant (avogadro), Boltzmann's constant (k), the gas constant (R), fundamental particle masses and charges, and hundreds more constants that rely on these values.

  The standard data file has all of the changes and links to the new CODATA values.

• There will be a leap second added to the clock at the end of this year. Frink has known about this leap second since it was announced on 2015-01-05. To find out when the leap second will occur in your local time (in case you want to watch your atomic clock to see what it does,) in your local copy of Frink, execute:

  #2015-07-01 UTC#

2015-06-29

• Rewrote the source for U.S. historical currency conversions because I noticed that the previous Consumer Price Index source is no longer being updated regularly. (It's pretty sad when the Bureau of Labor Statistics, the original source of CPI data, can't even keep primary sources up-to-date. Also their "contact us" forms are broken. Yay government.) The new source comes from the St. Louis Federal Reserve, specifically by parsing this file. The new data is also cached in each Frink jar file in case you don't have network connectivity.

2015-06-23

• For Android: Added a "go" button for devices whose keyboards don't quite do what they're supposed to do.

2015-06-10

• Updated sanity checks and performance optimizations to detect Java 9 and other VMs.
• Removed debugging information that might have leaked to standard error.

2015-05-08

• Added graphics.backgroundColor[colorObject] method that sets the background color from a previously-obtained color object.

2015-05-07

• Fixed formatting of for and multifor loops that have labels.

2015-05-06

• Added getExponent[unit, dimension] to get the exponent for the specified base dimension. See the Other Functions section of the documentation for details. Thanks to Mike Meyer for the suggestion.
• Updated sanity checks and performance optimizations to detect Java 9.

2015-03-03

• Rewrote code for sizing and placing windows:
  • Frink now requests that the operating system uses its algorithm for placing new windows (instead of letting Java do it badly.) This usually means that multiple graphics windows will be placed next to each other, rather than on top of each other, if your windowing system has a reasonable layout algorithm. This requires Java 1.5 or later to work, but previous versions of Java are still supported.
  • Rewrote the code for creating exactly-sized graphics windows. This means that the content of your windows will be exactly the size requested when using graphics.show[width, height]
  • image.show[] should now consistently display images at their exact native size by default. Previously, it may have been a couple of pixels off.
  • Initial user interface windows will more likely be placed sensibly, if your windowing system supports it.

2015-03-02

• Modified the int[x] and trunc[x] functions (which are the same thing) to work for interval arguments.

2015-03-01

• Addded functions to enumerate the partitions of an integer:
  • partitions[n] Returns an enumeration of the partitions of the integer n. For example:

    for a = partitions[4]
   println[a]
[4]
[3, 1]
[2, 2]
[2, 1, 1]
[1, 1, 1, 1]

  • partitionsCompact[n, countPermutations=false]: Like the partitions function above, but returns a more compact enumeration of the partitions of the integer n. Each list contains [num, count] pairs indicating the number and its count in a partition. For example, compare the following representation with the one from the partitions function above.

    for a = partitionsCompact[4]
   println[a]
[[4, 1]]
[[3, 1], [1, 1]]
[[2, 2]]
[[2, 1], [1, 2]]
[[1, 4]]

    If the optional argument countPermutation is true, then each element also contains the number of possible permutations of the list.

2015-02-22

• Added a few new functions for manipulating filenames and URLs:
  • filenameToURL[string] turns a string containing a filename into a URL string.
  • fileURLs[string] takes a string representing a file or directory and returns an enumeration of files in that directory. Each string is the URL of a file in that directory.
  • fileURLsRecursive[string] takes a string representing a file or directory and returns an enumeration of files in that directory and all its subdirectories. Each string is the URL of a file in that directory.

2015-02-16

• Fixed problems in converting rational numbers with very large or very small parts to a double value. (i.e. if the numerator or denominator or result of the rational number couldn't fit into a double). When converting rationals to double, validity of results is now checked much more strongly, and alternate methods are used to perform the division if the numerator, denominator, or result isn't representable as an IEEE double.

  While most Frink functions don't use IEEE-754 double values directly, they are used in some APIs (like graphics libraries and hardware-accelerated trigonometric functions). The problems are usually directly apparent and cause programs to stop at higher levels, but Java's graphics APIs silently swallow NaN and infinite values, which made these cases possibly slip through the graphics system undetected.

• Added a toRational[num] function to convert Frink's internal representation of a floating-point number to an exact rational number representation of the number represented.

2015-02-08

• For Android: Revised the way that "enter" keypresses are handled in interactive mode. Hopefully, this will solve problems with some keyboards and input systems. Please let me know if you have problems with this.

2015-02-05

• For Android: Requested that the Android keyboard doesn't take up the whole screen when entering data in interactive mode (especially for landscape mode.) This may make it easier to enter data and view results at the same time (if your Android device allows this; it's allowed to ignore this request.)

2015-02-04

• Improved containment for intervals in the exponentiation operator and sin[] function.

2015-01-21

• Fixed some units in the standard data file that were directly or indirectly defined in terms of electroncharge, which changed sign recently.
• Made several fixes to Formatting Functions:
  • Greatly improved the functioning of the format, formatFix and formatFixed functions (which are currently identical to each other) to improve calculation of more significant digits for exact values like rational numbers. (This is at the cost of more work needing to be done in this function, so it's possibly slower. That is, it needs to predict how many digits will be in the result, and then has to adjust its working precision to calculate the full number of digits after the decimal point.)

    For example, the following now produces as many significant figures as are requested:

    format[2/3 * 10^20, 1, 30]
66666666666666666666.666666666666666666666666666667

  • Documented and improved the functions for formatting numeric values:
    • formatSci[value, divideBy, decPlaces] (Scientific notation)
    • formatEng[value, divideBy, decPlaces] (Engineering notation)
    • formatSig[value, divideBy, decPlaces] (Significant figures)
    • formatFixed[value, divideBy, decPlaces] (Fixed decimal places)
  • Noted that the behavior of formatFix and formatFix is somewhat deprecated. See the description in the new Formatting Functions sections of the documentation.
  • Sample programs and libraries may gradually be migrated to use the new formatting functions.
• Made a fix in image.averagePixels[left, top, right, bottom] to allow left and right and top and bottom to be out of order.

2015-01-16

• Fixed the sign of electroncharge to be negative. Also added units elementarycharge, protoncharge, neutroncharge, upquarkcharge and downquarkcharge, and modified several definitions to use elementarycharge instead of electroncharge. Thanks to Enon Harris for the catch.
• For Android: Fixed a crash and presented a better warning (with suggestions) when trying to load or save a file in programming mode when the SD card is not available.
• Changed = to := in defintions of Mars's moons Phobos and Deimos in the standard data file. Thanks to Daniel Beskin for the catch.

  Also thanks to Daniel for writing an entertaining introductory article about Frink.

2015-01-05

• It was announced today that a leap second will be added at the end of June 2015. Validated that Frink's internal data file (loaded from the US Naval Observatory's tabulation of leap seconds) has the new leap second. For more information see the Leap Seconds section of the documentation.

2015-01-02

• When adding text to a graphics object, the text can now contain embedded newlines, which are broken into separate lines and handled appropriately. This makes it much easier to lay out multi-line blocks of text. It is now essential to explicitly set a font size on a graphics object before adding multi-line text. Example:

  g = new graphics
g.font["SansSerif", 12]
g.text["One\nTwo\nThree"] // Note newlines
g.show[]

• Fixed miscalculation of some bounding boxes for rotated text, and for text vertically aligned to the baseline.

  (To be more precise, the text was always rendered where it should have been, but due to miscalculation of the bounding box, it may not have been visible in the rendering area if it was on the edge of the graphic, or the only thing in the graphic. This did not affect the default case where the text was centered at the specified coordinates, but may have affected cases where horizontal and vertical alignment was not "center".)

• Updated copyright dates for 2015. Happy New Year!

2014-12-29

• Added a version of array.lexicographicPermute[function] which takes an ordering function to perform the permutation. See the Array Methods section of the documentation.
• When rendering graphics to HTML files, each bitmapped image is only included once in the output, even if it is rendered multiple times. This may greatly decrease the size of HTML files.
• You can now add bitmapped images when rendering graphics to Scalable Vector Graphics (SVG) files.

  (I tried to make each bitmapped image only render to the SVG one time, even if it was rendered multiple times, like the fix for HTML files above, but after much effort, I found that according to the SVG spec, the image tag cannot reference elements within an SVG file, so you can't reference a single image multiple times. I tried.)

• Changed some internal sanity checks to the year 2015.

2014-12-19

• Internal changes to Frink's security manager:
  • Security errors when constructing an object with the new keyword or constructExpression function are now printed more specifically.
  • Security manager now has more granular control over expressions constructed with constructExpression function.

2014-12-10

• Added graphics.fillCenter[img, cx, cy, width, height] and graphics.fillCenter[img, cx, cy, width, height, leftSrc, topSrc, rightSrc, bottomSrc] methods which draw an image onto the graphics object with the specified center coordinates (cx,cy), making it completely fill the specified width and height without modifying the aspect ratio. Note that this may cut off part of the image. See the Images section of the documentation for more.

2014-12-03

• Graphics can now also be clipped to a GeneralPath, which means that graphics can now be clipped to all of the two-dimensional shapes that Frink supports. See the Clipping Graphics section of the documentation for more.
• See the GeneralPathClipTest.frink sample program for an example of clipping to a GeneralPath.

2014-11-23b

• Graphics can now also be clipped to an ellipse or a polygon. See the Clipping Graphics section of the documentation for more.

2014-11-23

• Frink's graphics now allow you to set an arbitrary clipping rectangle which constrains the drawing area. This improves graphing equations, drawing maps, and makes it safer to draw graphics into a specified area.

  A cool thing about the clipping implementation is that, like all of Frink's graphics, you can render to any coordinate system that makes sense to you, even if it's rotated, scaled, skewed, and clipped, and Frink will automatically center and scale that into your graphics window by default, greatly simplifying many graphics programming tasks. In other words, this can be used to "zoom in" on a section of a larger graphic--just set a clipping region before drawing the graphic and only the section within the clipping region will be displayed.

  See the Clipping Graphics section of the documentation for more.

• Now that many browsers implement the even-odd winding rule in the HTML 5 canvas (previously, the specification only supported the rather useless nonzero winding rule,) Frink now requires that functionality, and will now draw many more concentric or self-intersecting objects correctly in HTML5.

  This feature is being gradually implemented in current browsers, (but not yet in the official HTML5 Canvas spec!) Your browser needs to support the HTML Canvas's context.fill("evenodd") method for Frink's graphics to work properly now. This appears to be supported in current versions of Firefox (21+), Firefox on Android, Chrome (27+), Opera (15+), Safari 8.0, and IE11 (according to this).

2014-10-20

• The random[min, max] and random[int] functions can now handle arbitrarily-large integer arguments (previously, they could only handle arguments with magnitudes up to 2³¹.)

  This change was inspired by my Twitter contest: "What is the smallest positive integer that does not return a Google result?" The earlier results were on the order of 10¹⁵ which could not be randomly-generated directly. Try your hand at this contest, preferably without peeking at the results from the link above!

• Added an internal optimization that may make integer-heavy operations work faster.

2014-09-24

• Added Indian terms lakh (100 thousand) and crore (10 million). Thanks to Emily Lakdawalla for pointing these out in her coverage of India's Mars Orbiter's successful orbital insertion burn around Mars.
• Internally rewrote some parsing routines for Devanagari numbers.

2014-08-21

• Added array methods:

  array.indexOf[value]
array.indexOf[value, startIndex]
array.lastIndexOf[value]
array.lastIndexOf[value, startIndex]
array.contains[value]


  See the Array Methods section of the documentation.

• The left[string, len] and right[string, len] methods can now take negative arguments for len. If len is negative, it returns a string with -len characters removed, that is, if the original string is 5 characters long, and len is -1, 4 characters are returned. In any case, if the original string is shorter than the number of characters requested, the string returned will contain only the number of characters available, and will not return an error.

2014-08-20

• Fixed the exp[n] to not overflow or underflow. The functions in ArbitraryPrecision.frink are still preferred if you need exact, very large exponents.
• Improved error messages for the parseInt[str, base] function.

2014-07-31

• Functionality Change: Suppressed a trailing newline that was printed from most programs loaded from a file. This behavior is due to the fact that Frink would print the value of the last evaluated expression when exiting. Most meaningful programs end with statements that have void values, so the only effect was a blank line. The blank line is now suppressed, but if the last statement in a program actually returns a value, it will still be printed. It was probably not noticeable unless you piped Frink's output into some other sensitive program. Thanks to Ty! Boyack for noticing the problem.

  It's likely that the current behavior will change further. If you expect a program loaded from a file to output the last expression evaluated, you will soon likely have to wrap it in a println[] statement, as Frink will likely someday never output the value of the last expression evaluated.

• Added (not-yet-officially-documented, pending final testing, but already much superior and recommended) functions for formatting units of measure which improve on and supersede the format[num, divideBy, decPlaces] function.

  The new functions are:

  • formatSig[num, divideBy, decPlaces] : Divides num by divideBy and returns a string with decPlaces significant figures. The value will be in normal notation when possible and scientific notation when required to display the requested number of significant figures.
  • formatSci[num, divideBy, decPlaces] : Divides num by divideBy and returns a string in scientific notation with decPlaces significant figures.
  • formatEng[num, divideBy, decPlaces] : Divides num by divideBy and returns a string in engineering notation (that is, the exponent is a multiple of 3) with decPlaces significant figures.
  • formatFix[num, divideBy, decPlaces] : Divides num by divideBy and returns a string in with a fixed number decPlaces of digits after the decimal point.

    formatFix matches the historical and current behavior of the format[num, divideBy, decPlaces] function.

    Warning: format and formatFix are almost necessarily broken, lose information, and do not necessarily calculate all decimal places correctly, especially when displaying the values of exact fractions like 2/3 to a large number of decimal places. The behavior of the format function will eventually change to follow the behavior of formatSig as listed above. You may want to prepare modifying your programs now. Changing all instances of format[ to formatFix[ should preserve the current behavior forever, but it is strongly recommended to move to smarter functions like formatSig.

  In all of the above, divideBy should be 1 if the number is dimensionless. If divideBy is a string, this evaluates the string, expecting a unit to be returned, and both divides by this unit and concatenates the string after the result.

• Made lots of internal mathematical improvements to support more accurate rounding when formatting numbers. These improvements can be seen in the formating functions above, most notably when displaying exact rational numbers to a large number of decimal places, complex numbers, and intervals. Containment for intervals when calling the new formatting functions is vastly improved.

2014-07-07

• Modified the Web-based Interface to be a bit more usable, including controlling scrolling to the results, placing results right after the calculation field, and trying to work around auto-capitalization and autocorrect problems in mobile browsers.

2014-07-02

• Modified Functionality: Frink now handles high Unicode characters (those above \uFFFF) much more easily and correctly. These changes will not affect you if you don't process high Unicode characters, but if you do, there will be some changes:
  • High Unicode characters will be represented as a single character (rather than by two "surrogate pair" characters as in Java.) The following functions have been modified to behave properly and easily with high Unicode characters, treating them as a single character.
    • char[str]
    • chars[str]
    • charList[str]
    • editDistance[str1, str2]
    • editDistanceDamerau[str1, str2]
    • indexOf[string, substr]
    • indexOf[string, substr, startPos]
    • length[str]
    • padLeft[str, width, padChar]
    • padRight[str, width, padChar]
    • left[str, chars]
    • right[str, chars]

    For more information, see the Unicode in Frink and Unicode in Strings sections of the documentation.

  • If you want the old, cumbersome Java-style string functions that treat high Unicode characters as a pair of surrogate characters, the following functions have been added. See the Raw String Functions section of the documentation for more.
    • charsRaw[string]
    • indexOfRaw[string, substr]
    • indexOfRaw[string, substr, startPos]
    • lengthRaw[string]
    • substrRaw[string, startPos, endBefore]
    • substrLenRaw[string, startPos, length]
• The new Unicode escape sequence \u{XXXXXX} places a Unicode character into the string, where XXXXXX is a 1- to 6-digit hex value for the Unicode codepoint. For example, to create a string with a cat face, you would use "\u{1f638}" (this is the Unicode character "GRINNING CAT FACE WITH SMILING EYES".) For more information, see the Unicode in Strings section of the documentation.
• Variables and identifiers in Frink programs can now be high Unicode characters:

  😸 = "kittyface" // Unicode \u{1f638}
\u{1f638} = "kittyface" // Alternate ASCII-safe representation.

2014-06-09

• The Swing GUI now tries harder to work around bugs in Swing. Namely, the Swing interactive GUI would refuse to scroll correctly if the font size was changed. This improves that situation on the JVMs it has been tested on.

2014-06-03

• Added array.remove[start, end] and array.removeLen[start, length] methods to remove a range of items from an array. See the Array Methods section of the documentation.

2014-06-02

• Many changes to date/time parsing:
  • Changes to allow ISO-8601-format dates like:

    2014-06-02T02:24:10Z

    This required making changes so that quoted text literals in a format could actually work correctly. (e.g. the literal character T in the example above that separates the date from the time.) The above format is actually specified as:

    # yyyy-MM-dd'T'HH:mm:ss #

    where the single quotes do not actually appear in the date; they are ways of escaping the literal text T.

  • Timezone specifiers are now more flexible with respect to whitespace; the timezone name can be separated from the date/time with zero or more spaces. (Previously exactly one space was allowed.) This allows the ISO-8601 format above, where the "Z" timezone is flush up against the timezone name, and more latitude in parsing.
  • Allowed Custom Timezone specification in the formats allowed by RFC 822, RFC 1123, ISO-8601, and Java's default parsing. These look something like:
    • +0700
    • -0700
    • +07:00
    • -07:00
    • GMT+0700
    • GMT-0700
    • GMT+07:00
    • GMT-07:00

    This allows ISO-8601 formats with the custom numeric-only timezone jammed directly onto the end of the date, such as:

    2014-06-02T02:24:10-06:00

  • Added Z (Zulu; a synonym for Universal Coordinated Time) timezone alias. This is required by ISO-8601 format dates.
  • Added an new Timezone Warning section to the documentation, warning about the problems with using the timezone aliases that look like Etc/GMT+7 or GMT+7 as defined by the Olson timezone database, the POSIX standard, and Java. These aliases should be considered error-prone and dangerous. Please read that section carefully.
  • Added parsers for RFC-8601, RFC 822, RFC 1123 to the standard date formats file. (RFC 822 and its successor, RFC 1123, specify date formats required in HTTP headers.)
  • Modified parsing of milliseconds for all time formats in the date formats file to use .S instead of .SSS which gives more flexibility and correctness in parsing (using .SSS required 3 digits to be present while .S can handle 1 to 3 digits.) There are also bugs in Java's parsing if .SSS is used and less than 3 digits were provided.
  • Added a sample in the Listing Timezones section of the documentation, showing how to find timezones that contain a substring.

2014-05-31

• Added graphics.show[insets] method to allow you to specify the insets for a graphic without specifying height and width. See the Showing Graphics section of the documentation for details.

2014-05-26

• Added functions integerDigits[num] and integerDigits[num, base] to return an array of the digits of a non-negative integer in the specified base.

2014-05-21

• Fixed the deepCopy[expr] function which was broken recently.

2014-05-20

• Fixed the bug introduced in Java 7 that long words or numbers in the Swing GUI do not wrap like they always have. They now wrap as they did since the first Swing releases. (See Java Bug 7125737 which was stupidly closed as "not an issue". This major compatibility bug is not easy for end developers to fix (but would be trivial for Java's developers to fix) and affects almost all Java programs that use Swing. Sigh.) This only affects the Swing GUI so an Android release was not made.

2014-05-09

• The select and remove functions now allow selector functions with more than one argument. Previously, all arguments were passed as an array to a single-formal-argument function, which will continue to work the same if you pass in a one-argument selector function. See the documentation select and remove for examples.
• Behavior change: The select and remove functions now try harder to keep their return values as arrays if passed an array, and an enumerating expression if passed an enumerating expression. In addition, they now keep dictionaries as dictionaries, OrderedLists as OrderedLists, and sets as sets. To obtain other types, toArray[expr], toDict[expr], and toSet[expr] functions. If in doubt, use these functions directly to change the return types.
• Internal change: All array types are now also enumerating expressions (i.e. all ListExpressions are now also EnumeratingExpressions.) Almost all of them were already, but now all are. (The only changes were to ComplexArray and ComplexArray2D, used mostly in Fourier transforms.) This allows for simplification of some code (e.g. the select function has turned into a single, simpler implementation.)

2014-05-05

• Behavior change: Revised the select and remove functions to make them return an enumerating expression if passed an enumerating expression. (Previously, they returned an array. They still return an array if passed an array.) This makes these functions now work properly with very large or infinite series, and work much better with long-running operations. This change may also allow significantly-reduced memory consumption, as you can process each element and then forget about it, rather than holding on to a large array of values.

  If for some reason you need them as arrays, you may want to wrap the call to select in a call to the toArray function to restore the original behavior.

• Internally revised code to turn a java.io.File into a URL. This is safer and uses better libraries on Java Virtual Machines that have them (at the expense of doing a bunch of call-by-introspection.)
• For Android: Added more hints on what to try if Java throws a low-level exception in random code. (This is usually due to the Android device not allocating enough stack space for highly recursive calculations.) Thanks to Andrew Webb for the report.

2014-04-30

• Added a remove function which is the inverse of the select function. It removes items that match a condition from an array or enumeration.
• Documented a few regular expression patterns like (?!pattern) and (?=pattern) that have always been available but were not documented. See the Basic Patterns and Metacharacters section of the documentation for more.

2014-04-23

• Fixed a bug in the cache for the Historical British Price Data. This could return incorrect values when first requesting one unit for a given year (e.g. pound_1914) and then requesting another unit for the same year. (e.g. pence_1914).

2014-04-21

• Updated the jar file's manifest file to hopefully eliminate many of the new security warnings and dialogs presented by Java 7 when running Java Web Start. Note that in some cases, this will change the name of the icon on your desktop or start menu, or will create multiple icons. Sorry--this appears to be out of my control.

  Whenever Java Web Start gets confused (which seems to be always,) I always recommend deleting the application from your Java console and reinstalling it from the links in the Java Web Start section of the documentation (after reading the new warnings in that section.) Please let me know if older (or newer) versions of Java Web Start cannot start with these new changes. Again, make sure you read the new warnings in the Java Web Start section first.

• Behavior change: The staticJava functions now try harder to turn their return values into Frink types. For example, types that were previously returned as JavaObject:java.lang.Integer are now returned as a normal Frink integer. This should not affect most programs, but If you need the original behavior, you can call the three-argument version, with the third argument false indicating that the value should not be converted to a Frink type. See the Accessing Static Java Fields section of the documentation for more details.
• Added more security checks around method calls by name.

2014-04-20

• Modified newJava functions to explicitly throw exceptions when the user attempts to call a Java constructor with invalid arguments. Previously, the call could fail silently in some cases. Thanks to Frank van Noorden for the report.

2014-04-17

• Major New Functionality: Frink's formatters were totally rewritten to allow output in multiple formats. This includes a new "input form" which lets you easily save and load most Frink data structures (and programs,) send them over a network, etc., in a simple, safe and reversible way. See the Formatters section of the documentation for more.

  This involved a large cleanup of lots of formatting code and redesign of many classes which should make it easier to make Frink render code in other languages and supports planned future features like genetic programming.

  This involved changes/additions to about 5000 lines of code, and took longer than I thought it would. (This started out as an attempt to make nested data structures indent themselves properly, and became a huge re-design!)

• Several new functions have been added to support formatting in different formats:
  • format[expression, format] formats the expression to a string using the specified formatter. Current formatters include the strings "Input" and "Output". "Input" is a formatter that provides Frink's input form that can be easily parsed by a call to eval[str]. "Output" is the human-friendly formatter, which has been greatly improved in this release.
  • formatters[] lists the currently-available expression formatters.
  • inputForm[expression] and outputForm[expression] are aliases for format[expression,"Input"] and format[expression,"Output"] respectively.
  • Formatting options such as showApproximations[], rationalAsFloat[], setEngineering[], and showDimensionName[] and the :-> operator are now local to the interpreter, (and only effect the "Output" formatter,) not global to the entire Java Virtual Machine. This makes it safer to embed multiple Frink parsers in a single virtual machine, each with their own preferences, and makes Java Server Pages more robust against poorly-behaved scripts. (Programs still need to pass a security check to set these flags on an interpreter basis.)
• Nested data structures are now indented appropriately.
• Many, many more Frink data structures and programming constructs can now output themselves correctly, in a form that looks like their form in the Frink programs that you write. (Which lets Frink parse them correctly with the eval[str] functions !)
• The Julian day parser can now parse rational numbers or date intervals, for example:
  • Rational: # JD 212263942857555001/86400000000 #
  • Interval: # [JD 212263942933679/86400000, JD 70754647644893/28800000] #
• When outputting dates in "input form", the date will be formatted as an exact Julian day (possibly an interval or an exact rational number as above) if necessary, or in a human-readable format in UTC, if sub-millisecond precision is not required, which allows exact round-trips of dates.
• Currently, objects created from a class specification will be output as a dict with name-value pairs for all instance variables. This may change. This is currently done because there's no way to guarantee that the Frink interpreter on the other end has loaded the same class or a compatible version. There are potential security and correctness issues if the classes are incompatible. A malicious user could also modify the data to get around security or logic checks and create invalid or dangerous objects. It's currently left up to the programmer to take these objects and turn them back into the objects they want on the other end. This may change.
• Added toASCII[str] function to turn a string into a network and file-encoding safe ASCII-encoded equivalent. This is useful if you don't want the full quoting of inputForm.
• Note: Many expression types have changed their child count and/or ordering with this release, so if you use the (undocumented and changing) functions getChildCount[function] and getChild[function, index], expect some changes. Hopefully universally for the better.
• The do...while loop can now have a newline before the while clause when brackets are used:

  do
{
   println[i]
   i = i + 1
}
while i<10

• Made many changes to the way that functions allow you to discover their arguments and body using getChildCount[function] and getChild[function, index].
  • The arguments to a function are now first-class expressions, with information about their types, constraints, and default values.
  • The body of a function can be returned.
  • Named functions, such as those returned from the getFunction[name, argCount] actually remember their names and allow you to display their names and arguments correctly, and call them through an indirect variable.
  • In inputForm, the body of an function is dumped in a usable way (for anonymous functions defined in Frink code. The body of Frink functions implemented in Java are not dumped.)
• Added expressionConstructors[] function which returns the names of all the expressions that can be constructed by name and argument list.
• The three-way comparison operator <=> is now a proper first-class operator with a proper precedence, and can dump itself properly.
• The match operator =~ is now a proper first-class operator with a proper precedence, and can dump itself properly.
• Regular expressions and search-and-replace expressions can now dump themselves in a human-readable format.
• The child types of many expressions have changed from returning strings to returning SymbolExpressions for easier formatting and correctness.
• Boolean algebra operators now dump themselves with a text string instead of symbols (e.g. and instead of &&.)
• The existing functions toArray[expr] or array[expr] can turn an object created from a class specification into an array of [key, value] pairs.
• The existing function toDict[expr] can turn an object created from a class specification into a dictionary of key, value pairs.
• Added functions for dumping the children of an expression:
  • children[expr]: Returns an array containing all the children of the expression.
  • childrenWithTypes[expr]: Returns an array containing all the children of the expression and their types.
  • childTypes[expr]: Returns an array containing the types of all the children of an expression.

2014-04-15

• Apologies if you read this page in the last few days and saw notes for a 2014-04-11 release with lots of new features. That actually hasn't been released yet. It should be officially released in the next few days. Sorry about the confusion.
• Fixed a problem with the WAR file for running Frink Server Pages. The class frink.servlet.ServletUtils was missing from some builds.

2014-03-18

• Modified the JSON parser to allow an escaped forward slash, to match the spec, and tightened the list of characters that are allowed in a string (that is, disallowed unescaped control characters.)
• Now that the U.S. Bureau of Labor Statistics has now apparently made the Consumer Price Index file available from a non-broken HTTP site (as opposed to their old broken FTP site, see the notes for the 2013-07-09 release,) Frink now fetches the CPI file from their site instead of mine.

  Update: See their discontinuation statement about their FTP site and their FTP migration document.

2014-03-01

• Added two-argument versions of functions to sum and multiply lists. sum[list, emptyValue] and product[list, emptyValue] sum and multiply lists respectively, and if the list is empty, these return the user-provided emptyValue.

2014-02-20

• Oops! Added a few new classes that are loaded by name to the list of classes that aren't obfuscated/compressed, so they can be loaded by name. This includes the JSON parser and the wrapper for Java's Map class.

2014-02-17

• Even though JSON is a terrible format based on a terrible language, you can now parse it easily in Frink with the parseJSON[string] function. See the Parsing JSON section of the documentation.
• As a side-effect, you can now obtain Bitcoin rates easily. See the Bitcoin section of the documentation for an example.
• Added the bitcoin.frink sample program.

2014-02-14

• Java collections that extend java.util.Map (this includes classes like HashMap, Hashtable, Properties, etc), can now be treated like a Frink dictionary, including the ability to enumerate over [key, value] pairs. See the Iterating over Java Collections section of the documentation for more.
• Performed a large rewrite of the internals of enumerating over Java objects, including improved compile-time typesafety and better error reporting.
• All Java objects are now HashingExpressions so they can be used as keys to dictionaries, placed into sets, and more.

2014-02-03

• Performed an internal restructuring of Frink's parser and lexer, allowing multiple parsers to be included more easily. This shouldn't affect you unless you accessed the old classes directly (which you shouldn't.)

2014-01-29

• Updated the Geocaching Tools page in several ways:
  • Fixed to use Google Maps API v3.
  • Now calculates UTM to Lat/Long.
  • Updated the supporting CoordinateConversions.frink and GoogleEarth.frink files.

2014-01-21

• The parseInt[str] function can now take an array of strings as input.

2014-01-13

• Added copy constructor for the image class, so an image can be copied and the copy can be modified without modifying the original:

  orig = new image[url]
copy = new image[orig]

2014-01-11

• Greatly improved the rendering of polylines, polygons, and filled polygons, especially when printing. This eliminates jagged edges of polylines and gives smoother curves.

  Internally, the rendering of polylines was changed from using Java's drawPolygon methods (which could only use integer coordinates) to using GeneralPath which can use sub-pixel coordinates. It also forces "pure" rendering of strokes in Java's graphics subsystem. This may be slower to render, but the results will look much better and be more accurate.

  Note that this only applies to environments where Java's Graphics2D is used (that is, almost any modern Java distribution.) Android's graphics were unchanged as they have always rendered properly due to better design of Android's graphics routines.

2014-01-02

• Added functions isArray[expr], isDict[expr], isSet[expr] to allow you to test if an expression is of the specified types.

2014-01-01

• Happy New Year! Updated sanity checks and copyright dates for the year 2014. No leap seconds were added at the end of the year.

2013-12-07

• Several methods were added to allow graphics objects to be added rotated into other graphics objects. This makes it even easier to compose complicated graphics and place them in other graphics, no matter their original coordinates or orientation!

  Detailed information on the new methods is found in the new Composing Graphics section of the documentation.

2013-12-06

• Late update: Fixed an additional bug in graphics.add that might have caused a Null Pointer Exception. Thanks to Nicholas Spies for the bug report.
• Fixed a bug in composing graphics (graphics transforms were not always reset when adding multiple graphics.) Please update.

2013-12-05

• This release improves the ability to easily compose a graphics object from several other graphics objects. You can now add a graphics object to another graphics object while automatically scaling it to fit into a specified area, no matter what coordinates it was originally drawn to! This makes it easy to take graphics objects from a variety of sources, drawn into their "natural" coordinates, and easily compose them into other graphics objects.

  Detailed information on the new methods is found in the new Composing Graphics section of the documentation.

2013-12-04

• Added editDistanceDamerau[str1, str2] which calculates the Levenshtein-Damerau edit distance between two strings. This is similar to the editDistance function which calculates the Levenshtein edit distance, but also allows swaps between two adjoining characters. See the Other String Functions section of the documentation for more.

2013-11-20

• For Android: Made sure that the input field requests focus on startup. This was affected by the 2013-11-11 changes..

2013-11-12

• Frink can now render animated GIFs! These are quite simple to generate from a series graphics objects with very little additional code. See the Animated Images section of the documentation for details.

2013-11-11

• For Android: Made the text in the output windows selectable, so results can be copied and pasted into other programs. This requires a platform running Android 3.0 (API level 11) or later. Thanks to Carl Graff for the suggestion.

2013-11-10

• Changed calculation and display of approximations to rational numbers to use "engineering notation" whenever requested. This especially manifests itself when rationalAsFloat[true] is called. Note that the approximations are calculated slightly differently before (before, they could use IEEE-754 math and now they use Frink's division with proper rounding.) Many more numbers are correctly displayed as "exact" now. Note that this may change the display of some numbers (numbers close to zero with 5 or fewer leading zeros after the decimal point are currently not displayed in scientific notation.) Thanks to Phil Knodle for the bug report.
• Updated references in the standard data file about the amount of energy in a quantity of TNT. This is another case where NIST Special Publication 811 is broken or vague.

2013-10-29

• You can now render arbitrary-resolution graphics objects into bitmapped images in memory using the constructor:

  new image[graphics, width, height]

  See the Images section of the documentation for more examples.

• For Android: Fixed a potential issue where images might not be rendered correctly if the file extension was in lowercase.
• For Android: Enabled writing images and graphics to WEBP graphics format if your platform supports it.

2013-10-21

• The uppercase and lowercase functions can now be applied to a list of arguments.
• Added a function readLines[URL] to read the contents of an entire URL into an array with one line per entry. Thanks to Millicent (whose name, when converted to lowercase, is a parseable Frink unit) for the inspiration.

2013-09-28

• Added base64[integer] to encode an integer to/from a string in standard base64 encoding format. If passed an integer, returns a string representing the integer as a base 64-encoded value. This uses standard base-64 indices in the order A-Za-z0-9+/. If passed a base-64 encoded string, this returns an integer with the corresponding value.
• The base[integer, base] base conversion function can now have 64 as a base.
• The parseInt[integer, base] base conversion function can now have 64 as a base.

2013-09-22

• Added graphics.alpha[opacity] command to set the transparency (often called "alpha channel") of all subsequent drawing operations. The opacity is a dimensionless number from 0 (fully transparent) to 1 (fully opaque.) This primarily allows you to draw transparent images, as transparency could already be specified when setting colors. If a color already has a transparency, that transparency value will be multiplied by this global transparency.
• For Android: With respect to the changes above, modified the behavior of drawing bitmaps when the current drawing color has a transparent alpha channel. Previously, if the current drawing color had a transparent alpha value, the bitmap was rendered with the same transparency. This was probably unexpected and does not match the behavior of Frink on other platforms. Now, to render bitmaps with some transparency, you need to call graphics.alpha[opacity] before rendering the bitmap.

  This global alpha channel also affects any other subsequent drawings that are being done, multiplying the alpha channel in drawn colors by the global alpha channel.

2013-09-19

• Again updated the statistics.frink to eliminate source of underflow/loss of precision when calling erfc and inverseErfc for large arguments.

2013-09-16

• Updated the statistics.frink to eliminate source of underflow when calling erfc for large arguments. Thanks to Dave Schulman for the bug report.

2013-09-08

• Started a new Frink Science mailing list. (Hosted by Yahoo! Groups. Link opens in new window.) This list is intended to discuss problems in math, science, and physics and explore solutions using the Frink language.

  The first sample was posted today, exploring and quantifying the effects of the Coriolis effect on a kicked football (or other projectile.)

2013-07-28

• Added a labeled next LABEL level statement to jump to the next specified level of a multifor construct. See the documentation for multifor and the sample program multinexttest.frink for more.
• Allowed OrderedList to take a second parameter which is an arbitrary data object that will be passed to the comparison function. See the documentation for examples.

2013-07-27

• Added new class, OrderedList, which extends array but automatically keeps items in order.
• Added image.toComplexArray[] method which turns the pixels of an image into a 2-dimensional array of complex numbers (ComplexArray2D) which can be manipulated, Fourier transformed, etc. The behavior of this method will change.
• More documentation on Fourier Transforms. Fourier transforms can now operate on a ComplexArray and ComplexArray2D, primarily for transforming the pixels of an image.
• Added lots of internal methods to the graphics library to support Fourier analysis of images.
• Greatly extended the ComplexArray and ComplexArray2D classes to support Fourier analysis of images, normalizing, etc. These methods may change so they're not documented yet.

2013-07-14

• Fixed a problem when matching a regular expression that ends with the global /g modifier and assigning the results to a variable directly (as opposed to using it in a for loop.) Spurious null values could have been appended to the list, and the return values could be duplicated.
• Improved error messages when we can't connect to the source of the Consumer Price Index data.
• Added set.putAll[expr] method to put all of the elements of expr into the set as individual items. See the Sets section of the documentation for examples.
• Added dict.remove[key] method. This returns the value corresponding to the key that was removed, undef if the key was not in the dictionary.

2013-07-09

• The U.S. historical currency converter in Frink and the associated webpage may not have been working for you if you are using a new version of Java, because it can't connect to the U.S. Bureau of Labor Statistics FTP server. Technical reasons at bottom, if you care.

  As a result, Frink will now temporarily fetch the file from my site, http://futureboy.us/frinkdata/cpiai.txt instead of the URL ftp://ftp.bls.gov/pub/special.requests/cpi/cpiai.txt . I mirror the file on a daily basis for now. The current release of Frink will fix the problem temporarily.

  This problem didn't affect Android. I guess their programmers use more sane FTP code.

  Frink has always tried (and usually succeeded after about a 90 second timeout) to fall back to an internal copy of the Consumer Price Index file, but in the case of the web page, the timeout for the FTP connection was longer than the webpage's timeout, so it never had a chance to complete.

  Technical reasons: The problem is that modern versions of Java don't seem to retrieve FTP data from the BLS site correctly, specifically this URL.

  I can fetch that file just fine with my web browser or programs like wget but Java 1.7 and 1.8 just time out while trying to download it.

  I dug deep into this problem, (packet-sniffing the network traffic and even hacking debug code into the Java Virtual Machine itself) and can put the blame in 1 of 2 places:

  • Java uses a newish FTP feature (EPSV, extended passive mode) without checking to see if the server supports it using the FEAT (features) command.
  • The BLS's FTP server or firewall is misconfigured. While it responds to the new FTP feature as if it supports it, it doesn't. It's either failing to open a port in the firewall for the data transfer, or it's not actually implemented correctly in their server.

  I sent the message below to the BLS, but they have proven to be incapable of fixing the problem so far. I have a 1-line fix that fixes Java, but it's against the current JDK 8 codebase which isn't really stable and isn't easily available to customers. I'm not especially positive about getting it fixed on the Java side. I finally got a couple of my fixes to bugs in Java checked into the official code this week. I first gave them those fixes 11 years ago. Seriously.

  Message to BLS:

  This question is for the person who administers your FTP server, ftp.bls.gov. Please forward it appropriately.

  It appears that your FTP server does not correctly handle FTP connections that use the EPSV command. While your server responds to EPSV commands, returning the status something like:

  229 Entering Extended Passive Mode (|||55226|)

  It is then impossible for a client to make a data connection on the specified port (55226). I verified this manually using telnet and hand-crafted FTP requests. The FTP client just waits until timing out. I don't know if this is a firewall issue on your end, with those ports not opening for listening correctly, but it prevents some clients from working correctly (e.g. anything written in a modern version of Java, which defaults to EPASV.)

  If the client uses the PASV command instead, the file transfer works.

  If you don't actually support EPSV commands properly in your FTP server and firewall, you must disable them in your FTP server. A web search for "disable EPSV" will probably show how to do this.

  I am willing to help you debug this problem further if necessary.

  Alternately, is there a way to access the file via an HTTP URL?

2013-07-03

• Added array.clear[] method to remove all elements of an array.

2013-06-19

• Fixed a problem in formatting Dynamical Time values in later JVMs. This could possibly cause NullPointerExceptions. The design and implementation of Java's Calendar, Date, and TimeZone classes are quite insane.

2013-06-15

• Fixed a problem in the sun.frink astronomical library. The approxTransit function could potentially jump a day backward or forward, which could affect the date returned by the approxRiseSet, sunrise and sunset functions.

2013-06-05

• The special value undef is now a hashing expression, so it can be placed into a set, used as a key in a dictionary, and so on.
• My super-fast divide-and-conquer Schönhage base conversion routines have been extended to work with all bases from 2 to 36. My improvements for faster multiplication and radix conversion will hopefully make it into Java 8 after 11 years of battling to get them approved. Much of my programming efforts over the last month has been in polishing and testing those routines and preparing staged patches for review.

2013-04-26

• Fixed a null pointer exception when assigning a value larger than 127 to a Java byte array, and improved the error message in this case. This had a surprisingly large cascade of changes throughout the code.
• Allowed users to set values between 128-255 into a Java byte or array of bytes. Previously, this was disallowed because Java insanely has bytes as signed values. Be warned though that values coming out of bytes will still be signed, so values set from 128-255 will actually come out as negative numbers. I should eradicate Java's weirdness around signed values.

2013-03-28

• Turned div, mod, and conforms operators into true operators in Frink so they know their precedence and can display themselves more effectively.
• Modified all the links to colorize.fsp and highlight.fsp to have shorter links. Old links will still work too.

2013-03-15

• Allowed labeled next statements to break out to the next iteration of a specified loop (this includes for, multifor, do, and while loops. See the for loop section of the documentation for an example.
• Fixed parser problem with labels preceding while loops.
• Added getLowestSetBit[num] function which returns the index of the rightmost (lowest-order) one bit in an integer (the number of zero bits to the right of the rightmost one bit). Returns -1 if the integer contains no one bits.
• Added shiftLeft[num, bits] function which shifts the bits of an integer left by the specified number of bits. New bits will contain zero. This is equivalent to multiplying by 2^bits but is usually more efficient for large numbers.
• Added shiftRight[num, bits] function which shifts the bits of an integer right by the specified number of bits, losing the bits pushed off the right side. This is equivalent to performing a div by 2^bits but is usually more efficient for large numbers.

2013-03-05

• Fixed currency conversions to work again.

2013-02-19

• The DFT and InverseDFT functions can now take 2-dimensional arrays as well as 1-dimensional arrays. See the Other Functions section of the documentation for details.
• Refactored the Fourier transform code to handle multi-dimensional arrays.
• Added sample program to demonstrate 2-dimensional Fourier transforms. Note that this file is not actually necessary, as 2-dimensional Fourier transforms are now built into Frink, but this demonstrates the algorithm simply.

2013-02-18

• Changed Java Introspection to partially work around the 15-year-old (I'm not kidding) Java Bug 4071957 (and its dozens of related bugs) which causes method invocation to fail on classes that are declared private, even if the methods are public and access would be allowed from normal Java code. This works around a major design flaw in Java's introspection. The fix this time now also looks in implemented interfaces to eliminate the problem.
• Added randomBytes[numBytes] function to generate an array of random bytes (as a Java byte array.)
• Added a sample of AES-256 encryption and decryption with proper padding and salting (I hope.)

2013-02-14

• The contents of an array can be randomly shuffled with the array.shuffle[] method.

2013-02-05

• Improved Frink-to-Java type conversions. The code now checks more strongly to see if numbers are dimensionless, are integer-valued, and will fit into the specified numeric type (e.g. int, byte, double, etc.)

  This helps to disambiguate between previously-ambiguous calls such as doSomething[int] and doSomething[float]. If the value is a floating-point value, the above will always select the float method, rather than indicate that the call is ambiguous. If the value happens to be an integer, this is still ambiguous, because the integer could be coerced to a float parameter (but not the other way around.)

  The code still does not try to disambiguate by the size of the value, such as between (int and short) or (double and float) if the value will fit into both, but if an integer value is too big to fit into a short, this will be unambiguous.

2013-01-31

• For Android: Added several improvements to reading from GPS and other sensors. These allow programs to wait for new inputs, instead of sleeping and polling:
  • Added getSensorService[sensorNum, updateFrequency] which allows the user to specify the update frequency for sensors. See the documentation for SensorService for more information.
  • Added SensorService.getAccuracy[] method to return the accuracy of the readings from the sensor.
  • Added SensorService.waitForValues[] method. This returns the latest raw values from the sensor as an array of floating-point values without dimensions. If new, unread values are available, this returns them immediately, otherwise it blocks until new values become available. This is much preferable to polling.
  • Added a waitForGPSLocationJava[] method which returns the current-known GPS position as a Java object of type Location. If a new, unread GPS location is available, this returns it immediately, otherwise it blocks until the next GPS location is available. It should not return data until GPS locations are being returned. This is much preferable to polling.

2013-01-24

• Optimized several control flow commands such as return, next, and break to be faster. When calling a tight loop with short functions that return data, performance was improved by a factor of 2.7 to 3.4 on some architectures and JVMs! Unfortunately, it's only 1.15 times faster on Android/Dalvik.
• Improved formatting of a list of statements. That is, doing things like dumping the body of a function.
• Several smaller optimizations to variable lookup.

2013-01-12

• For Android: Fixed listen[prompt, numOptions] to actually present no more than the specified number of options to the user. Thanks to Andrew Webb for the bug report.

2013-01-07

• Important: The security manager now checks to see if you have permission to call methods or write fields on Java objects when security is enabled (e.g. when you're in an eval statement or when restrictive security has been turned on.) This prevents untrusted users from calling potentially-unsafe methods on arbitrary Java objects that might be accessible from their scope.
• The last argument to callJava["classname", "method", argList] can now be eliminated if there are no arguments to the method.
• The last argument to callByName[obect, "methodName", argList] can now be eliminated if there are no arguments to the method.
• Internal changes to newJava function to simplify and reduce code.
• Refactored and modified internals of functions to allow getChildCount[function] and getChild[function, index] to do useful things. Child 0 of a function is now a string representation of its argument list, (which may change to a more useful object type in the future), and child 1, if it exists, is the body of the function. This may allow you to do interesting things like take the derivative of a user-defined function.

2013-01-05

• The argument to the lines[] function can now be a java.io.InputStream, allowing you to iterate over InputStreams provided by other libraries.
• The constructor new image[java.io.InputStream] allows you to construct an image from a java.io.InputStream, possibly entirely in memory.
• Fixed rendering of graphics that have both transformations and units of length.
• Updated some sanity checks in the calculation of historical values of the British pound for 2013.
• Updated deltaT calculations with current predictions. I'd like to unify and improve these by parsing the files available at https://maia.usno.navy.mil/ for UT1-UTC current values and predictions. (I already parse their leap seconds files.)
• Updated copyright statements to 2013. Happy New Year!

2012-12-13

• Happy Frink Day! Frink became provably Turing-complete 11 years ago, on December 12, 2001, at 10:16 PM MST when array manipulation first became possible. The first public announcement of Frink came a few hours later on December 13, 2001. I consider Frink Day to occur beginning 10:16 PM MST on December 12 of each year, and lasting for 24 hours. Let the festivities commence.
• Added additional graphics transformation convenience methods graphics.rotate[angle, cx, cy] and graphics.scale[sx, sy, cx, cy] to rotate and scale around the specified point respectively. See the Transforming Graphics section of the documentation for more information.
• Added arbitrary affine transform method graphics.transform[a,b,c,d,e,f] which allows you to specify all the coordinates of the affine transformation matrix, enabling skews and other effects. See the Transforming Graphics section of the documentation for more information.
• Added possibly-educational technical notes to the Transforming Graphics section of the documentation, showing how matrix math can be used to achieve various transformations.
• Fixed a problem where text alignment settings might be overwritten in the HTML5 renderer. The fix means a slightly more verbose HTML file, but it's probably necessary.

2012-12-12

• Java objects that implement the java.util.Iterator or java.util.Iterable interface are now turned into Frink enumerating expressions, which means that they can now be used in for loops transparently, among other uses. This is done in a call-by-name fashion so the code will still work on Java 1.1 and later.

2012-12-11

• Major New Functionality: Frink's graphics libraries now allow you to translate, scale, and rotate graphics on all platforms! This allows you to write simple code using the coordinate system that is most logical, and translate or scale it wherever you want. Like all of Frink's other graphics, Frink ensures that whatever you draw is automatically scaled and centered into the display no matter how confusing your transformations get, and can be exported to various file formats. You can now write programs with graphics transformations that work the same in Java with AWT or Swing, Android, SVG, HTML5, to printers, and in various bitmap files!

  This makes many graphics coding tasks much simpler. It also makes certain things possible that were impossible before, such as rotating bitmaps or distorting text. These few little functions add a huge amount of power, while even allowing you to simplify your code!

  See the Transforming Graphics section of the documentation for more information.

• For Android: Attempted to force a fix for a problem where programming mode might only have a single-line input. This only seemed to show up in the emulator, though.
• For Android: The file chooser for loading files in programming mode now allows you to choose the parent directory, allowing the reading of files from anywhere you have permission to read. (You're still not allowed to save to arbitrary directories yet.)
• For Android: Fixed a potential race condition when shutting down sensor services before they've had a chance to properly start. Thanks to the person who reported the problem via their Android device.

2012-12-07

• getBoundingBox[graphicsExpression] now returns undef if graphicsExpression contains an empty bounding box. (That is, there are no drawable elements in it.)
• Various internal improvements and fixes to expression transformation:
  • Improved formatting of method calls.
  • Improved formatting of object dereference expressions (i.e. obj.member)
  • Loosened construction of method calls so more symbolic transformations would work on them.
  • Added expression constructor for object dereferences. This means that you can now use expressions like obj.member in transformation rules.

2012-11-24

• For Android: The GPS receiver is now enabled with much more sensible update frequencies (1 second updates, no distance threshold.) Previously, this was set much higher (updates possibly as far as 60 seconds apart and a 1 meter distance threshold.) While older devices may have ignored the too-high settings, newer devices may have updated too infrequently, even when moving.
• For Android: Added a new two-argument function startGPS[minTime, minDist] which allows you to configure the GPS unit for less power consumption if you want less-frequent updates, or want to try to force your device to send updates more frequently than once per second (mine won't.) See the GPS/Location section of the documentation for more information about this function. You probably don't want to use this version of the function without a lot of testing on multiple devices and Android versions. (The Android documentation says that Android versions before 4.1 (Jellybean) could have ignored these settings.)

2012-11-11

• The following (undocumented and generally unused) functions have changed their behavior. They now do evaluate their arguments before being executed, which they did not before. This means that you may have to wrap the arguments to these functions in a noEval[expr] block if you don't want them to evaluate their arguments first:
  • childCount[expr] (Returns number of children of the expression.)
  • type[expr] (Returns the type of the expression as a string. This behavior may change to return a more useful object in the future.)
  • isConstant[expr] (Returns a boolean value indicating if the specified expression is constant.)

  Also note that the behavior of these "undocumented" functions may change in the future, or the functions may be removed entirely.

2012-11-09

• HTML5 graphics can render drawings with dimensions of length. Unfortunately, there is apparently no way to query a browser for its screen resolution, so these graphics won't be sized appropriately.
• Updated HTML5 canvas rendering to be more correct: in some places where the provisional HTML5 standard specified that integers are required, Frink would previously use floating-point numbers. While all browsers seemed to handle either case, it's good to be safe. Integers are now output in these situations.

2012-11-07

• Fixed problem in rendering ellipses in HTML5. They were being rendered incorrectly in some cases. (The provisional HTML5 standard specifies an ellipse function but most browsers don't implement that yet, so we have to draw circular arcs and transform them to kludge around it.)
• HTML5 graphics now resize to fit the width of the browser window and repaint themselves on resize to give optimal resolution. Printing is still jaggy and substandard because of deficiencies in the HTML5 specification. If printing, use SVG when possible.

2012-11-06

• Frink can now render its graphics to an HTML5 document, using HTML5's canvas feature. While HTML5 will not be a finalized specification until at least 2014, major modern browsers for desktop and mobile devices (Firefox, Chrome, Opera, Safari, IE) support the HTML5 features that Frink requires. This includes the following features:
  • Transmission of vector graphics in vector formats, allowing efficient, antialiased rendering of vector graphics.
  • Bitmapped images are transmitted within the HTML document as embedded data URIs encoded in base-64, allowing you to send the entire graphic as a single HTML file. Bitmapped images are transmitted at the end of the file, and displayed as they are loaded, allowing progressive display of documents containing multiple bitmaps.
  • All of Frink's graphics primitives are supported, including bitmaps, GeneralPath, partially-transparent graphics, and rotated text.
  • HTML5 is rendered to relatively simple, user-modifiable code.
  • Sample graphic: graphicsTest.html which was generated from graphicsTest.frink. Do a "view source" on the HTML file to see the generated code. Note that this includes vector graphics, multiple bitmaps, and rotated, partially-transparent text.
  • What doesn't work in HTML5 (future wish list):
    • Drawings with dimensions (e.g. a rectangle with width 1 inch) does not get rendered properly to HTML5. I'm still doing research to see if we can get a reasonable resolution figure from the rendering environment.
    • HTML5, for some ungodly reason, does not support the even-odd winding rule for filling graphics, which becomes important when drawing an arbitrary GeneralPath and self-intersecting filled polygons. HTML5 only supports the rather stupid and useless nonzero winding rule which will make some objects with "hollow" centers not render the same in HTML5 as they do in all other sane environments (e.g. Swing, AWT, Android, SVG, PostScript, PDF).

      This means that you may have to draw the inside and outside paths of an object with "holes" in different "directions" to make it work correctly. See GeneralPathTest.frink for an example of a working and non-working hollow object. The commented-out code demonstrates how the code had to be changed to accommodate this stupid deficiency in HTML5, which will hopefully be improved before the specification is finalized.

      Frink goes to some lengths to kludge around this problem, such as by alternating the drawing direction of circles/ellipses each time one is drawn. Sigh.

    • It would be nice if the graphic would re-render itself at the display device's resolution when resized. Note: this is implemented in the 2012-11-07 release, so the rest of this paragraph is for historical notes and unsolicited rants. I'm not sure how I'll handle this; there may be zoom in/out buttons, or the graphic may track the width of the window and automatically resize itself to fill the browser window. The HTML5 specification is kinda stupid about canvas dimensions; it only allows a hard-coded number in pixels to be specified for the size of the canvas, and printing doesn't happen at the printing device's native resolution. This is stupid. Compare this to the SVG specification, or Frink's display and print routines which handle all of these issues sanely.
    • Animation is not yet possible in HTML5. It's not clear if this will be possible without porting all of Frink to JavaScript.
    • All bitmapped graphics are embedded in PNG format. These may be larger than the corresponding JPEG graphics, but they are lossless and allow alpha channels, which JPEG does not allow. It's possible that there may be a switch in the future to embed bitmaps in JPEG format and to control the quality, or the renderer may get "smarter" and determine if alpha channels are present, and switch rendering formats for efficiency.
    • A single bitmapped image currently cannot be rendered several times in the same graphic without retransmitting it.
    • When rendering just a portion of a bitmapped image to HTML5, the entire original bitmap file is transmitted in the HTML5 document.
    • If the browser doesn't support the HTML5 canvas element, Frink could theoretically render a small thumbnail image (or full-resolution image, but that would be wasteful) showing the user what they're missing. If the browser doesn't support canvas, the user is warned about possibly needing to open the document in a newer browser.
• Refactored Frink's internal rendering of SVG and HTML documents into a common superclass and some derived classes, as all are approximately SGML applications with similar syntax and needs.
• Refactored the internal FrinkImage interface to render to an OutputStream instead of a File, which gives more flexibility to the rendering process, and allows images to be rendered to base-64 strings in memory, for example.
• Added image.toBase64[format] method to allow a bitmapped image to render itself to a base-64 encoded string in the specified image format (e.g. "jpg", "png").
• Added graphics.toBase64[format, width, height] method to allow a graphics object to render itself, as a bitmap, to a base-64 encoded string in the specified image format (e.g. "jpg", "png").

2012-10-21

• Added zip[a, b] and zip[a, b, defaultA, defaultB] functions to "zip" together corresponding elements of lists a and b and return each pair as a two-element array. See the zip section of the documentation for more.
• The base64Encode[expr, encoding] function can now take a Java array of bytes for the input expression.
• Added a base64DecodeToBytes[string] function to decode a base-64 encoded string to a Java array of bytes.

2012-09-29

• Added array.pushAll[array] method to push all elements of an array onto the end of another array.
• Added array.removeAll[value] to remove all elements in the array which have the specified value.

2012-09-13

• Made assignment-to-list more flexible:
  • [a, b] = 1 now assigns a=1 and b=undef (previously nothing was assigned if the right-hand-side was not a list.)
  • The values in the array on the left-hand-side can now be any assignable expression, not just simple variable names.
• Modified the map function:
  • If the number of arguments passed to the function are greater than the number of formal arguments declared by the function, the extra arguments will be passed as an array to the last variable in the function.
  • Fixed the case where the first argument to map is a string indicating the name of a function. This allows you to call simple functions like:

    a = [[1,2],[2,3],[3,4]]
map["lcm", a]

    Thanks to Hakan Kjellerstrand for many useful suggestions and tests.

2012-09-10

• Modified the date formats file to allow parsing of dates with single-digit days, like #2000 Jan 1#.

2012-09-05

• Fixed bug in split function when passed an empty delimiter string.

2012-09-04

• Rewrote the the multifor loop implementation to allow it to handle "triangular" loops where the bounds of one of the loops depends on the bounds of other loops. For example:

  multifor [f,g] = [new range[1,3], new range[f+1,3]]
   println["$f $g"]

2012-08-30

• For Android: Voice recognition (for as many languages as your device supports) is now available! The functions listen[prompt] and listen[prompt, numOptions] will now listen for voice input and return the text as a string. This is extremely powerful, and it allows you to write voice-controlled programs, automatic translators, voice calculators, and more! For more information, see the Speech Recognition section of the Android documentation.

2012-08-22

• Fixed null pointer exception when calling units[1] .
• For Android: Forced the spellchecker off in the input fields for interactive mode.

2012-08-21

• Yet again, further improved disambiguation of calling Java methods. This time, Frink tries harder to disambiguate when turning a Frink array into a Java array. Although Frink arrays are potentially heterogeneous, the new code looks at the first element of the Frink array to determine if it's mappable to the Java type. This handles many/most cases, but may need to potentially look at all elements in some cases, which it doesn't do now. Checking all elements could be a potentially huge performance hit, so it's not done now.

2012-08-20

• Further improved disambiguation of calling Java methods. Formerly, if a class implemented multiple interfaces, and we got unlucky in the order in which we iterated through method names, we could have failed to resolve ambiguities. This affected cases like a class which contained the following methods:
  • void doSomething(Serializable)
  • void doSomething(CharSequence)
  • void doSomething(String)

  Formerly, if we iterated in that order, the code would detect that neither of the interfaces Serializable nor CharSequence were more specific than each other (sharing no common parent class,) and disambiguation would fail. However, the new code now detects that String implements both interfaces and dispatches to the String version.

  A sane class hierarchy wouldn't have cases like this, but Android does not have a sane class hierarchy. This will help to work around some issues with Android calls, and enables us to do things like send messages prepopulated with text!

• Frink now throws a AmbiguousMethodException if method calls can not be disambiguated. (Previously, it would just print an error and continue.)

2012-08-16

• For Android: Made the right and left arrow buttons ensure that the cursor position was visible in the view when moving off the screen.
• For Android: Various changes to the text-to-speech functions, specifically those dealing with SAMPA. Huge thanks to Manny Neira for testing and extremely detailed reporting.
  • speakSAMPA now sends out a briefer SSML (link opens in new window) string that appears to work better on many devices. The language used is no longer hardcoded to en-US but should better follow your platform's voice.
  • Added encodeSAMPA function to allow you to encode part of a string to be pronounced correctly.
  • Added a lot of warnings and caveats to the documentation of the above functions, indicating that they may work differently depending on which text-to-speech engine you have installed.

2012-08-14

• For Android: Added a "menu" button to the button bar to work around Android's new stupid missing menu button.

2012-08-10

• For Android: Forced off spell checker in programming mode. This was causing significant performance issues on Android 4 devices.

2012-08-09

• For Android: Added right and left arrow key buttons to aid platforms where these keys are unavailable (like the Nook.)
• Added Unicode codepoint output when unrecognized characters are encountered in the input.

2012-07-07

• Added = to Android user interface. Thanks to Albert de Koninck for the suggestion.

2012-07-01

• Fixed Sloppy Time Specifications so that they would work properly if the time conversion might cause an increment or decrement of the day.
• Added formats like 9 AM and 10 PM to the date formats file.

2012-06-23

• Updated Sun position calculator pages to take arbitrary date/time values to calculate the position of the sun anywhere and anytime.

2012-06-20

• Made several improvements to the Frink Emacs Mode:
  • Made electric braces work better and tried harder not to indent inside a regular expression, quoted string, or anonymous function.
  • Suppressed echoes of input in comint-mode (which seems to be new in both Emacs and XEmacs.)
  • Forced cursor to jump to end-of-buffer when killing and restarting a Frink process. Due to race conditions, it may or may not have moved to the end of buffer.

2012-06-12

• Fixed foreign language translations to work again. The new code uses a regex-based solution, which is more powerful, robust, and will be easier to modify.
• Added set methods set.subsets[] and set.subsets[allowEmptySet, allowOriginalSet] to return subsets of the elements in an set. For more information, see the Sets section of the documentation.

2012-06-11

• The setDifference[arg1, arg2] function now tries to coerce its arguments into sets. This allows you to perform set-like differences on arrays and other types. Note that ordering and duplicates will be lost from arrays in this case.
• Added array methods array.subsets[] and array.subsets[allowEmptySet, allowOriginalSet] to return subsets of the elements in an array. For more information, see the Sets section of the documentation.

2012-06-09

• For Android: Pushed out a fix for the package installation errors that were occurring with the "2012-06-09" release from this morning. It appears that this was caused by a known bug in Google's tools, bug 19567, for which a fix has not been released yet.

  I've kludged in a workaround to my build processes to get a release out, and I've pushed it to the market. You should see the new version as "2012-06-09b". Sometimes it takes Google a long time from when I upload the new software until it is available in the Market or visible from devices, so please wait a bit if it's not visible.

• Added union[a, b] function to return the union of two intervals, or an interval and a real number. (Or two real numbers, in which case an interval containing both real numbers is returned.) The return type will be an interval or an ordinary real number if the two numbers are the same real number. It also works with dates and date intervals.
• Made the functions min, max, union, and intersection work with date intervals.

2012-05-13

• Made several changes to the input functions which make it easier and more consistent to build simple interactive applications that work consistently across operating systems, windowing libraries, and in text-based input mode:
  • Changed the single-item and multi-item input functions to behave similarly on user cancels. This means that if the user cancels/closes an input dialog, or end-of-file is encountered, all input functions return the special value undef.
  • In AWT mode: allowed the window "close" button to work on input dialogs. This will cancel input and return undef.
  • In Swing mode: made single-line input window return undef on window close. (Previously, you couldn't close it.) Made multi-line input windows return undef if closed/cancelled by user.
  • In text mode: single-line input functions will return undef when end-of-file (EOF) is encountered. If EOF is encountered on the first line of a multi-input field, the return value is the single value undef. If EOF is encountered after the first line of a multi-input field, the partially-completed values will be returned, and the rest of the fields will be undef.
  • For Android: For input function, hitting the "back" button now returns undef when cancelling single and multi-line inputs.
  • Added a new example of creating cross-platform user interfaces to take and process user input and handle cancellation gracefully. See the Making Interactive Interfaces section of the documentation for more.

2012-04-26

• When constructing a power expression, many roots are simplified at construction time to a more canonical form. For example, 4^(1/2) is immediately simplified to 2, and 8^(1/2) is immediately simplified to 2 * 2^(1/2). Other fractional powers are similarly simplified. The compile-time simplifications improve symbolic math. More compile-time simplifications and canonicalizations will follow.
• Expanded intersection[arg1,arg2] function to return the intersection of intervals or ordinary units. The return type in this case will be an interval or an ordinary real number. If there is no intersection between the arguments, the function will currently return undef although this behavior may change to return an empty interval in the future.
• Made the min and max functions do something sensible when passed overlapping intervals. (Previously, they just threw an OverlapException, which could be improved.)
• For Android: Updated Google's compilation tools, which forced me to delete some project files and recreate them rather than upgrading gracefully. (Nice.) Please let me know if anything broke.

2012-04-25

• Updated sun.frink to rename the function sunMoonAngularSeparation[date] to geocentricSunMoonAngularSeparation[date] to make it more clear that the calculation was from the center of the earth.
• In the same file, added a new function sunMoonAngularSeparation[date, lat, long] to calculate the angular separation of the sun and the moon from a particular point on earth. This is usually the function you want.

2012-04-10

• Multi-dimensional arrays of Java objects can now be constructed by passing an array of integers to the second argument of the newJavaArray function. For example, the following creates a two-dimensional array of double with dimensions 3 by 4:

  d = newJavaArray["double", [3,4]]
d@0@0 = 3.14

  See the Creating Java Objects section of the documentation for more.

• When passing an array of Java objects to a Java method, the disambiguation rules were improved to eliminate some incorrect "can match" errors.

2012-04-02

• Added single-argument constructor new dict[array] to construct a dictionary from an array. See the Dictionary Constructors section of the documentation for more.
• Added toDict[array] function which behaves exactly as the constructor above.
• Added two-argument constructor new dict[keys, values] to construct a dictionary from two separate arrays (or enumerating expressions.) See the Dictionary Constructors section of the documentation for more.
• Added dictionary.invert[] method to return a new dictionary with key-value pairs inverted. See the Dictionary Methods section of the documentation for more.
• Internally rewrote enumerating expressions for better compile-time typesafety.

2012-04-01

• Added functions ceil[x,y] and floor[x,y] to round x up or down to the nearest multiple of y, analogous to the two-argument version of round. See the Rounding Functions section of the documentation for more.
• The read and lines functions now allow the first argument to be an instance of java.io.InputStream, which simplifies reading from other input streams (for example, reading from a URLConnection or an external process, or a pipe.)

2012-03-01

• For Android: Added experimental unit name completion in interactive mode. You can now start typing the first 2 or more letters of a unit name, and Frink will present an autocompletion list. This seems to be slow in some Android devices, so if it becomes too ponderous, it's gone. If it's useful, it may be expanded. Note that this list does not include all possible completions; you can still enter suffixes or units that may not be listed (like dollar_1910).
• For Android: Added a class file that may have been missing from the past release.

2012-02-16

• Added a map[function, list] applies the specified function to all the members of a list, and returns a new list containing the results. See the map section of the documentation for more.
• Added getFunction[name, numArgs] which returns a reference to the function with the specified name (specified as a string) and number of arguments. This can then be assigned to variables, or called as noted in the Anonymous Functions and map sections of the documentation.
• Rearranged split and join sections of the documentation.

2012-02-08

• Added functions for converting text to/from base-64 encoding. See the Other String Functions section of the documentation for more information.
• Added a "fallback" constraint source that will match arbitrary object names.

2012-02-06

• Added a built-in Writer class to enable easy writing to files without including external libraries. See the Writing Files section of the documentation for more information.
• Changed these documentation pages to reflect the fact that I'm now putting new announcements on Twitter at @frinklang, and not using Freshmeat any more.

2012-02-03

• Improved error messages when array bounds errors occur.

2012-01-26

• Added urlFile[string] to return a string indicating the filename of a specifed URL string, that is the last path part of a URL (e.g. "http://futureboy.us/frinkdocs/whatsnew.html" will return "whatsnew.html")
• Added urlPath[string] to return a string indicating the entire path of a specifed URL string, (e.g. "http://futureboy.us/frinkdocs/whatsnew.html" will return "/frinkdocs/whatsnew.html")
• Added browse[URL] function to launch the specified URL in your computer's browser (or however your computer likes to launch things.) This also works on Android, but Android doesn't like to launch many protocol types other than http.
• Wrote a colorillusion.frink program to draw color illusions like the one here. (You'll want to supply your own image file.) I don't think my algorithm is quite right yet, as colors easily become saturated or blocky and don't produce quite the right colors in the inverse. Note that this program requires today's release of Frink!

2012-01-21

• Updated data file to account for the leap second that will be introduced at the end of June, 2012.

2012-01-18

• Worked around some weird issues in calling methods on Java objects. I ran into weird cases where multiple methods have the same signature (function name and arguments) but different return types. The code now tries to disambiguate and uses the method with the most specific return type. I don't know if that's what you actually want to do, so let me know if there are issues with this.
• Added a cool demo program to use Java's MIDI music synthesis to play music from Frink. See midisynth.frink . Note that your Java Virtual Machine must have implemented this feature. (e.g. Sun/Oracle's JVM works, while OpenJDK does not.)

2012-01-16

• Updated the secant.frink file to invert a given function using the secant method, which is pretty cool.

2012-01-06

• Updated planets.frink with the radii and masses of planets, and allowed calculation and drawing of bright limb angle.
• Updated sun.frink to allow drawing of the illuminated fraction of planets.

2012-01-03

• Added the ability to draw part of an image into a graphics object. See the new functions in the Images section of the documentation.o
• As of 2011-12-01, Google has eliminated free access to their translation APIs, so they are no longer available through Frink. If you wish to pay for an API license, you may still be able to modify GoogleTranslate.frink (although the version 2 API has changed significantly.)
• Added isComplex[expr] function.
• Updated sanity checks for the year 2012.
• Updated copyright dates.
• Forced creation of frink directory on Android.
• No leap seconds were added at the end of 2011, so no changes were made.

2011-12-05

• Text in graphics can be now drawn rotated at any angle. See the Graphics with Text section of the documentation for more information.

2011-11-15

• Changed eulerTotient[1] to return 1.
• For Android: Made input fields expand themselves to multi-line, rather than always horizontally scrolling.

2011-11-10

• Updated many units in the standard data file (particle masses, charges, gravitational constant, Planck's constant, etc.) to match 2010 CODATA values, which were first released by CODATA in June, 2011. A reference for the 2010 CODATA values can be found at NIST.

2011-10-31

• Refactored arrays to ensure that all implementations are hashable and have the same hash code.
• Added hashCode[expr] to return the hashcode for a particular expression.

2011-10-25

• Fixed a bug in the allFactors function which effectively made the parameter onlyToSqrt always equal false. Thanks to Tom Louie for the bug report.
• Added a three-argument sort function to allow the user to pass in arbitrary "helper" data to be used in a sorting operation. See the Sorting section of the documentation for more information. Thanks to Jim Fishman for the report.

2011-09-16

• Modified the read[location] to read from standard input (stdin) if passed the argument "-". See the Reading Entire Files section of the documentation for examples.

2011-09-15

• Added the ability to call functions and methods by name using the callByName[object, methodName, argList] function. See the Calling Functions and Methods by Name section of the documentation for more.
• Added slice[array, start, end] and sliceLength[array, start, length] functions to take a "slice" out of an array.
• Modified the lines[location] to read from standard input (stdin) if passed the argument "-". See the Reading Lines section of the documentation for examples.
• Added messageDigestInt[str, algorithm] to calculate a message digest and return its value as an integer. See the sample program drawMD5.frink which graphs the output of subsequent inputs to the MD5 hashing algorithm.

2011-09-05

• Added array.combinations[take] method to generate the combinations of the elements in an array. See the Array Methods section of the documentation.
• The sample program pokerhands.frink demonstrates using the combinations method to enumerate all possible 5-card poker hands.

2011-08-17

• Various improvements and changes in Frink-Java mapping:
  • When calling methods on Java objects, when there is ambiguity, Frink now attempts to find the method with the most specific arguments. For example, if a class has methods doSomething(String) and doSomething(Object), and the method is passed a string, Frink will call doSomething(String). This will not yet disambiguate between primitive types.
  • Java function calls that return void now return Frink's void type instead of undef. I don't really like having a void type, so this may change back.

2011-08-16

• Fixed currency conversions to work again.

2011-08-11

• The newJava function now displays the original cause of the exception in the case of an InvocationTargetException.

2011-08-10

• Made improvements to make it easier to read data from standard input (stdin) using the input functions.
  • input functions now return undef at EOF, or when the user enters an end-of-file (EOF) character (usualy Ctrl-D on Unix variants, Ctrl-Z on Windows).
  • Removed the single-space of padding if the empty string is specified as the prompt of the input function. A trailing space is still added if the prompt string is non-empty. This is to make input legible and give some uniformity to both GUI-based and command-line based calls to the function.
  • The multi-line input form of the input function now returns undef for arguments on which the user enters the EOF character and for following arguments.
  • Piping input from another file or process and reading it with the input functions now works in a less error-prone fashion. Previously, it could throw NullPointerException if you were testing its return value in certain ways. Now, with it always returning undef on EOF, its behavior is more predictable.
  • If, for some reason, you're in a GUI mode and you still want to read from standard input, you can call readStdin[] to read one line from standard input. This is just like calling input[""] from command-line mode, which is what you really want to be calling if you're trying to make programs that work both interactively and non-interactively, and in GUI mode and non-GUI mode.
  • Improved synchronization and removed multiple constructions of buffers that caused problems with reading single lines from stdin.
  • Modified some logic when reading from stdin to ensure that we always catch EOF.
• Some more exponential expressions are simplified at compile-time, such as 12^-1 is immediately reduced to the exact rational number 1/12.

2011-08-01

• Added additional security restrictions in sandbox mode.

2011-07-28

• Added security restrictions to parseToExpression[str].
• Improved Java mappings from expressions to expressions.

2011-07-14

• For Android: Many user interface enhancements for programming mode, including:
  • Created a new preferences screen.
  • Font size selection moved to preferences screen.
  • Allowed the user to hide the "run" buttons on screen. These can still be accessed with Menu+R or through the new "Run" menu item.
  • Stack size is now user-configurable.
  • Mode switch menu item now just takes one click to switch to "convert" mode.

2011-07-11

• Improved construction-time optimizations for NOT operator.

2011-07-10

• Optimized setIntersection[set1, set2] function.
• Added setsIntersect[set1, set2] function.
• Improved documentation of the date formats file.
• Added allFactors function to find all factors of a number, not just the prime factors. See the Number Theory section of the documentation for more information.
• Allowed bounds in a for loop or range object to be boolean values, for example: for a=false to true.
• Improved the documentation for the for loop.
• Added construction-time optimizations for the not operator. If possible, this simplifies boolean expressions on construction.
• The graphics.print[] and graphics.printTiled[pagesWide, pagesHigh] functions now print with no insets--that is, they print as wide as possible on the page. (Previously, they filled up 95% of the page.) If you want the old behavior, see the new functions that take insets arguments in the Showing Graphics section of the documentation.
• The image.print[] and image.printTiled[pagesWide, pagesHigh] functions now print with no insets--that is, they print as wide as possible on the page. (Previously, they filled up 95% of the page.) If you want the old behavior, see the new functions in the Images section of the documentation.

2011-07-07

• Added image.getPixelAsColor[x,y] and image.setPixel[x,y,color] to allow getting/setting pixel colors from a portable color object that can also be used on graphics objects.

2011-07-06

• Fixed a bug where multi-line comments might cause syntax errors in classes or interfaces.
• Added Dymaxion.frink library file and demo file drawDymaxion.frink to draw maps of the world using the Buckminster Fuller "Dymaxion" icosahedral projection.

2011-07-02b

• For Android: Increased the size of the stack in Programming Mode to 128kB (many Android environments allocate only 8 kB for the stack.) For very memory-limited devices, this may cause problems with programs running. It will, however, allow programs with deeper recursion to run. Please let me know if there are problems running on some devices.

2011-07-02

• The methods[obj] function will now display argument types and return types of a method if known. Notably, this is only for methods on Java objects at the moment. This makes it easier to play around interactively with Java objects without a reference.
• Made construction of complicated bounding boxes for graphics expressions more efficient.
• Added getBoundingBox[graphicsExpression] to return the bounding box of a graphics expression. See the Graphics Functions section of the documentation for more.
• Added calculations for the centroid and area of a polygon to the geometry.frink sample program.
• Added a Country.frink library containing country shapes and a cool demonstration program drawCountries.frink to draw them.
• Added degree symbol ° (\u00B0) to the standard datafile as a synonym for degree. This is an angular degree and should not be used for temperatures.
• Improved the "Save File/New File" GUI ergonomics for Android. Worked around a stupid android bug which doesn't let you select the beginning of a line, and fixed an incorrect display name of the file to save.

2011-06-26

• The manifest file of frink.jar now launches the Swing GUI by default. If you're on some old Java VM without a Swing implementation and you've been launching Frink by something like the equivalent of double-clicking the file, you'll need to specify the old AWT main class when you start. See the Running Frink section of the documentation for more information.
• Fixed double-drawing of polyline in an enviroment that uses Java's Graphics2D class. This might have manifested as "blurred" polylines if your Java platform's renderer isn't repeatable. The internal method for rendering also changed from using a GeneralPath to Graphics2D.drawPolyline, which might be a bit faster or more memory-efficient.

2011-06-23

• Added product[x] function to return the product of the elements of an array or enumerating expression.

2011-06-22

• Added Unicode divide operator ÷ ( \u00F7 ) as a synonym for the normal divide operator. And why not. This complements the other Unicode multiplication operators × ( \u00D7 ) and the Unicode "INVISIBLE TIMES" operator ( \u2062 ).
• Refactored formatting functions to make it easier to add new typesafe formatters.

2011-06-19

• Updated planets.frink to calculate rise, set, and transit times of planets, added functions to calculate when a planet would be at a specified altitude, and improved the secantAzimuth calculations to work better around discontinuities.

2011-06-18

• Updated sun.frink in the following ways:
  • Revised rise/set calculations for the sun and moon to use a smarter calculation for the initial guess.
  • Added functions to calculate approximate rise, set, and transit times for arbitrary bodies.
  • Added moonTransit and sunTransit functions.
  • moonrise, moonset, sunrise, and sunset functions now return undef when the body is circumpolar and does not rise or set for that date (rather than just doing something undefined.)
• Extended the Moon position calculator and Sun position calculator pages to calculate and display transit times and altitudes.

2011-06-03

• Removed incorrect double-eval when retrieving values using the array dereference operator array@index . Symbolic values can now be retrieved from an array correctly.
• Added new range[lower, upper] and new range[lower, upper, stepSize] constructors to create a range operator. This is similar to writing lower to upper or lower to upper step stepSize, but more useful in many places.
• Changed the operation of the range operator to be more useful in more places.
• Modified the documentation of the multifor loop to use the new range syntax.
• Added allFactors2.frink sample program to find all factors of a number using the multifor construct. Compare this to the allFactors.frink program which does not use the construct.
• Added documentation about the new range syntax to the For Loop documentation.
• Revised several classes internally for maintainability.
• Added multifor structure support to the Frink Emacs Mode.

2011-05-29

• Added a new multifor loop construct to perform several loops at once. See the multifoor loop section of the documentation.

2011-05-26

• Added toString[expr] to convert an expression into a string. This could already be done in other ways, but this may be more concise in certain cases.

2011-05-25

• Added binaryToGray[num] and grayToBinary[num] functions to convert numbers to/from binary reflected Gray code. More information in the Other Functions section of the documentation.
• The arguments for new array now match the arguments for makeArray See the Initializing Arrays section of the documentation for more information.
• Added a three-argument version of the select statement that allows you to pass in arbitrary helper data.
• Added a mastermind.frink program to solve Mastermind near-optimally.

2011-05-18

• Worked around a bug in Java's Calendar.add method which exists in some JVMs. This would cause displayed times of day to be sometimes in error by an hour when doing date/time math around a daylight saving time boundary, usually only during part of that day. It is very strongly recommended to update.

  It's not clear which JVMs are susceptible to the above bug, but it occurs in the latest JVM from Oracle and in current OpenJDK. All calls to the broken and insane Calendar.add methods have been removed.

  Due to the way that date/time values are stored internally in Frink (as a Julian Day referenced to UTC,) this bug only occurred when formatting dates for display to the user. Internal calculations were still likely to be correct, and this error did not tend to propagate unless a date was output and that text re-parsed as input.

2011-05-17

• Added makeArray[dims, initialValue] and makeArray[dims] functions to allow easy construction and initialization of multi-dimensional (and one-dimensional) arrays. See the Initializing Arrays section of the documentation for more information.
• Added several new distributions to statistics.frink including exponential, Weibull, and log-normal distributions.

2011-05-12

• Added Poisson distribution calculations to statistics.frink and improved documentation.

2011-05-04

• Improved compile-time optimization and canonicalization of some exponentiation expressions, notably, things like (1/2)^(-1/2) are canonicalized to 2^(1/2).
• Added performance improvements to certain operations that deal with non-real numbers.

2011-04-28

• Removed double-printing of errors in some cases in the GUI.
• Improved cursor movement between windows in Frink Emacs Mode.

2011-04-24

• Fixed null pointer exception when drawing a polygon/polyline when it has no points.

2011-04-21

• Allowed search-and-replace regular expression to substitute its value back into any assignable expression, not just simple variable names.

2011-04-19

• Added a tutorial on regular expression syntax to the documentation.

2011-04-15

• Added methods to get/set the value of a pixel in an image as values from 0 to 255, rather than as floating-point numbers. These allow you to work with pixel values as integers, if that's what you prefer. See the Images section of the documentation for more.
• Fixed argument list for getPixel[x,y] in the documentation. (Arguments were omitted.)
• Added more ways of evaluating exponents at compile time.
• Added functions for adding/subtracting date/times with leap seconds taken into account. These functions are called addLeap[date,offset] and subtractLeap[date2,date1]. For more information see the Leap Seconds section of the documentation.

2011-04-13

• Created a new frink-discuss mailing list on Yahoo for more detailed discussions about programming problems, help requests, and discussing features in detail. The original "Frink" group at Yahoo is for more low-traffic general announcements about Frink, and topics of general interest related to Frink

2011-04-12

• Frink now returns exact integer and rational roots for numbers when possible. Previously, exact integer roots were only returned for the square root case. For example:

  a = 10^100
a^(1/20)
100000

  (8/125)^(1/3)
2/5

• Added bitwise functions bitAnd[n,m], bitOr[n,m], bitXor[n,m], bitNor[n,m], bitNand[n,m], and bitNot[n] to perform efficient bitwise operations on numbers. See the documentation for more information on how these functions work.

2011-04-08

• Updated the output formatter to make sure that exponents with a negative base like (-2)^x are parenthesized properly on the left-hand-side. Standard mathematical notation treats negation as having lower precedence than exponentiation, so the exponentiation is performed first and then the result is negated, unless the left-hand-side is parenthesized.

2011-04-07

• Updated == and != operators to test sets for equality and inequality. Previously, they just returned the identity equality (that is, true iff both sets pointed to the same object in memory.)
• Fixed the internal equals method for sets to be more reliable.
• Removed the deep copy that was performed on keys to dictionaries and values placed into sets when they were inserted. This puts a bit more responsibility back into the hands of the programmer to not modify objects that are used in sets or as keys to dictionaries without performing a deepCopy[expr] call. It does, however, allow reduced memory usage and faster execution, and more control to the programmer.
• This change fixes a problem visible in the experimental Solver.frink library which occurred recently due to the fact that objects created from a class specification were made deep-copyable, and were deep-copied when put into a set, triggering the problem, which manifested itself when the identity comparison == started returning false for the copied object.

2011-03-29

• Rewrote boolean algebra expressions (AND, OR, NOR, NAND, NOT, IMPLIES, XOR) to be able to have an arbitrary number of children.
• Boolean algebra expressions are now flattened so that expressions like a AND b AND c are parsed into a single AND expression with three children.
• Enhanced pattern matching of boolean algebra expressions so that all possible permutations of sub-expressions are tested. This allows automatic simplification of boolean expressions, etc.
• Revised construction of boolean algebra expressions to ensure flattening.

2011-03-25

• Arrays and date/time values can now be used as keys in dictionaries and sets. It's probably always a bad idea to use a date/time as a key to a dictionary, just as it's a bad idea to use a floating-point number in the same context, but it's now possible.

2011-03-24

• The deepCopy[x] function now also copies the fields of objects generated from a class specification. It performs a recursive deep copy of all the parts of a container class. The function can be called with any expression type. The function currently deep copies everything contained in arrays, dictionaries, sets, and objects created from a class specification, and everything contained within them. It is thus useful for copying nested data structures, multi-dimensional arrays (which are arrays of arrays, etc.) and prevents modification of the original or the copy from changing the other. It does not currently deep copy Java objects, nor Java arrays, nor enumerating expressions.

2011-03-20

• Updated sun.frink to add moonApogee[date] and moonPerigee[date] functions.
• Extended the Moon position calculator page to calculate and display apogee and perigee times and distances.

2011-03-10

• Allowed C/C++/Java-style block comments that can span multiple lines or comment out just part of a line. This style of comments can also be nested.

  /* This is a
   multi-line comment. */

  See the Comments section of the documentation for more information.

• Frink Emacs Mode updated to handle the new block comments. Unfortunately, XEmacs 21 does not handle nested comments properly at this time, so nested comments may not be highlighted exactly like they will be parsed. If comments are not nested, everything displays just fine.
• Once again fixed the "shebang" parsing. That is, if the first line of your file is something like:

  #!/path/to/frink

  then you can start Frink programs easily from a (newish) Bourne or bash shell, by just typing the filename, instead of frink thefilename. (Up until recently, many versions of bash or sh wouldn't allow you to specify another script as your start script; it required an "executable binary" magic number.)

• Updated the script that colorizes programs for the web server to highlight block comments.
• Forced input fields in Multi-Input box to be opaque to work around inconsistencies in rendering in different JVMs. This fixes the "light text on white" problem in some JVMs.

2011-03-03

• Revised the order in which symbols are looked up. Names of classes (basically for static methods) are now looked up before units. The name of a class will thus hide the name of a unit! If you need a hidden unit, you can preface it with the prefix unit_
• Added a new function source into which user-defined functions will be parsed. The major impact of this change is now that user-defined functions will hide built-in functions with the same name. (Currently there is no warning if you do so.)

2011-02-26

• Changed the human-readable description of mol in the standard data file from substance to amount_of_substance.
• Added additional rants about the mol and the Hz to the data file.

2011-02-22

• Added binomial distribution calculations to statistics.frink.

2011-02-21

• Fixed single-line if/then and if/then/else statement. Thanks to Laszlo Hars for the bug report.

2011-02-20

• The text-mode input[] function now prints the default value in square brackets.
• Expanded and improved the error messages when mapping to/from Java types.

2011-02-15

• Modified the color and padding of the Swing Multi-Input dialog.

2011-02-08

• Added a new Multi-Input facility that lets you prompt the user to enter multiple pieces of information with a GUI, using just a single line of code:

  [first, last] = input["What is your name",[["First Name", "Jeff"], ["Last Name", "Albertson"]]]
  

  

  This works on Swing, AWT, and Android GUIs, and in pure text mode.

• Added a try/finally block to allow the programmer to ensure that resources are closed no matter what happens in a code block. See the Try/Finally section of the documentation for more.
• Frink Emacs Mode updated for the new try/finally blocks.
• Allowed quick creation of literal sets, e.g.

  b = new set[1,2,3] // Construct a set with the specified elements
  

• Added toSet[x] function to turn the specified expression into a set, if possible. This works with enumerating expressions, arrays, or simple expressions (making a single-item set out of the latter.)

  c = [3,6,9] // Create an array
d = toSet[c] // Create a set from the array


  The following single-line program demonstrates turning an enumerating expression into a set (the lines[url] function returns an enumerating expression of all of the lines in a file,) turning that into an set (to remove duplicates) and sorting it (implicitly turning it into an array in the process.) The result is a sorted array containing all of the unique lines in a file, discarding duplicates.

  sort[toSet[lines["file:myfile.txt"]]]

• The "shebang" functionality has been slightly improved. That is, if the first line of your file is something like:

  #!/path/to/frink

  then you can start Frink programs easily from a (newish) Bourne or bash shell, by just typing the filename, instead of frink thefilename. (Up until recently, many versions of bash or sh wouldn't allow you to specify another script as your start script; it required an "executable binary" magic number.)

• For Android: Modified the Android manifest so that you could move Frink to your SD card. This forced me to update the target SDK version to 8, which I hate doing and which is stupid, but it's the only way to do it. This may let programming errors leak through because the compiler is no longer checking that I don't use features that aren't in Android 1.5.

2011-01-22

• Fixed SVG rendering so that SVG can be rendered in a Frink Server Page. See the Rendering Graphics section of the Frink Server Pages documentation for more information.
• Modified SVG rendering so that it by default renders in UTF-8 format.
• Added a Braille renderer Frink Server Page for converting text to Braille.

2011-01-17

• Greatly improved the root.frink sample program which finds roots and exponents to arbitrary precision. It now reliably finds integer and rational roots reliably and quickly. It may become part of the standard distribution soon.
• Added Braille.frink and BrailleTest.frink sample programs to encode text into Braille (including Unicode representations) and render it graphically to standard sizes and formats suitable for punching with a slate and stylus. Currently, only Grade 1 Braille (the version of Braille without contractions) is supported.

2011-01-16

• Updated deltaT (the offset between Dynamical Time and UTC) with updated predictions for the years 2012 and later, with three new curves. The earth's rotation hasn't been slowing down as much as had been predicted in the past.

2011-01-10

• Added repeat[str, times] method to repeat a string the specified number of times.
• Added padLeft[str, width, padChar] and padRight[str, width, padChar] functions to pad a string to the specified width.
• Added a new font width guesser which hopefully reduces the overestimation of the bounding box for text in graphics mode. Previously, it was assumed that each character was as wide as it was tall, which is only true for characters like lowercase "m". The new guesser tries to use ordinary character widths for common fonts. This should make bounding boxes tighter for text, and fit better, at the possible risk of making text run off the screen when rendered.

2010-12-31

• Fixed some foreign language translation pairs to work again.
• Updated sanity checks for the year 2011. There will be no leap second added at the end of 2010, so no changes are necessary to Dynamical Time calculations.
• For Android: Added speakSAMPA[str] to speak strings encoded in the Extended SAMPA alphabet. This allows you to describe exactly how text is to be pronounced.

2010-12-30

• Fixed problem in selecting from multiple functions with the same name and different numbers of arguments when some functions had default arguments. This now gives correct behavior; some previous (incorrect) programs may no longer work.
• Frink is now built with JFlex version 1.4.3. This may give a slight performance increase. Please let me know if you notice any differences in parsing.

2010-12-15

• Internal cleanup of a few minor questionable code constructs identified by FindBugs.

2010-12-09

• Added set.shallowCopy[] method.
• Removed NullPointerException when calling a constructor with a nonexistent argument list when the constructor requires an argument list.
• Improved error messages when assignments fail.
• Added internal check and error message to prevent assignment to negative array indices.
• Added argument to eval[expr, rethrows, hidesPrevious] function to allow hiding of local variables.
• Allowed objects created from a class definition to be added to sets and dictionaries. For now, only the identity of the object is used for hashing.
• Added more rules to solvingTransformations.frink
• Lots of amazing updates to the all-new simultaneous equation solver! It's not quite complete yet, but it is solving systems of equations that it could never solve before!

2010-12-01

• Added getSymbolsByComplexity[expr] function to return a list of the symbols in an expression with a rough estimate of their depth and usage.

2010-11-25

• For Android: Changed the manifest file to explicitly request permission to write to the SD card. Earlier versions of Android allowed you to write to the SD card without requesting this permission.

2010-11-20

• Added methods to the Frink class to simplify setting of variables from an Object. See Frink's integration methods, specifically for the Frink class.

2010-11-19

• Added more deep copy points when inserting into a set or dictionary.

2010-11-18

• For safety, Frink now performs a deep copy on any key used in a dictionary or set. This may make it somewhat slower to insert complex objects as keys into sets or dictionaries, but it will also prevent lots of problems if you modify the original key.
• Added "set" constraint so a variable can be forced to be a set.

2010-11-06

• Made the font size in the output window match the font size in the programming window, both in the Swing and AWT GUIs. Thanks to Peter Padilla for the report.

2010-11-04

• Improved error message for child[expr, index] when expression has no children.

2010-11-03

• Greatly improved the statistics.frink sample program in various ways:
  • Improved inverseErf and inverseErfc calculations greatly by implementing a much faster algorithm for their tails. This improves performance by orders of magnitude in the tails of the inverseErf and inversePhi functions.
  • Added inversePhi[phi, mean, sd] function.
  • Improved dispatcher functions to call the best algorithms for different number sizes.
• Greatly improved the root.frink sample program in various ways:
  • Fixed behavior of sqrt for numbers between 0 and 1.
  • Fixed behavior of sqrt for numbers too small to be represented by IEEE-754 double-precision math, that is, smaller than 10^-323.
  • Allowed sqrt function to work with negative numbers.

2010-11-01

• Fixed historical currency conversions for the British Pound. Thanks to Phil Lewis for the bug report.
• Fixed lexicographic permutations for zero-element lists.
• For Android: Added a horizontal scroll bar to the tool buttons in programming mode.

2010-10-29

• For Android: Revised the tool buttons in interactive mode. They are now horizontally scrollable, and two new buttons have been added to repeat previous calculations.
• Repeating previous calculations now sets the cursor to the end of the line.

2010-10-27

• For Android: Fixed a crash that occurs when selecting text backwards in the interactive interface and then hitting a tool button. Thanks to whoever chose to hit the "report" button on their Android!

2010-10-20

• Added setDefaultTimezone[tzstring] function to allow setting of default timezone used for parsing and display.
• Reordered default output date format to put the most significant information (AM or PM) before the time. Thanks to Dr. Joachim Wiedemann-Heinzelmann for the suggestion.
• Fixed a lot of date formats to require that 12-hour date formats have an explicit AM or PM specifier. This was not done consistently.
• Added a lot of date parsing formats to ensure that dates could be written or parsed with AM or PM before or after the time specification.
• Extended the date formats file to ensure that dates that could be produced could be parsed.

2010-09-12

• Made it possible to put sets into dictionaries, or into other sets. A set can even be put into itself. Whitehead and Russell, take note. However, you shouldn't try to print out cyclic data structures like this yet. (In fact, it actually triggers an internal Java Hotspot crash.)
• Added dict.containsKey[key] method to see if a dictionary contains the specified key.

2010-09-07

• Fixed newlines in translations from Google Translate engine.

2010-09-06

• Fixed incorrect double-eval in array.push[x] method. You can now push symbolic quantities onto an array correctly.
• Renamed unit kcal_mol to be cal_mol so various prefixes would work with it. You can still write kcal_mol of course.
• Added similar unit J_mol so you could write stuff like kJ_mol. Thanks to Richard Terrett for the suggestions.

2010-08-09

• For Android: Improved handling of potential race conditions for shutting down GPS or other services before they start. This guarantees that all services are shut down on exit, even if they are requested to be shut down even before their thread starts.

2010-08-08

• For Android: Fixed a potential crash if you stop the GPS receiver before it even gets a chance to start.

2010-08-03

• For Android: Fixed a potential crash when changing from convert mode to programming mode from within the user interface.
• For Android: Greatly improved the behavior of both conversion and programming modes when the display is rotated or the keyboard is slid in/out. Normally, Android restarts the entire application in these cases, which loses results of your running calculations, loses the state of your interpreter, and forces you to recreate interpreters, which can be expensive. This removes a lot of the annoying problems when (intentionally or accidentally) rotating the device or moving the keyboard.

2010-07-27

• For Android: Files with the extension .frink can now be launched from applications like Astro, or launched with an Intent with the ACTION_VIEW action. (the data must be a Uri with a file: URL.) This allows you to, say, make a folder of Frink programs on your Android device that can be opened with a single click. See the Viewing Files section of the Android documentation for more information.

  The following restrictions on launching files are for security reasons:

  • The file will not be run by default, but will require the user to hit the "run" button, to ensure that they intended to run the program.
  • Files with the .frink extension will be launched if they are on the filesystem. Files with the .frink extension will never be launched from http URLs or from the network.

2010-07-22

• Added an entry about the odd history of the (choose one: acre, rod, furlong, township, section, league, statutemile, etc.) to the FAQ because it is indeed a frequently asked question. Full text here.

2010-07-20

• Added more synchronization to Frink Server Pages dispatcher. This makes Frink Server Pages both more robust when hit with simultaneous requests, and helps prioritize requests so that a single user session making a lot of simultaneous requests doesn't monopolize the server.

2010-07-19

• Renamed some internal directories after painstakingly figuring out with several days' effort that the Android Market would silently make your entire application disappear for everyone in the world if your .apk file contained a directory called "/lib", even if it didn't have anything in it. Dear Android Market, you are the worstest thing evAr!

2010-07-16

• Added the Google Translate program GoogleTranslate.frink functions to the standard distribution. This gives a lot more language translation pairs. Unfortunately, the quality of the Google Translate engine is quite poor, and fails to even try to translate a large percentage of strings for many languages. See the Google Translations section of the documentation for more.

2010-07-08

• Extended the Google Translate program GoogleTranslate.frink to handle translations to/from other languages, to handle errors better, to guess languages, and to automatically guess the language that a text is written in and translate it to your language. These functions may make it into the standard distribution soon.

2010-07-07

• Added some error messages and diagnostic information and eliminated a NullPointerException when trying to run on a platform with a broken classloader that doesn't load resources correctly from Frink's jar file. (Notably Jython, probably related to their bug 1373.)
• For Android: Handled the "back" button in the program output view so it would just switch back to the program window instead of exiting Frink entirely.

2010-06-20

• For Android: The programming mode now watches for changes to the current program and prompts you to save any changes before loading another file or creating a new program.
• For Android: Added "New Program" option to Android's programming mode. This clears the current program (prompting you to save first).
• For Android: The Android version of Frink now requires Android 1.5 (API level 3) or higher. This was necessary to do some simple things such as tracking when the user changes data in a field. I based this decision on Google's metrics which show that only 0.1% of users are running anything before Android 1.5. If someone is running Android 1.1 and really needs Frink to work on that device, let me know.

2010-06-18

• Finished a large rewrite of Frink's expression matching and replacement facilities. This fixes some subtle but tricky problems with pattern matches that require significant backtracking and re-ordering of expressions. This was hard. Really hard, which is why it took so long. But it's awesome now.
• Further increased the awesomeness of the systemSolver2.frink program which solves systems of equations. It now solves even more systems correctly.
• Updated the Frink Solver page to use the new functionality. It also now performs some simple integrals (e.g. try Integrate[1/x+x, x])

2010-05-14

• Fixed a problem when modifying a transformation rule (with default values and a condition) in which the condition would not be copied when substituting parts of the rule.
• Updated hubbleconstant with the latest WMAP data.
• Internally modified the representation of operator precedence to make more sense.
• Ensured that when printing out expressions containing operators that rational numbers are treated with the precedence of a multiply/divide operator. This ensures that expressions like x^(1/2) are printed correctly with those parentheses.

2010-05-08

• Further improved symbolic math capabilities by making undefined function calls evaluate their arguments before returning themselves.
• Added isRational[num] function which returns true if a number is a rational number (and not an integer,) false otherwise.
• Further increased the awesomeness of the systemSolver2.frink program which solves systems of equations. It now detects simultaneous equations and solves them correctly.

2010-05-07

• Added a variety of functions for sets. These allow you to obtain the union, intersection, and difference of two sets, and to determine if a set is a subset or proper subset of another set. See the Set Functions section of the documentation for more information.
• Added the triple-equals operator === which is intended as a special form for equations that are going to be solved, manipulated, and rearranged. It does not do any evaluation on its children, so equations can be passed around to functions easily. Its behavior may change.
• Added noEval[expr] special function that does not evaluate its arguments, but passes them to the next level unmodified. It is primarily useful for symbolic manipulation. It's similar to the Lisp "quote" operator, if that helps you.
• Added expression constructors for === operator and for symbols. This simply means that they can be used in transformation rules.
• Added constructExpression[stringType, [args]]
• Modified the function getSymbols[expr] which to return a set of symbol names (now as strings.) This may change again!
• Added a variety of security checks when creating transformation rules, executing transformations, or constructing expressions.
• Added lots of mathematical rules to solvingTransformations.frink to allow it to solve cubic equations, equations with positive and negative unknowns on the same side of the equation, and to use the new triple-equals === operator.
• Revised the Frink Solver page to use the new functionality.
• Added a magnificent new systemSolver2.frink which solves systems of equations as a demonstration of the new facilities. It's not really documented yet, because it will change, but it's awesome.

2010-04-29

• Added inverse hyperbolic tangent function arctanh[x] or atanh[x]. This function works for complex and interval arguments.
• Added lcm[x,y] function to return the least common multiple of two integers.

2010-04-05

• Fixed problem where Android might produce the error "Your Java platform does not support the BufferedImage class." This allows Android to create a new writable, modifiable image with the new image[width, height] call.

2010-03-31

• Improved an error message when trying to access a member variable of an object that actually wasn't an object at all.
• Eliminated a null pointer exception when trying to print out a null expression.

2010-03-29

• For Android: Added a doUI[expr] function to execute the specified message on the user interface thread. Android requires that many methods, including anything to create views or user interface components, is executed on the UI thread. This allows you to call more Java methods to create Toasts, AlertDialogs, etc, that require construction or modification on the UI thread.
• For Android: Worked around some problems in the text-to-speech service where we were not properly notified when an utterance was complete.

2010-03-23

• Rewrote threading model for displaying input dialogs and graphics windows on Android. This reduces the numbers of Threads and Loopers created and runs all graphics on a single thread. This may eliminate some problems hinted at in reviews (but never officially reported) that on some old platforms, alert dialogs and other input windows might appear behind other windows, however that may happen.

2010-03-09

• Added graphics.show[width, height] and graphics.show[width, height, insets] methods to allow display of a graphics window at a specified size (when supported on the target platform.) See the Showing Graphics section of the documentation for more information.

2010-03-05

• The graphics.color[r,g,b] and graphics.color[r,g,b,a] methods now return a color object that you can use again later to set the color.
• Added graphics.color[colorObject] method so you can set the color with a color object you obtained from the calls above.
• Added constructors new color[r, g, b, alpha] and new color[r, g, b] to create a color object. See the Shapes and Colors section of the document for more information about these methods. Thanks to Duncan McKenzie for the suggestions.
• Regenerated the (expired) signing certificate for frink.jar. This may prompt you to accept the new certificate if you're using Java Web Start.

2010-03-03

• Improved some error messages when performing incorrect conversions.

2010-03-02

• Fixed a possible NullPointerException when trying to assign to something that wasn't a dictionary as if it were a dictionary.
• Improved error messages when working with dictionaries.

2010-02-26

• Fixed Frink-to-Java mappings to allow mappings from Frink's strings to any interface implemented by Java's String class (notably CharSequence which was first introduced in Java 1.4 and is becoming popular.) Frink still only requires Java 1.1 and later.
• Added "What's New in Frink" link to the help menu in the Android interfaces.
• Wrapped more thread methods in the Android interface in try/catch blocks because they like to throw exceptions rather than do nothing gracefully.
• Expanded the Permissions section of the Frink on Android documentation describing the permissions that the package requests.

2010-02-22

• Attempted to handle "out of memory" conditions on the Android platform, which is very memory-limited.
• The Android platform's programming mode now auto-saves the program state before trying to run it, in case of out of memory conditions or other unexpected errors.
• On the Android's programming mode, Frink now tries to catch OutOfMemory errors (and other Throwables) and present them to the user, rather than allowing Android to "force close" the application cryptically. These are memory-limited devices, and often have hardly any free RAM available. However, it's usually impossible to do anything useful after an OutOfMemoryException, no matter how hard you may try.
• Added more verbose error messages when Java throws a low-level error.
• Fixed a problem on Android 1.5 where a class was not being verified properly (yet it worked on 1.1 and 2.0!). This could cause graphics to fail or the application to not load at all on Android 1.5. Thanks to Leonardo Boselli for bug reports and testing!
• Added some catch blocks to prevent problems when Android devices complain about calling deprecated thread methods. (Actually, instead of complaining reasonably, they throw nasty exceptions.)
• Added Memory Issues section to the Frink on Android documentation describing the limitations of Android devices.
• Removed references to AWT classes that could cause difficulties on some platforms with over-eager verifiers.

2010-02-20

• Simplified the sample program on the Android program to draw graphics, but not require a GPS receiver or Geocoder.

2010-02-19

• Added expression constructors for new expressions and method calls. This simply means that they can be used in transformation rules. As a result of this, you can now do something resembling operator overloading of user-defined classes, such as in the simulatedOverload.frink sample program.
• Eliminated some NullPointerExceptions in the Android code if you're attempting to access sensors or GPS and your device returns null for these. This allows programs to recover from errors more simply. These calls now return undef where Java returns null.

2010-02-15

• Modified the Swing programming mode's output window to be less intrusive. This involved rewriting it as a JFrame instead of a JDialog, and causing it only to bring itself to the front and change its visible state on the first output of a run. The change from JFrame to JDialog was necessary as it's apparently impossible to programmatically uniconify a JDialog?! This means that the output window won't be minimized when the programming window is minimized, but you'll be able to edit programs more easily as they are running and producing output.
• Improved scrolling of Swing programming mode's output window when it produces output.

2010-02-13

• Simplified the initial program that's presented to the user in the Android programming interface.
• Fixed and expanded documentation in the Frink for Android documentation.

2010-02-12

• Released Frink on the Android Market. (It's called "Frink Programming Language") If you have already installed Frink on your Android device, you'll probably need to uninstall it before installing from the Market.

2010-02-11

• Made consistent search paths for use statements on the Android platform.
• Added documentation on the SensorService class for the Android platform.

2010-01-27

• Fixed an overeager sanity check in Frink's symbolic simplification routines that caused the error "Error in evaluation: Expression requires 2 or more arguments." when evaluating a simple expression. Thanks to N.S. for the bug report and creating a very simple testcase. Updating is highly recommended.
• In the Android user interface, added the ability to change font sizes. Font sizes can be set differently in interactive mode and programming mode, and persist when the application is closed.

2010-01-25

• Fixed a problem in the expressionContains[a,b] function to properly match expressions. This manifested itself in a failure to reduce the double derivative D[D[x,x], x].

2010-01-14

• The sun position calculator now uses the Geolocation API supported by mobile browsers and Firefox 3.1 to automatically request your latitude and longitude.
• The moon position calculator now has a timezone selector to enable you to display results in any of the timezones that Frink supports.

2010-01-13

• Added interactive mode and the ability to run programs from the menu in Frink Emacs Mode. Thanks to Elliott Hird for some sample emacs code.

2010-01-09

• Various fixes for the Android's programming mode, including saving files to the proper subdirectory they were loaded from, and some other minor usability improvements.

2010-01-06

• Added the function URLEncode[str, encoding] to encode a string to be used as part of a URL. The encoding should probably be the string "UTF8" for most applications.
• Added a test program GoogleTranslate.frink to translate text using Google's translation API. It requires the URLEncode function above to work, so this release is required.
• Added functions isSubset[setA, setB] and isProperSubset[setA, setB] functions to perform relation tests on sets.

2010-01-05

• Made the output window in Android's programming mode output in a threaded fashion. This improves performance greatly (appending a lot of small pieces of output was sped up more than 50 times).
• Fixed a logic error when adding a new function source. This may have manifested as an ArrayIndexOutOfBoundsException when running programs repeatedly and rapidly on the Android platform.

2010-01-04

• Updated sanity checks for the year 2010.

2009-12-16

• Announced the first release of Frink for Android mobile devices. This is a full port of all of Frink's features, not a limited subset. This provides a wonderful marriage between an easy-to-use programming language and a powerful, standardized platform with real-world sensors and other interesting features. It should work on all Android platforms version 1.1 and later. (API Level 1.)

  This includes anti-aliased graphics with transparency, animation, image manipulation, integration with the Android's sensors, GPS, text-to-speech, and other features. For more details please see the Frink for Android page.

• The Android port consists of about 4000 lines of new code, and some architectural changes and rewrites to the graphics code, which mostly consisted of removing references to classes not available on Android. The rest of Frink (about 100,000 lines of code) compiled without modification, primarily because I take lots of care to only use Java constructs that will be available on all platforms.

2009-11-16

• The moon position calculator now uses the Geolocation API supported by mobile browsers and Firefox 3.1 to automatically request your latitude and longitude.

2009-10-16

• Added function getSymbols[expr] which returns a set of symbols defined in the expression.

2009-10-15

• Added transformExpressionDebug[rulesetname, expr] and transformExpressionDebug[expr] to transform an expression and return the intermediate expressions and the transformation rules used.
• The various transformExpression...[rulesetname, expr] functions can now also take an array of strings for the rulesetname parameter which contains the names of multiple rulesets to apply.

2009-10-08

• Fixed a problem in the expression sorter which caused symbolic arguments to be sorted incorrectly, and thus not simplified correctly.

2009-10-04

• Major New Functionality: Patterns can now have default values which allows you to write a much smaller number of rules. The default value is written as:

  (_a:1)

  Which creates a pattern called _a which, if it does not appear, is assigned the value 1. For example, if you wanted to match a quadratic equation, with optional coefficients for each of the the terms, you could write your pattern as:

  (_a:1) _x^2 + (_b:1) _x + _c

  See the solvingTransformations.frink file for a concrete example of a transformation rule that solves quadratic equations.

  The method for replacing the default value is pretty interesting and complicated. It actually undergoes all of the symbolic reductions that ordinary expressions undergo, so you can generally write your pattern the same way you write your equations. Again, all possible orderings of commutative/associative operators will be tested.

• Added a link to the "Frink with libraries" distribution in the Java Web Start section of the documentation.
• Added solvingTransformations.frink, solve.frink and commonTransformations.frink libraries to the "Frink with libraries distribution.

2009-10-02

• Fixed a stupid mistake (missing parenthesis in the quadratic equation) in solvingTransformations.frink.

2009-09-30

• Added the new amazing Frink Solver to demonstrate Frink's new equation manipulaton capabilities. This solves a variety of algebraic equations with just a small number of rules.
• Split the solvingTransformations.frink file into a set of rules and a demonstration file, solve.frink.

2009-09-29

• Major New Functionality: Frink's mathematical transformation capabilities have been greatly extended to allow the following:
  • Commutative and associative operators (e.g. multiplication and addition) can now match patterns in any permutation of arguments automatically. This greatly extends the power of pattern matching, and allows single rules to be defined that have great power.
  • Patterns with conditions can now be backtracked and all permutations of the pattern are checked. Previously, patterns with conditions might fail if the pattern was matched successfully and then the condition failed. Now, all permutations of arguments are tried until one succeeds.
  • Added facility for generalized backtracking in pattern matching.
• Extended the solvingTransformations.frink sample file which demonstrates a powerful algebraic equation solving system with only a small handful of rules!
• Enhanced substituteExpression[orig, from, to] to backtrack and try all patterns with conditions in all possible orders.
• Added isPositive[num] and isNegative[num] functions which return true if a number is a positive (or negative, respectively) dimensionless real number, false otherwise.
• Added transformations block to create a named set of transformation rules which can be applied to an expression. See below. Also see the solvingTransformations.frink file which demonstrates the use of this construct.
• Added transformExpression[rulesetname, expr] and transformExpressionTrace[rulesetname, expr] to apply a named set of transformations to an expression.
• Added transformExpressionTrace[expr] function to transform an expression and return the intermediate steps as a list.
• In the standard data file, modified the defintion of molarvolume to follow the accepted defintion (its units are now m^3/mol.) This allows easy conversion of some quantities to and from moles. For example, to find number of moles in 1 gallon of gas at STP, you can use:

  1 gallon / molarvolume
0.16888608262948273721

2009-09-28

• Fixed planets.frink library to work with the changes I made to class initialization in the 2009-09-14 release.

2009-09-22

• Major new functionality: Frink's symbolic transformation routines can now test all of the orderings of operands in associative/commutative expressions (e.g. multiplication, addition) to match many more patterns with a single rule. In fact, it matches all orderings if there's not a conditional. This essentially allows symbolic algebra to be possible with a small number of rules.
• Added named lists of transformation rules that can be applied by name. This allows different rulesets for solving equations, for example. See the next section for an example.
• The solvingTransformations.frink file now solves many more types of expressions. This demonstrates using named sets of transformation rules and can solve a lot of your algebraic equations.
• Added isUnit[expr] which returns true if the specified expression is a unit of any type, including dimensionless numbers.
• Changed the key handlers in the GUI (both AWT and Swing) multi-line input boxes to no longer move to previous calculations when you pushed the up or down arrow. You can now use Ctrl-Up and Ctrl-Down to navigate and Ctrl-Enter to execute the command.

2009-09-18

• Added a two-argument version eval[expression, rethrows] where the rethrows argument is a boolean flag indicating if we want errors to be thrown or just suppressed and undef returned. If it is true, errors will be rethrown as Java exceptions.
• Updated the web-based interface to output more error information, instead of just "undef" on error. I noticed some calculations that people had been running that Frink outputs a meaningful and helpful error message for, (which is displayed if you're running Frink in an applet, or from the command-line, or on your own computer,) but those error messages were being suppressed in the web interface. This wasn't very useful or educational and made Frink look less capable than it really is.
• Restored spelling suggestions and other helpful text in the web-based interface when the user tries to convert an expression with unknown units.

2009-09-15

• Improved and expanded Frink's symbolic transformation routines to handle transformations where the result is split into a list of multiple solutions.
• Using the above fix, updated the solvingTransformations.frink file to solve equations with squared terms. (The solution becomes a list of multiple solutions.)
• Added a font size selector to the Swing GUI.
• Added methods[object] function to list the methods of an object.
• Made Java objects return a useful list of all their methods, so now the methods on a Java object can be listed with something like:

  f = newJava["java.awt.Frame", []]
sort[methods[f]]

2009-09-14

• Fixed a problem with values of external variables "leaking in" to class variable initialization. This happened particularly in a case where a call to a class triggered class initialization, and a local variable in the calling scope shadowed a global unit definition that was used in a class-level variable initialization in the class.

  In other words, this is a potentially severe bug and it is highly recommended that you update your version of Frink.

• Added methods getPressureAltitude[pressure] and getDensityAltitude[density] to StandardAtmosphere.frink. In addition, fixed a potential problem with calculating molecular Hydrogen densities below 150 km.
• Fixed all graphics.writeFormat... methods to allow a filename argument of "-" which writes the image data to standard output.

2009-09-13

• image.print[] and image.printTiled[pagesWide, pagesHigh] methods to an image to allow them to be easily printed to a printer.
• image.show[] now displays images at their original size by default.
• If you're using the Swing GUI, you can now right-click in an image window to print the image to a printer.

2009-09-09

• If you're using the Swing GUI, you can now right-click in a graphics window to print a graphic to a printer. More features to follow.

2009-09-03

• Frink Server Pages can now draw graphics which will be sent to the browser. These graphics are rendered in memory, without the need for saving temporary image files on your web server (which fill up drives, and need to get cleaned up, and may never be requested, etc.)

  See the Rendering Graphics section of the FSP documentation for more.

• Added the numberCheckerboard.fsp sample program, which demonstrates Frink Server Pages' ability to draw graphics. See its output. (Refresh it to get a new board.)
• Using the above facilities, added a drawing of the moon's illuminated limb to the Moon position calculator.

2009-09-02

• Updated sun.frink to add moonrise and moonset functions to predict rising and setting times of the moon.
• Extended the Moon position calculator page to calculate and display moonrise and moon set times.

2009-08-31

• Updated sun.frink to fix moonSecantAzimuth and sunSecantAzimuth functions to handle wrapping around the circle.
• Added signum[x] function to return a number indicating the sign of its argument. More information in the Other Functions section of the documentation.

2009-08-30

• Fixed an important bug which could cause underflow when raising a floating-point number to a large negative rational power. It is very strongly recommended to update.

• Improved cases of float^-float in the exponentiation operator which would normally underflow using IEEE-754 math. These fixups makes Frink return nonzero results for these cases and extends beyond the range of IEEE-754 numbers.

2009-08-24

• Modified the .jnlp files for Java Web Start to hopefully allow Frink to start properly even if you're offline or my servers are down. I already had the offline-allowed setting enabled, but found another switch dealing with shortcuts that would cause JNLP to throw an exception if the server was unavailable.

2009-08-15

• Improved the cases where x-x would be symbolically simplified to 0. This affects date calculations in a subtle way. A date can now be multiplied by zero, returning 0 s.
• Completed implementation of U.S. Standard Atmosphere, 1976 from the 86 km to 1000 km levels. This required changing method signatures to allow correct calculations at higher altitudes.

  See StandardAtmosphere.frink.

• Updated StandardAtmosphereTest.frink to conform to the above changes.

2009-08-12

• Major New Functionality: Frink now supports generalized animation with smooth double-buffering (on a modern JVM with Swing.) See the Animation section of the documentation for more information on how to animate images.

  In short, this is done by calling the replaceGraphics[g] method on a graphics window. Thanks to Warren Schudy for the suggestions.

• Added sleep[time] function which sleeps for the specified amount of time. The argument time must have units of time, for example 1 s or 4.9 minutes or 1/30 s. This supports smooth animation.

2009-08-04

• Improved the cases where x-x would be symbolically simplified to 0.

  Note that this change was rolled back later in the day because it caused premature simplifications of some expressions. Please obtain the current version.

2009-07-19

• Important Change: The compiler now tries to perform more symbolic simplification and optimization of symbolic expressions as they are constructed or evaluated. For example, the following transformations are now applied:
  • Gathering of additive terms: x + 2x is transformed into 3x.
  • Gathering of multiplicative terms: x * 3x^2 is transformed into 3 x^3.

  This allows purely symbolic conversions to be performed. For example:

  pack = 10 dog
tribe = 10 pack
tribe / dog
100


  Hint: to avoid "undefined symbol" warnings, call symbolicMode[true] which suppresses warnings about undefined variables and changes some behavior when encountering undefined symbols from fail-fast to a more tolerant deferred evaluation.

  Note that at all times, dog is an undefined variable that is manipulated purely symbolically. Also note that prefix, suffix, and plural checking is not performed on local variable names, so you can't write dog or dogs interchangeably like you can if you define a concrete unit.

  These changes should be essentially invisible to most programs, but may have an effect on variables that later contain interval arguments. The symbolic simplification will sometimes create a different result than the original formulation may have produced. In most cases, the resultant interval will actually be tighter than the previous result, such as in the case:

  a = new interval[-2, 3]
a*a
[0,9]


  Note that this interval is tighter than a naïve implementation which would produce [-6,9]. This will also symbolically simplify expressions such as x/x to 1.

• Added functions isDefined[x] and isVariableDefined[x] to test if an identifier is defined in the current scope. The difference is that isDefined[x] checks local variables and unit definitions, while isVariableDefined[x] just checks local variables.

  These functions can be called with either a variable name or a string. For example:

  isVariableDefined[a]
isVariableDefined["a"]

  See the Testing Variables section of the documentation for more.

• Weakened the equality check for two different "new" operators so they're not considered to return identical objects, even if called with the same arguments.
• Fixed the conversion operator -> to allow more relaxed conversion of undefined variables to give better symbolic behavior.
• Improved printing of several expression types, including assignment statements, comparison expressions, and boolean operators such as AND and OR.
• Added the ability for transformation rules to have conditions that must be met before they are applied. For example, a rule to make sure that x is on the left-hand-side of an expression is:

  solve[_left == _right, _x] :: freeOf[_left, _x] <-> solve[_right == _left, _x]

  The condition follows the :: operator. This allows much more powerful transformation rules to be written. For example, see the solvingTransformations.frink file which solves many algebraic equations with only a very small number of rules.

  Note that the syntax for anything dealing with transformation rules may change.

• Changed the signature of a method in a base class which caused its logic to be changed in about 100 classes.

2009-06-15

• Added DFT[array, divFactor=-1, direction = 1] and InverseDFT[array, divFactor=-1, direction = 1] functions to make a Discrete Fourier Transform of the specified array, or its inverse. These were previously only available in the Fourier.frink external file.

  Note that the default value for divFactor has changed in both of these files. If your code relied on the default value of divFactor, you may need to specify it. See the Number Theory section of the documentation for more information.

2009-06-14

• Made Re[x] and Im[x] (functions that return the real and imaginary parts of a number return the number) with its units rather than blowing up if the number wasn't dimensionless.

2009-06-09

• Added eulerPhi[n] function to calculate the Euler's Totient of a number. See the Number Theory section of the documentation for more information.

2009-05-30

• Added facilities for getting and setting individual pixels of an image, for creating images in memory, and for averaging values of pixels. This allows image processing and analysis. See the Images section of the documentation for more.

2009-05-15

• Modified the sorting of symbolic expressions so that the expression 3x sorts before the expression y. This is necessary to make a variety of symbolic transformations easier to write.
• Made converter expression -> print "Unconvertable expression:" before the expression if it's not convertible and not in symbolic mode. This may make it more clear that the conversion failed. If in symbolic mode, this returns the partially-converted expression, which might succeed later after setting variables and calling eval[] on it.

2009-05-05

• Fixed the Unicode symbol for the British Pound Sterling, which was incorrect. Since many other countries use this same symbol for their currencies, the Unicode symbol may be removed someday.
• Added the prefix unit_ to the standard data file. This allows you to use the original definition of a unit even if you've "shadowed" it by declaring a local variable with the same name. For example, if you define a local variable called g, that hides the original definition of the gram. You can get the original definition of the unit g by writing unit_g instead.

  Note that this is not generally a problem when writing programs. If you realized that you shadowed a unit definition that you want later in the same function, just rename your variables and run the program again. It's only a problem in interactive sessions, where you're already at the top level and can't undefine the variable.

• Added functions[] function to list the signatures of all functions.

2009-04-26

• Warning: This release changes the behavior of the abs[x] function when called with an interval argument. It does not alter its behavior for any other numerical types (e.g. real or complex numbers.)

  The behavior of the abs[x] function has changed for interval arguments. Previously, it returned a single scalar value instead of an interval. To be precise, it used to return the absolute value of the endpoint furthest from zero (which is a definition that goes back to Ramon Moore's early texts on interval analysis.) However, this was considered to be a surprising definition by many (including myself.) It didn't follow the spirit of absolute value for real numbers, it chose one endpoint arbitrarily as being more important than the other, discarded the other endpoint and the "main/middle" value, and caused loss of information and unexpected results when passing interval arguments to a program initially written with real numbers in mind.

  Thus, after surveying a large number of implementations of interval arithmetic and discussing this with the leading practitioners in the field, it was decided to change the implementation of this function to more closely follow the spirit of the definition of abs[x] for real numbers, and to follow a more modern convention that is widely used in interval arithmetic implementations. The abs[x] function now returns an interval (possibly with a main/middle value) which contains the interval that would be obtained by calling abs[x] on both endpoint (and the middle value) of the interval, with one exception. If the interval contains zero, then the lower bound of the new interval will be zero.

  The previous behavior is now moved to a new function called magnitude[x] which returns a scalar which corresponds to the absolute value of the endpoint farthest from zero. For symmetry, another function mignitude[x] has been added, which returns the absolute value of the endpoint closest to zero.

  This change should make the results of passing an interval to an equation designed for real numbers much less surprising.

  Thanks to Alan Stebbens for the initial inquiry into this behavior, and to the respondents on the "Reliable Computing" mailing list and on the IEEE-1788 expert group mailing list, which is working toward defining an IEEE standard for interval arithmetic. Special thanks to R. Baker Kearfott, Arnold Neumaier, George Corliss, Ramon Moore, Dan Zuras and Richard Smith for directly answering questions related to these definitions.

  Please see the Interval Arithmetic Status section of the documentation for more information about the new functions.

2009-04-19

• Fixed Frink-to-Java mappings to allow mappings from JavaObjects that wrap one of Java's primitive types (e.g. JavaObject:int) to be mapped to that primitive type in a Java call.

2009-04-18

• Fixed some "Class not found" exceptions that may have occured when rendering graphics to files (e.g. graphics.write[] or when calling leap-second-related functions like TAIMinusUTC. This was due to calling some classes by name, and those names no longer matched their obfuscated versions in the jar file available to the public.
• Improved some error messages when a function could not be called.

2009-04-17

• Fixed calculation of bounding box for text when its font was specified with units of length, e.g. g.font["SansSerif", 1 inch]. The fix improves cases where the bounding box was wildly overestimated, and caused everything to be drawn very tiny. However, there's really not enough information available at the time that the bounding box is calculated (because we don't know what other objects may be drawn) to calculate an accurate bounding box. Thus, a zero-sized bounding box is calculated, which may make constant-sized text be drawn off screen if it's too big, but it eliminates the "everything drawn too small" problem.
• Fixed a variety of internal warnings found by gcj.

2009-04-16

• Updated sun.frink library to add several functions to draw the shape of the moon's crescent for any time.
• Updated mithengemoon.frink program to use Frink's graphics library to render the path of the moon when it aligns with MIT's Infinite Corridor. See my MIThenge pages for more, including new graphs of the moon's path.
• Updated Sun Locator webpage to enable selection of timezones, improved display of lat/long, and reordered output fields.

2009-04-09

• Major new functionality: Added image loading and drawing capabilities! Frink now has the ability to load bitmap image files (e.g. JPEG, GIF, PNG) and display them onscreen, or resize and render them to a graphics object (which can then be printed, saved to a file, printed tiled across several pages, modified, drawn upon, etc.)

  This gives the ability to modify images, add watermarks or text to images, build collages or thumbnails, rescale images, overlay transparent images on each other, and much more. See the new Images section of the documentation to see how to load and display images.

• Added methods graphics.write[filename, x, y, insets] and graphics.write[filename, x, y, insets] which allow you to control the borders around your graphics when written to a file. The default is to only use 95% of the width and height of the image file to allow a small border around the image, but setting insets to 1 (which equals 100%) forces 100% of the space to be used, that is, no border to be drawn. This allows an image to be effectively re-rendered to different formats, watermarked, or modified, without changing its size or introducing a border.
• Added rewriteImage.frink sample file which loads a bitmap image and writes a semi-transparent watermark on it and then saves it back out to a file. Demonstrates image loading, drawing over images, and saving image files at their original size.
• Fixed an off-by-one error in the calculation of the bounding box when writing to image files. This was probably undetectable until the changes above were made which allowed an image to be loaded and rewritten.
• Modified the initialization of some data structures in the Frink interpreter to hopefully improve startup performance. The actual improvement is rather small (about 5%,) and may further be improved by deferred initialization of standard functions.

2009-03-28

• Added new methods to GeneralPath to allow drawing of true ellipses and circular arcs. This allows drawing of perfect circles with transparent holes in the center, which was previously impossible. Previously, circular arc segments could be approximated with cubic Bézier curves, but this was an imperfect approximation.

  More information is available in the GeneralPath section of the documentation.

• Updated sample program GeneralPathTest.frink to demonstrate drawing with ellipses and circular arcs.
• Internally rewrote the GeneralPath class to allow these new curve types, and to allow curves to calculate their own tight bounding boxes.
• The definition of marsday has been changed to use the solar day instead of the sidereal day. Both definitions are still available, as always, as marssiderealday and marssolarday.

2009-03-22

• The commands graphics.print[] and graphics.printTiled[pagesWide, pagesHigh] now also render the background color. The background color was not drawn previously in an attempt to minimize ink usage, but this is easier than drawing a colored rectangle for the background.

2009-03-10

• The graphics package gets a powerful new GeneralPath class which allows drawing of complicated outlines and filled shapes, which may be composed of straight lines and quadratic and cubic Bézier curves. This allows filled shapes with transparent holes (such as the letter "P") which were previously impossible to obtain.

  Note: The GeneralPath functionality is only available under Java 1.2 and later.

  More information is available in the GeneralPath section of the documentation.

• Added sample program GeneralPathExample.frink to demonstrate drawing cubic and quadratic curves, and generate the image files used in the documentation.
• Added sample program GeneralPathTest.frink to demonstrate the GeneralPath class's ability to draw filled shapes with open holes, which was previously impossible.

2009-03-03

• Improved exponentiation operator for rational exponents, e.g. (1/4)^(1/2). Previously, if intermediate results were too big (such as when the numerator of the exponent became large enough,) this could stop the program with an error due to overflow. This situation has been fixed.
• Changed the graphics.show[] method to suppress printing "frink.graphics.PaintController" if it's the last method called in a program.

2009-02-19

• Added descriptions of several operators to the standard data file, and improved the descriptions of others.
• In the same file, extended my diatribe against the candela, and cited some hopeful progress between the BIPM and the CIE which may someday get us to a workable, authoritative, single definition for the candela at more than one infinitesimal wavelength.

2009-02-18

• Fixed foreign language translations to work again.

2009-02-04

• Added the ability for a graphics window to repaint itself on demand, allowing graphics to incrementally paint itself onscreen. There is more information in the Animation section of the documentation.

2009-01-03

• Happy 2009! Updated some sanity checks and copyright statements for 2009. Note that the 2008-11-14 release made allowance for the leap second that was introduced at the end of 2009.
• Updated the currency for Slovakia to the Euro which took place on January 1, 2009.

2008-12-12

• Added functions to track all leap seconds that have been added to the calendar, or, more precisely, functions to return the difference TAI-UTC for any given date, where TAI is International Atomic time and UTC is Universal Coordinated time. The function TAIMinusUTC[date] returns this value. See the International Atomic Time (TAI) section of the documentation for more details.

2008-12-05

• Fixed conversion operator (->) when the left-hand-side is an interval and the right-hand-side is an array, like:

  a = new interval[1.0 kg, 2.0 kg]
a -> ["lb", "oz"]
[(2 lb, 3.2739619495804129157 oz), (4 lb, 6.5479238991608258314 oz)]

  Previously, this would return strange results in a strange format that didn't make much sense. Thanks to Mark Feeney for reporting the problem.

• Slightly changed the value of the sidereal day to match best-known results.

2008-12-04

• Updated a lot of currency codes for exchange rate calculations. Some obsolete currencies may now contain the word OBSOLETE but will still be convertible at their last known exchange rates. Thanks to Jenny Williams for researching the changes.

2008-11-29

• Fixed rendering of background color when rendering graphics to image files.

2008-11-19

• Modified the ISO-4217 code for the Russian ruble.
• Made a change to the Zaurus installer per a suggestion by Gus Collins.

2008-11-15

• Worked around an apparent Java bug where polylines with a wide stroke weren't joined properly when printing (they rendered fine on the screen for some reason.) This was finally worked out by changing the "cap" of the stroke, changing it from CAP_SQUARE to CAP_BUTT. This may make some polylines slightly shorter at the endpoints then they were rendered before, but makes it easier to butt them up accurately against each other.

2008-11-14

• A leap second will be introduced at the end of 2008. The Dynamical Time corrections have been updated to take this into account. Although predictions are impossible to make, this correction of 66.184 seconds is assumed to continue through the beginning of 2012. After that, the correction reverts to the predictions given in Jean Meeus' Astronomical Algorithms.

2008-11-13

• Modified the graphics.writeFormat[filename, format, width, height] methods so that if filename is the string "-" then the image file data is written to standard out.

2008-11-11

• Updated 19 units in the standard data file to match 2006 CODATA values. A reference for the 2006 CODATA values can be found at NIST.

2008-11-09

• Improved bounding box calculations for objects with a wide stroke outline. This prevents objects with a large stroke from extending off the screen.

2008-11-04

• Added graphics.printTiled[pagesWide, pagesHigh] method to allow a graphics object to be printed to a printer at extremely large sizes and tiled across several pieces of paper.
• Since scaling to these large sizes usually requires thicker lines, added the method graphics.stroke[width] to change the width of the stroke used to draw lines, polygons, or other outlines. (Note that the stroke width can not be changed in Java 1.1.)

2008-11-02

• Fixed historical currency conversions for the British Pound.

2008-10-29

• Fixed the case that Frink Server Pages might stop showing floating-point approximations to rational numbers. This was actually caused by a single FSP page turning off approximations globally. Yuck.
• Updated the mod_jk connectors on my webserver, which will hopefully improve reliability of Frink Server Pages.

2008-10-24

• Added the following array methods:
  • array.remove[index] : Removes the item with the specified index from an array and returns its value.
  • array.removeRandom[] : Removes a random element from an array and returns its value.

  More information is available in the Array Methods section of the documentation.

• Added the function randomSeed[seed]. To obtain repeatable results with a program that generates random numbers, sometimes it is desirable to use the same random sequence. This function seeds the random number generator with a known value. The seed must a number from -2⁶³ to 2⁶³-1 (both inclusive.)
• Added the program Boggle.frink to create random 5x5 Boggle game boards either in text or graphics modes. Thanks to Jenny Williams for the ideas and research.

2008-10-21

• Added the method graphics.text[text, x, y, horizontalAlign, verticalAlign] to allow text to be drawn with its sides aligned to the right, left, top, bottom, centered, etc. See the Graphics with Text section of the documentation for more information.
• Fixed race condition in repainting graphics that caused a failure to repaint the first time that a graphics window was maximized. Also simplified the painting chain so it's easier to predict and minimizes the need for speculative repaints.

2008-10-15

• Text can now be drawn into Frink's graphics! Text is high-quality, with transparent aliased edges, and can either automatically scale with the drawing or be rendered at a fixed size as the drawing is scaled. More details and sample programs are available in the Graphics with Text section of the documentation.
• Revised and improved internal bounding box calculations for text.

2008-10-09

• Major New Functionality: Frink now has powerful but easy-to-use graphics! This is a very important and large upgrade to Frink's capabilities. It is now very easy to draw high-quality, scalable graphics, and display them, print them, or write them to a variety of image formats. Here are some of the features:
  • Flexible coordinate system: You can draw your graphics to any coordinates you wish, and Frink will, by default, automatically scale and center them in your display device, eliminating the tedium and error of manual coordinate conversions, adjustment for different window or printer sizes, etc.
  • Dimensioned drawings: Graphics can be specified with explicit lengths (such as "3 cm",) so exactly-sized drawings can be printed. (Well, as accurately as your printer's driver allows them to be!)
  • Infinitely scalable: Frink's graphics are primarily designed to work with shapes, not individual pixels, so they can be re-scaled perfectly to display with full resolution on printers, in resizable graphics windows, in image files, or in rescalable vector formats.
  • High-quality shapes: Polygons and polylines are drawn with properly-joined, angled corners.
  • Anti-Aliasing: Lines and shapes are anti-aliased, eliminating jagged edges. (When running under Java 1.2 or later. Frink's graphics will also run on Java 1.1, but without antialiased edges.)
  • Transparency (alpha channel): Allows transparent shapes and lines, and see-through shapes to be drawn on top of other shapes. Anti-aliased edges are drawn with proper transparency so they can be overlaid on any background color or image. (Requires Java 1.2 or later for transparency.)
  • Easy writing to files: Graphics can be easily written to various file formats, including JPEG, PNG, and Scalable Vector Graphics (SVG) formats. PNG supports transparency (alpha channel) and allows antialiased, semi-transparent lines and shapes to be overlaid over other backgrounds or layers. SVG format allows infinite rescaling and perfect rendering to high-resolution devices such as printers, and perfect import into other vector graphics programs.
  • Easy display on different devices: The same graphics object can be created and then displayed on screen, printed to a printer, or written to a file, using a single command.

  Please see the Graphics section of the documentation for detailed information on this major update, including sample programs. This update consists of over 7000 lines of new code, with a large number of new features and capabilities.

2008-09-17

• Fixed AWT and Swing input dialogs (those displayed by the input[] function) to return empty strings instead of null strings when the user cancels or closes the dialog. The null strings caused problems in many cases, such as simply checking to see if it's true or not.
• Fixed silly problems in frink.gui.FrinkStarter class that caused errors like "cannot load file --swing" when you were actually passing a flag.

2008-09-10

• Some minor usability improvements, specifically making the main window request focus into a useful field when a dialog is closed.

2008-09-07

• Added setRestrictiveSecurity(true) method to the frink.parser.Frink class to easily enable the most restrictive security. See the Embedding Frink section of the documentation for more information.

2008-09-02

• The jar file once again starts the AWT GUI when double-clicked, instead of the Swing GUI. In more technical terms, the AWT GUI (specifically, frink.gui.InteractivePanel) is now the "Main-Class" of the jar file.

  I pondered over this, and figured that if there were platforms (like handheld devices) where you don't have Java Web Start or you downloaded the .jar file and didn't have any way to specify how to start it, or you didn't know what you were doing, and just randomly started it by double-clicking or using the platform's "launch" command or something, it would use the least common denominator to start and display itself, which is AWT and not Swing. So, sorry, if you're just randomly clicking on the .jar file, it may not look as pretty as it (briefly) did, but it should work on more platforms. The differences are probably purely aesthetic.

2008-08-29

• Added nextPrime[n] function to return the next prime number greater than n. The value of n may be any real number. This uses a "wheel factoring" method to completely avoid checking composites with small factors.

2008-08-27

• Minor updates, such as not trying to append a file extension to files when saving from the GUI. Windoze caused problems with that because its file association mechanism will corrupt a filename like basetiming.frink to something awful and 1980's era DOS-like BASETI~4.FRI.

2008-08-26

• The jar file now starts the Swing GUI when double-clicked, instead of the AWT GUI. In more technical terms, the Swing GUI is now the "Main-Class" of the jar file.
• The Java Web Start file for the Swing GUI now requests making a file association for .frink files. This may give conflicts if you run both the AWT and Swing Java Web Start versions. The Swing GUI is now preferred, so you should probably use that one if possible.
• Fixed a few errors in starting up the Swing and AWT GUIs in programming mode.

2008-08-25

• Added a programming mode to the Swing GUI. This makes the capabilities of the AWT GUI and the Swing GUI about the same, and the Swing GUI is somewhat more attractive. It has gotten to the point that the Swing interface should be considered to be the preferred one.

2008-08-23

• Rewrote the Swing GUI to duplicate some of the features of the AWT GUI. It now includes a menu bar which allows selection of several input modes, loading/saving of history, and includes links to documentation. Programming mode is not yet implemented.

2008-08-22

• Completely refactored the interactive AWT GUI into a GUI and a controller class which will make it easier to make GUIs using other graphical toolkits, including Swing and GTK.
• The Programming Mode of the AWT GUI was modified to add the directory of a loaded/saved file to the include path, which makes "use" statements work properly when loading and running multi-file programs from disk.

2008-08-12

• Added "help" menu item to the AWT GUI. This contains menu items that will launch the Frink documentation in your web browser, and also displays version number information. Note that for the documentation links to appear, you need to have Java 1.6 or later (although Frink still runs on any Java Virtual Machine version 1.1 or later.)

2008-08-03

• Added date formats with AD/BC indicator to the date formats file:
  • # August 19, 1969 AD 04:54 PM #
  • # 18 February 3102 BC 06:00 Ujjain #

2008-08-02

• Fixed calculation of Julian Day values for BC dates. Previously, manipulation of BC dates, especially large ones, could have been in error.
• In addition, the behavior of dates before the Julian-Gregorian switch date (by default, October 4, 1582 (Julian) in most Java Virtual Machines) was made consistent. These algorithms use a Julian Calendar date before this date and a Gregorian Calendar date after this date. Frink also produces dates in the Julian calendar before this date. Thus, the time #1582-10-04 23:59:59 UTC# (Julian) is followed immediately by #1582-10-15 00:00:00 UTC# (Gregorian) Note that if a date is specified between these dates, behavior will be undefined.
• Added Notes on Dates section to the documentation to discuss the new behavior and boundary cases.
• Added Ujjain timezone for use in ancient Indian astronomy calculations. See IndianAstronomy.frink for more information.
• Added continuedFraction.frink program to calculate with continued fractions.

2008-07-31

• Added global setDimensionNameDelimiters[string,string] function which changes the text printed around the dimension name (default is parentheses). For example, when you enter "1 K", the result is displayed as 1 K (temperature). Setting setDimensionNameDelimiters["UN[", "]"] makes this output as 1 K UN[temperature].

2008-07-16

• Added global showDimensionName[bool] function which switches display of the names of dimensions on and off. For example, when you enter "1 K", the result is displayed as 1 K (temperature). Setting this flag to false suppresses the "(temperature)" display. For more information, see the Setting Number Formats section of the documentation.

2008-07-15

• Changed integration method
  frink.parser.Frink.getVariableAsDouble(String variable, String units)
  to allow the argument units to be either null or the empty string. This tries to return the value of the variable as a dimensionless number. And it must be a dimensionless number or an exception will be thrown. See the documentation on Frink's integration methods for more information. Thanks to Alberto Di Lullo for the suggestions.

2008-07-10

• Updated and improved the planets.frink library in several ways:
  • Added calculations of visual magnitude as seen from Earth, including effects of Saturn's rings.
  • Made conversion of planetary positions to the FK5 coordinate system optional and turned off conversion to FK5 by default. The coordinates are now referred to the epoch of the date. This may give slight differences to previously-calculated values.
  • Added calculations of the position of Saturn's rings (not yet complete.)
  • Added secantAzimuth function to calculate the time that a planet will pass through a given azimuth as seen from a location on earth.

2008-07-03

• Fixed a case where classes with no member variables were not constructed properly. Thanks to Rowan Worth for the bug report.
• Fixed errors which reported "could not set 'this' object" when constructing instances of certain classes.
• Fixed a case where Java introspection could go into an infinite loop when working around Java bugs 4071957 and 4071593, which seemed to occur with non-public inner classes. Frink now terminates with an error if the inner class cannot be invoked due to Sun's (broken) access checks in invoking inner methods. An example of the code that causes the problem:

  list = newJava["java.util.ArrayList", [] ]
ulist = callJava["java.util.Collections", "unmodifiableList", list]
ulist.size[]

  This problem occurs because ulist is an instance of the inner class java.util.Collections$UnmodifiableRandomAccessList in which, for some reason, the class has no access specifier and is thus "package private" which, due to the aforementioned bug in Java's handling of method invocation, is considered not accessible (even though the method is public) when using reflection, but would be perfectly fine to call from compiled code. Sigh. There may be a nasty workaround to try and call this method via an interface specification, but I'm not sure. For more information, see the discussion in the entry for 2007-06-28. I already implemented some nasty workarounds to try and fix part of these bugs.

  Thanks to Rowan Worth for the bug report.

2008-06-08

• Fixed incorrect term in navigation.frink. This was a small term in eq. 6 that wasn't squared. It caused very small errors in distance and bearing calculations (on the order of fractions of a meter in most cases.) Many thanks to Bryan Vare for researching and detecting this problem and finding the exact bug!
• Improved Sanskrit Number converter and IndianAstronomy.frink to support conversion of decimal numbers to mixed decimal/sexagesimal fractions as used in ancient Indian mathematical texts. Thanks to Dr. Toke Lindegaard Knudsen for the assistance.
• Fixed an over-eager security check in the web interface to Frink, which would refuse to perform conversion operations with quoted expressions on the right-hand-side like:

  100 m -> "ft"

  and returned undef in these situations. The excessive security check has been modified. Thanks to André Sihera for the report.

• Made various changes to the documentation to clarify instructions about how to download Frink. Thanks to Gerald Norby for the suggestions.

2008-05-22

• Added Sanskrit Number converter sample program, and updated IndianAstronomy.frink to support these conversions.

2008-05-21

• Added deepCopy[x] function to perform a recursive deep copy of all the parts of a container class. The function can be called with any expression type. The function currently deep copies everything contained in arrays, dictionaries, and sets, and all of the sets contained within them. It is thus useful for copying nested data structures, multi-dimensional arrays (which are arrays of arrays, etc.) and prevents modification of the original or the copy from changing the other. It does not currently deep copy Java objects, Java arrays, nor objects created from a class specification, although it may do some of these in the future.

2008-05-20

• Improved symbolic transformations of function calls with undefined parameters. The arguments are now evaluated when possible, and the return value is a new function call with the replaced values. Note that this behavior only occurs when in "symbolic mode," otherwise the behavior is still to fail fast. For example:

  symbolicMode[true]
f[x] := sin[x] + 4
f[y^2]
4 + sin[y^2]
  

2008-05-17

• Frink can now directly parse integers written in the Devanagari script. These are represented using the Unicode characters \u0966-\u096f.

  ९८७६५४३२१०
9876543210
  

2008-05-15

• Fixed help operator to suppress "undefined symbol" warnings on default arguments of functions.

2008-04-17

• Fixed structure and revised process for building frink.war file which contains all classes necessary for users to install Frink Server Pages on their own server. A critical file was missing, and the structure was not optimal. Thanks to Knut for the notes.

2008-04-10

• Fixed broken "this" keyword in some object-oriented code. The "this" keyword was incorrectly marked as being constant, which caused premature optimization of expressions and caused some object-oriented code that explicitly used the "this" keyword to fail. The "this" pointer was not publically documented yet, so hopefully no code used it.
• Added working calculation of refracted planet positions in the planets.frink library.
• Added a simple demonstration program planetLocations.frink to print the current positions of the planets from anywhere on earth to high accuracy.

2008-04-09

• Fixed error when calling approxLog2[0].
• Made exponentiation for numbers with large non-integer exponents work, for example, 10.0^32000.5
• Improved arbitrary-precision square root routine sqrt[n,digits] in root.frink. This now uses adaptive working precision and smart initial guesses to produce results more rapidly.
• Added fast program for calculating many digits of e using a binary splitting algorithm in eBinarySplitting.frink

2008-04-07

• Fixed a bug in parsing integers which end with an underscore and then one digit, (e.g. 6_0). Thanks to Neal Crook for the bug report.
• Allowed underscores in integers in various bases. The following formats are now allowed:
  • feed_face\\16
  • 0xfeed_face
  • 0b0001_0101_0000

  Thanks to Neal Crook for the suggestion.

• Added the FrinkVersion[] function to return the current version of Frink from within a program. (You can also find out the current version from the command-line by running:

  frink -v
  or
  frink --version
  

• Increased size of cache for factorials from 1000 to 10000.

2008-03-29

• Fixed Historical British Price Data conversions to work again.

2008-03-20

• Added a lengthy section on the 'dependence problem' and the 'overestimation problem' common to all Interval Arithmetic to the Interval Arithmetic section of the Frink FAQ.

2008-03-08

• Added the function binomial[m,n] to calculate binomial coefficients. This is of the number of ways m things can be chosen n at a time, with order being unimportant. This is sometimes called "m choose n" or "m C n". This is equivalent to m!/(n! (m-n)!) although calculating that way often leads to way-too-big numbers. For example, binomial[10000, 9998] is equal to 49995000, but if you calculated it naively, you'd have to calculate 10000! which is a 35660-digit number, and divide it by another huge number, which could be inefficient and slow.

2008-03-05

• If a conformance error occurs when using the -> operator, Frink will now make more suggestions for factors to multiply or divide by. Notably, it will look for squares and square roots of existing units and suggest those as well. For example:

  (8 pi 1 erg/cm^3)^(1/2) -> gauss
Conformance error
   Left side is: 1.5853309190424043 m^(-1/2) s^-1 kg^(1/2) (unknown unit type)
  Right side is: 1/10000 (exactly 1.0e-4) s^-2 kg A^-1 (magnetic_flux_density)
     Suggestion: multiply left side by permeability^(1/2)

 For help, type: units[permeability]
      to list known units with these dimensions.

  Thanks to Anne Archibald for the suggestion.

2008-03-01

• Made changes to allow fractional exponents for base dimensions. That is, you can now do things like take the square root of meters, and Frink will represent it appropriately:

  watt
1 m^2 s^-3 kg (power)
  

  watt^(1/2)
1 m s^(-3/2) kg^(1/2) (unknown unit type)

  The exponents of base dimensions can now be either integers or rational numbers. (Previously, only integers were allowed.)

  This change was necessary to support some systems of units such as the Gaussian and Heaviside-Lorentz systems of units, which build on the "cgs" (centimeter-gram-second) system of units, but have very different definitions of electromagnetic quantities than the International System of Units (SI). For example, in the Gaussian system, electric current has dimensions of cm^(3/2) g^(1/2) s^-2, and working natively with this system requires fractional exponents.

  While it does not usually make sense to have fractional exponents in many systems of measurement nor in physical measurements, it is sometimes necessary in some fields, quantum physics being another example. I have also seen the use of fractional exponents in physical equations, such as the square root of volumetric flow ( m^(3/2) s^(-1/2) ).

  In the future, enabling fractional exponents may require a flag, but it may not. The reason for having a flag would be to detect certain types of errors as early as possible.

  Thanks to Anne Archibald for a very edifying discussion of the needs of handling Gaussian units properly.

2008-01-29

• Internal cleanup of a few minor questionable code constructs identified by FindBugs.