Ox 9.0: new features and fixes

New features and enhancements in version 9.0
Fixed problems in version 9.0x
Fixed problems in version 9.0

New features and enhancements in version 9.0

New packages
- oxurl - download resources from the internet through simple interface to libcurl, see packages/oxurl/oxdoc/index.html
- oxdoc - generate documentation from source code markup (written in Ox), see packages/oxdoc/oxdoc/index.html. Documentation for oxdoc is created by running it on itself.
- gwg2ox - generates Ox code for a gwg file (used when calling Save Ox code from the graph window contact menu).
- Python - call Python from Ox code.
- Rox - call R from Ox code.
Language
- Can set matrix dimensions in declaration, decl x[3][3] for 3 x 3 matrix of zeros and decl x[3][3] = 1.5 for matrix filled with 1.5.
- Added .last to index last element:
```
	x[.last][.last] = 1;
	x[.last - 1][.last - 2] = 2;
	x[.last + 1] //error: indexing beyond last element
```
  Also see the new headc and tailc functions.
- parallel if (test-expression) for, parallel if (test-expression) foreach allows the code to decide to run in parallel or not
- if (decl-statement; condition)
- foreach (decl d in m[j]) d and j are now always local to foreach
- Added reference counting for objects. Objects are deleted automatically. So explicit deletion is not necessary, unless objects contain a circular reference to each other.
- try-catch block and throw: runtime errors now unwind and can be caught.
- Multiplicative concatenation of arrays and strings
```
	// example 1:
	{"%6.0f"} ~ {"%#10.5g"} * 4  ~ {"%#15.10g"}
	// example 2:
	decl n = 10, as = {""} * n;	 //	array of n empty strings
	//postfix multiplication different from postfix:
	{"a","b"} * 3 	// {"a","b","a","b","a","b"}
	3 * {"a","b"} 	// {"a","a","a","b","b","b"}
	"a" * 3			// "aaa" postfix only
Summary:

	string * int	 	 string  		  repeats content 
	string * array[c]	 array[c]	  	  each string in the array has string prefixed
	array[c] * string	 array[c]	  	  each string in the array has string suffixed
	int * array		  	 array[i * c]	  repeats first element, then second element, etc.
	array * int		  	 array[c * i]     repeats array i times
	array[c] * array[d]	 array[c * d]	  each string concatenated in all possible ways
	array[c] .* array[c] array[c]	  	  each string concatenated
```
  The range function can create a sequence of numbers as an array of strings.
