Expecco API/en - Versionsgeschichte

Cg: /* Interval, GeometricSeries and NumberSet */

2026-03-11T15:32:08Z

Interval, GeometricSeries and NumberSet

← Nächstältere Version		Version vom 11. März 2026, 15:32 Uhr
Zeile 955:		Zeile 955:
	An interval represents a range of numbers as in "<CODE>(1 to:5)</CODE>" or "<CODE>(1 to:10 by:2)</CODE>" or "<CODE>(7 to:4 by:-1)</CODE>"; these represent collections of numbers [1,2,3,4,5], [1,3,5,7,9] and [7,6,5,4] respectively.		An interval represents a range of numbers as in "<CODE>(1 to:5)</CODE>" or "<CODE>(1 to:10 by:2)</CODE>" or "<CODE>(7 to:4 by:-1)</CODE>"; these represent collections of numbers [1,2,3,4,5], [1,3,5,7,9] and [7,6,5,4] respectively.

	GeometricSeries are similar, but have a constant factor between elements, instead of a constant difference. For example, the "<CODE>(GeometricSeries from:1 to:64 byFactor:2)</CODE>" represents the collection of [1,2,4,8,16,32,64]".		GeometricSeries are similar, but have a constant factor between elements, instead of a constant difference. For example, the "<CODE>(GeometricSeries from:1 to:64 byFactor:2)</CODE>" represents the collection [1,2,4,8,16,32,64].

	NumberSets are optimized for collections of integer number ranges.<br>For example "<CODE>(NumberSet new add:1; add:3; addAll:(10 to:13)</CODE>" represents the collection of [1,3,10,11,12,13]".		NumberSets are optimized for collections of integer number ranges.<br>For example "<CODE>(NumberSet new add:1; add:3; addAll:(10 to:13)</CODE>" represents the collection [1,3,10,11,12,13].

	Intervals, GeometricSeries and NumberSets can be used wherever a readonly collection can be used.		Intervals, GeometricSeries and NumberSets can be used wherever a readonly collection can be used.

Cg: /* Interval, GeometricSeries and NumberSet */

2026-03-11T15:31:21Z

Interval, GeometricSeries and NumberSet

← Nächstältere Version		Version vom 11. März 2026, 15:31 Uhr
Zeile 957:		Zeile 957:
	GeometricSeries are similar, but have a constant factor between elements, instead of a constant difference. For example, the "<CODE>(GeometricSeries from:1 to:64 byFactor:2)</CODE>" represents the collection of [1,2,4,8,16,32,64]".		GeometricSeries are similar, but have a constant factor between elements, instead of a constant difference. For example, the "<CODE>(GeometricSeries from:1 to:64 byFactor:2)</CODE>" represents the collection of [1,2,4,8,16,32,64]".

	NumberSets are optimized for collections of integer number ranges. For example "<CODE>(NumberSet new add:1; add:3; addAll:(10 to:13)</CODE>" represents the collection of [1,3,10,11,12,13]".		NumberSets are optimized for collections of integer number ranges.<br>For example "<CODE>(NumberSet new add:1; add:3; addAll:(10 to:13)</CODE>" represents the collection of [1,3,10,11,12,13]".

	Intervals, GeometricSeries and NumberSets can be used wherever a readonly collection can be used.		Intervals, GeometricSeries and NumberSets can be used wherever a readonly collection can be used.

Cg: /* Interval, GeometricSeries and NumberSet */

2026-03-11T15:28:57Z

Interval, GeometricSeries and NumberSet

← Nächstältere Version		Version vom 11. März 2026, 15:28 Uhr
Zeile 953:		Zeile 953:
	===== Interval, GeometricSeries and NumberSet =====		===== Interval, GeometricSeries and NumberSet =====

	~~This~~ ~~represent~~ ~~ranges~~ of numbers as in "<CODE>(1 to:5)</CODE>" or "<CODE>(1 to:10 by:2)</CODE>" or "<CODE>(7 to:4 by:-1)</CODE>", ~~which~~ represent collections of numbers [1,2,3,4,5], [1,3,5,7,9] and [7,6,5,4] respectively.		An interval represents a range of numbers as in "<CODE>(1 to:5)</CODE>" or "<CODE>(1 to:10 by:2)</CODE>" or "<CODE>(7 to:4 by:-1)</CODE>"; these represent collections of numbers [1,2,3,4,5], [1,3,5,7,9] and [7,6,5,4] respectively.

	GeometricSeries are similar, but have a constant factor between elements, instead of a constant difference. For example, the "<CODE>(GeometricSeries from:1 to:64 byFactor:2)</CODE>" represents the collection of [1,2,4,8,16,32,64]".		GeometricSeries are similar, but have a constant factor between elements, instead of a constant difference. For example, the "<CODE>(GeometricSeries from:1 to:64 byFactor:2)</CODE>" represents the collection of [1,2,4,8,16,32,64]".

Cg: /* Interval and GeometricSeries */

2026-03-11T15:27:44Z

Interval and GeometricSeries

← Nächstältere Version		Version vom 11. März 2026, 15:27 Uhr
Zeile 951:		Zeile 951:
	There is also a non-balancing BinaryTree, which is slightly faster (by not balancing), but its worst case access times may degenerate to O(N), if elements are added non-randomly. <br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,BinaryTree Class Documentation]		There is also a non-balancing BinaryTree, which is slightly faster (by not balancing), but its worst case access times may degenerate to O(N), if elements are added non-randomly. <br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,BinaryTree Class Documentation]

	===== Interval and ~~GeometricSeries~~ =====		===== Interval, GeometricSeries and NumberSet =====

	This represent ranges of numbers as in "<CODE>(1 to:5)</CODE>" or "<CODE>(1 to:10 by:2)</CODE>" or "<CODE>(7 to:4 by:-1)</CODE>", which represent collections of numbers [1,2,3,4,5], [1,3,5,7,9] and [7,6,5,4] respectively.		This represent ranges of numbers as in "<CODE>(1 to:5)</CODE>" or "<CODE>(1 to:10 by:2)</CODE>" or "<CODE>(7 to:4 by:-1)</CODE>", which represent collections of numbers [1,2,3,4,5], [1,3,5,7,9] and [7,6,5,4] respectively.
Zeile 957:		Zeile 957:
	GeometricSeries are similar, but have a constant factor between elements, instead of a constant difference. For example, the "<CODE>(GeometricSeries from:1 to:64 byFactor:2)</CODE>" represents the collection of [1,2,4,8,16,32,64]".		GeometricSeries are similar, but have a constant factor between elements, instead of a constant difference. For example, the "<CODE>(GeometricSeries from:1 to:64 byFactor:2)</CODE>" represents the collection of [1,2,4,8,16,32,64]".

			NumberSets are optimized for collections of integer number ranges. For example "<CODE>(NumberSet new add:1; add:3; addAll:(10 to:13)</CODE>" represents the collection of [1,3,10,11,12,13]".
⚫	Intervals ~~and~~ GeometricSeries can be used wherever a readonly collection can be used.

		⚫	Intervals, GeometricSeries and NumberSets can be used wherever a readonly collection can be used.
	<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,Interval Interval Class Documentation] and [http://live.exept.de/ClassDoc/classDocOf:,GeometricSeries GeometricSeries Class Documentation]		<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,Interval Interval Class Documentation] and [http://live.exept.de/ClassDoc/classDocOf:,GeometricSeries GeometricSeries Class Documentation]

Cg: /* SortedCollection */

2026-03-11T13:55:13Z

SortedCollection

← Nächstältere Version		Version vom 11. März 2026, 13:55 Uhr
Zeile 890:		Zeile 890:
	Access time complexity by numeric index is O(1).<br>When searching for an element in a SortedCollection (using <code>includes:</code>, <code>indexOf:</code> or similar methods); time complexity is O(log n), because a binary search can be done.<br>Insertion and remove is O(1) for the first and last element, O(log n + n) for inner elements, because the insert index is first searched, then elements are moved inside a linear container.		Access time complexity by numeric index is O(1).<br>When searching for an element in a SortedCollection (using <code>includes:</code>, <code>indexOf:</code> or similar methods); time complexity is O(log n), because a binary search can be done.<br>Insertion and remove is O(1) for the first and last element, O(log n + n) for inner elements, because the insert index is first searched, then elements are moved inside a linear container.

	When a big sorted collection is created, it is faster to first create it as a non-sorted collection (OrderedCollection) and then converting the whole collection via <code>asSortedCollection</code>, instead of adding individual elements one-by-one.		When a big sorted collection is created, it is faster to first create it as a non-sorted collection (OrderedCollection) and then converting the whole collection via <code>asSortedCollection</code>, instead of adding individual elements one-by-one. If elements are to be added individually, it is probably better to use a tree like collection.

	~~<br>~~Overview: [http://live.exept.de/doc/online/english/overview/basicClasses/collections.html#SORTCOLL More Info]		Overview: [http://live.exept.de/doc/online/english/overview/basicClasses/collections.html#SORTCOLL More Info]
	<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,SortedCollection Class Documentation]		<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,SortedCollection Class Documentation]

Cg: /* ComplexFloatArray / Complex32Array,ComplexDoubleArray / Complex64Array,ComplexHalfFloatArray / Complex16Array */

2026-03-11T13:50:09Z

ComplexFloatArray / Complex32Array,ComplexDoubleArray / Complex64Array,ComplexHalfFloatArray / Complex16Array

← Nächstältere Version		Version vom 11. März 2026, 13:50 Uhr
Zeile 860:		Zeile 860:
	<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,SignedLongIntegerArray Class Documentation]		<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,SignedLongIntegerArray Class Documentation]

	===== ComplexFloatArray / Complex32Array,<br>ComplexDoubleArray / Complex64Array,<br>ComplexHalfFloatArray / Complex16Array=====		===== ComplexFloatArray / Complex32Array, <br>ComplexDoubleArray / Complex64Array, <br>ComplexHalfFloatArray / Complex16Array=====
	Ordered, fixed size, indexed by an integral index starting with 1.		Ordered, fixed size, indexed by an integral index starting with 1.
	<br>These store complex numbers as pairs of IEEE floats (32bit), doubles (64bit) or half floats (16bit). They allocate 8/16/4 bytes per element (4+4 / 8+8 / 2+2).		<br>These store complex numbers as pairs of IEEE floats (32bit), doubles (64bit) or half floats (16bit). They allocate 8/16/4 bytes per element (4+4 / 8+8 / 2+2).