- Now allow initialization of non-static member variable in class declaration (previously could only do this for static members). All uninitialized variable members default to 0 (previously giving `variable has no value' error)
- Trying to prevent same include file from being included again (case insensitive!)
- Indexing array by string: searches for an odd index wich has that string value, then accesses the next element. This emulates dictionary style lookup. If an item is not present, .Null is returned (instead of a index out of range error).
```
			decl aa = {"one", 10, "two", 0, "four", <1>, "five", {1,2}};
			println("aa[\"one\"]=  ",  aa["one"]   ?: "false");
			println("aa[\"two\"]=  ",  aa["two"]   ?: "false");
			println("aa[\"three\"]=",  aa["three"] ?: "false");
			println("aa[\"four\"]= ",  aa["four"]  ?: "false");
			println("aa[\"five\"]= ",  aa["five"]  ?: "false");
```
  This example also uses: allow a ? a : c to be written as a ? : c. This makes for more readable code when a function has many options:
```
	 func(const options)
	 {
	 	otherfunc(options["print"] ?: 0,
			options["stop_on_errors"] ?: 0,
			options["labels"] ?: {"a","b","c"});
	 }
	 decl aa = {"one": 10, "two": 0, "four": <1>, "five": {1,2}};
		 // is equivalent to
	 decl aa = {"one", 10, "two", 0, "four", <1>, "five", {1,2}};
		 // but the former may better reflect the intention
```
  Note that the : can only be after odd elements, otherwise there is a compilation error
- improvements to equality operators:
  - for non-matching types: TRUE for != otherwise FALSE
  - if ("") is now FALSE, so if part not entered
  - Matrix equality: must have same dimensions.
  - Can compare arrays for equality, e.g. if ({"A"} == {})
  - Can check if class objects are the same reference
  - Better comparison with .Null: not_null == .Null is FALSE.
- Faster evaluation of array expression {exp,...}
- Faster array self-concatenation, e.g. a ~= b; Applies to local variables and class data members (not arguments or a[0] ~= b)
- Recursive call and out-of-context call of lambda functions are now runtime errors.
- subtle change to `cond .? a .: b' operator: if cond is a matrix, a (or b) a matrix, a (or b) must be larger then cond, or have a single column or row which is replicated (cf other dot operator). Previously the value zero was used beyond the dimension, which was very confusing if a (or b) is a 1x1 matrix.
- convert array to matrix: e.g. matrix({{1,2,3},{4,5,6}}) and matrix({1,2,3}) to create <1,2,3;4,5,6> and <1,2,3>. A two-dimensional array must be rectangular; all elements must be castable to a double (strings are scanned! a string that cannot be read returns .NaN). Opposite cast is array(...<1,2,3>).
- Raw string constant, enclosed between backticks: no escape characters, can extend over multiple lines, tabs substituted out, e.g.:
- ...m spreads columns of matrix m
- improved default Ox path.
  If {user}/OxMetrics9 exists:
  {user}/OxMetrics9/ox/include;{user}/OxMetrics9/apps;{user}/OxMetrics9/ox;{OxMetrics9}/ox/include;{OxMetrics9}/apps;{OxMetrics9}/ox;
  else
  {OxMetrics9}/ox/include;{OxMetrics9}/apps;{OxMetrics9}/ox;
  {user} is the current user home folder
  {OxMetrics9} is location of ox dll with /bin removed
- arguments to function call: disallowing asignment in expressions for safety
- Undefined function is now link warning, and then runtime error if trying to use it.
- OxMetrics applications are now in OxMetrics9/apps
- Windows: switched to LoadLibraryExA with LOAD_WITH_ALTERED_SEARCH_PATH to allow dlls to depend on other dlls in the same folder.
- Windows: switched to clang compiler. Now can use clang for all versions on all platforms.
- removed OxGauss
- no ox-init.ox in interactive mode
- #pragma array_base no longer supported
- removed pragma link: use import instead
- C linkage: removed OxSetMatPtr because unsafe (was causing random crashes)
- C linkage: OxSetMainArgs/OxGetMainArgs now do nothing
- Stack now grows automatically, even in parallel code
- Passing an external static variable to a function and also changing it directly in that function (bad programming practice, unlikely scenario): content is likely to be lost (may crash). Now protected from this.
Library
- FindZero finds the root of a scalar function
- MaxScalarBrent maximize a function of one argument (derivative free)
- MaxScalarPowell maximize a function of one argument (derivative free)
- headc returns leading rows of all columns
- tailc returns the trailing rows of all columns
- peakc returns the matrix such that within each column the values do not go down
- fcopy copies a file
- fexists tests if a file exists
- find can find a reference to an object in an array of references.
- range can create a sequence of numbers as an array of strings or an arrray of numbers.
- two-dimensional array printing options as for matrix: useful to print mixed table, e.g. latex table
```
	
	println("%cs", "&", "%rs", "\\\\\n", "%8.2f", {{"AAA",10.1,1/3},"\\hline",{"XAAA",12.1}});
```
- %rs,%cs now works with row labels.
- Improvements to working with folders:
  - fopen for writing will create a folder if specified, e.g.: fopen("test/test.txt", "w");
  - fremove can remove a file or folder, but a folder has to be empty
- oxfilename("filename") searches for oxfilename in the Ox tree (used in libcurl, because that needs a full pathname for the certificate file).
- Improved printing of double: does not print redundant digits. So now prints 3.16 instead of 3.1600000000000001 when using "%.17g" format. The new version is also much faster. When using "%f" to print: switches to "%e" if the printed number gets too large (e.g. 1e100).
- arma0,armaforc,armagen,armavar now work with p=q=0; armaforc,armagen may now have a column vector as first argument with matrix for me/ma.
- find and replace hcan use ^ to match at start and $ at end of string. The . can be used to search in each string of an array.
- replace can be used for string array join and string split:
```
	replace({"aa","bb","cc","","dd"}, "", "|", "join");  // "aa|bb|cc||dd"
	replace("aa|bb|cc|dd", "|", "", "split");  // {"aa","bb","cc","dd"}
```
- sscan(&ipos, string, ...) as more efficient way to consecutively read a long string using sscan(&string, ...)
- sscan "%T" can now handle 0x.hexadecimal_double
- isfeq, isdotfeq have optional third argument to specify fuzziness; fuzziness function now does nothing.
- vecindex(array, item) and vecindex(string, character)
- further improvements to range function for floating point arguments
Data files
- More efficient csv file handling.
- Can now use Database::Load loadmat and loadsheet on file.csv.zip or file.zip (loads file.csv from the zip file; note: names in zip file are case sensitive).
- Dropped support for obsolete .wks files.
- Dropped support for saving as .xls files, warning for reading.
- Dropped support for .fmt and .dht files from documentation.
- Created new file format .oxdata (.in7 and .bn7 zipped together).
- csv: now writing missing values as empty cell for better compatibility with other programs.
- savemat csv/xlsx: if names specified, and first name starts with "dat" (not case sensitive) and column values look like dates: printing this column as a date.
- Abolished Database::Load... and Save..., just use Database::Load and Database::Save
- In some settings, a date axis would show no labels at all.
- Potential issue in fopen: if the file name is too long Ox crashes.
Other

Fixed problems in version 9.0x:

(9.06) Error in writing choice set to .oxdata/.in7 data files would lead to crash.
(9.04) return statement in lambda function in parallel loop was preventing parallelization.

Fixed problems in version 9.0:

fread with 'f' format always returned empty matrix
m[0][2] = 1; in 2x2 matrix would give wrong error message
decsvd: with .NaNs as result: returns -2.
quantilec/quantiler: if all missing, quantile is missing
Type error in internal function: did not print function name (e.g. log({1})).

This file last changed .