Cg: /* ComplexFloatArray / Complex32ArrayComplexDoubleArray / Complex64ArrayComplexHalfFloatArray / Complex16Array */

2026-03-11T13:49:32Z

ComplexFloatArray / Complex32ArrayComplexDoubleArray / Complex64ArrayComplexHalfFloatArray / Complex16Array

← Nächstältere Version		Version vom 11. März 2026, 13:49 Uhr
Zeile 860:		Zeile 860:
	<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,SignedLongIntegerArray Class Documentation]		<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,SignedLongIntegerArray Class Documentation]

	===== ComplexFloatArray / Complex32Array<br>ComplexDoubleArray / Complex64Array<br>ComplexHalfFloatArray / Complex16Array=====		===== ComplexFloatArray / Complex32Array,<br>ComplexDoubleArray / Complex64Array,<br>ComplexHalfFloatArray / Complex16Array=====
	Ordered, fixed size, indexed by an integral index starting with 1.		Ordered, fixed size, indexed by an integral index starting with 1.
	<br>These store complex numbers as pairs of IEEE floats (32bit), doubles (64bit) or half floats (16bit). They allocate 8/16/4 bytes per element (4+4 / 8+8 / 2+2).		<br>These store complex numbers as pairs of IEEE floats (32bit), doubles (64bit) or half floats (16bit). They allocate 8/16/4 bytes per element (4+4 / 8+8 / 2+2).

Cg: /* ComplexFloatArray and ComplexDoubleArray */

2026-03-11T13:48:39Z

ComplexFloatArray and ComplexDoubleArray

← Nächstältere Version		Version vom 11. März 2026, 13:48 Uhr
Zeile 860:		Zeile 860:
	<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,SignedLongIntegerArray Class Documentation]		<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,SignedLongIntegerArray Class Documentation]

	===== ComplexFloatArray ~~and~~ ComplexDoubleArray =====		===== ComplexFloatArray / Complex32Array<br>ComplexDoubleArray / Complex64Array<br>ComplexHalfFloatArray / Complex16Array=====
	Ordered, fixed size, indexed by an integral index starting with 1.		Ordered, fixed size, indexed by an integral index starting with 1.
	<br>These store complex numbers as pairs of IEEE floats (32bit) or doubles (64bit) ~~and~~ allocate 8/16 bytes per element.		<br>These store complex numbers as pairs of IEEE floats (32bit), doubles (64bit) or half floats (16bit). They allocate 8/16/4 bytes per element (4+4 / 8+8 / 2+2).
	These are used in similar situations as FloatArrays and DoubleArrays.		<br>These are used in similar situations as FloatArrays and DoubleArrays.
	<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,ComplexFloatArray] [http://live.exept.de/ClassDoc/classDocOf:,ComplexDoubleArray]		<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,ComplexFloatArray] [http://live.exept.de/ClassDoc/classDocOf:,ComplexDoubleArray]

Cg: /* SignedLongIntegerArray */

2026-03-11T13:45:03Z

SignedLongIntegerArray

← Nächstältere Version		Version vom 11. März 2026, 13:45 Uhr
Zeile 854:		Zeile 854:
	<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,LongIntegerArray Class Documentation]		<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,LongIntegerArray Class Documentation]

	===== SignedLongIntegerArray =====		===== SignedLongIntegerArray / Int64Array =====
	Ordered, fixed size, indexed by an integral index starting with 1.		Ordered, fixed size, indexed by an integral index starting with 1.
	<br>These store small 64bit signed integer values (-0x80000000000000000..0x7FFFFFFFFFFFFFFF), allocating 8 bytes per element.		<br>These store small 64bit signed integer values (-0x80000000000000000..0x7FFFFFFFFFFFFFFF), allocating 8 bytes per element.

Cg: /* LongIntegerArray */

2026-03-11T13:44:34Z

LongIntegerArray

← Nächstältere Version		Version vom 11. März 2026, 13:44 Uhr
Zeile 848:		Zeile 848:
	<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,SignedWordArray Class Documentation]		<br>Reference: [http://live.exept.de/ClassDoc/classDocOf:,SignedWordArray Class Documentation]

	===== LongIntegerArray =====		===== LongIntegerArray / UInt64Array =====
	Ordered, fixed size, indexed by an integral index starting with 1.		Ordered, fixed size, indexed by an integral index starting with 1.
	<br>They store small 64bit unsigned integer values (0..0xFFFFFFFFFFFFFF), allocating 8 bytes per element.		<br>They store small 64bit unsigned integer values (0..0xFFFFFFFFFFFFFF), allocating 8 bytes per element.