"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 1993 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic' }"

"{ NameSpace: Smalltalk }"

UnboxedFloatArray variableFloatSubclass:#FloatArray

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'Collections-Arrayed'

!

!FloatArray class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1993 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    FloatArrays store floats (and nothing else).

    They have been added to support heavy duty number crunching and

    data exchange with openGL frameworks and other mass data libraries.

    See documentation in DoubleArray for more information.

    [memory requirements:]

        OBJ-HEADER + (size * float-size)

    [See also:]

        DoubleArray Array

    [author:]

        Claus Gittinger

"

! !

!FloatArray class methodsFor:'queries'!

elementByteSize

    "for bit-like containers, return the number of bytes stored per element.

     Here, 4 is returned"

    ^ 4

    "Created: / 15-09-2011 / 14:12:39 / cg"

! !

!FloatArray methodsFor:'copying'!

clone

    "return a copy of the receiver"

    |newArr|

    newArr := self class new:(self size).

%{

    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0)) {

        INT _sz = __floatArraySize(self);

        bcopy(__FloatArrayInstPtr(self)->f_element,

              __FloatArrayInstPtr(newArr)->f_element,

              sizeof(float) * _sz);

        RETURN (newArr);

    }

%}.

    newArr replaceFrom:1 to:self size with:self startingAt:1.

    ^ newArr

    "

     |f1 f2|

     f1 := FloatArray withAll:#(1 2 3 4 5).

     f1 clone

    "

!

copyFrom:start to:stop

    "return a partial copy of the receiver"

%{

    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0)) {

        if (__bothSmallInteger(start, stop)) {

            INT __start = __intVal(start) - 1;

            INT __stop = __intVal(stop) - 1 ;

            if (__stop >= __start) {

                INT __sz = __floatArraySize(self);

                // printf("o_size=%d floatArraySize=%d\n", __qSize(self), __sz);

                if (((unsigned INT)__start < __sz)

                 && ((unsigned INT)__stop < __sz)) {

                    INT __n = __stop - __start + 1;

                    OBJ __nObj;

                    int nBytes;

                    // here we need to differ 32bit and 64bit

                    // because on 32bit machines we need to take care about the alignment

                    // but sadly, the same code is wrong for 64bit machines

                    if (__POINTER_SIZE__ == 8) {

                        nBytes = OHDR_SIZE + (__n * sizeof(float));

                    } else {

                        nBytes = sizeof(struct __FloatArray) + (__n - 1) * sizeof(float);

                    }

                    // printf("__n=%d nBytes=%d\n", __n, nBytes);

                    __nObj = __STX___new(nBytes);

                    if (__nObj != nil) {

                        __objPtr(__nObj)->o_class = __qClass(self);

                        __STORE(__nObj, __qClass(self));

                        // bcopy is marked as deprecated

                        // bcopy(

                        //     __FloatArrayInstPtr(self)->f_element,   

                        //     __FloatArrayInstPtr(__nObj)->f_element + __start,  

                        //     __n * sizeof(float));

                        memcpy(

                            __FloatArrayInstPtr(__nObj)->f_element + __start,

                            __FloatArrayInstPtr(self)->f_element,

                            __n * sizeof(float));

                        RETURN(__nObj);

                    }

                }

            }

        }

    }

%}.

    ^ super copyFrom:start to:stop

    "

     |f1 f2|

     f1 := FloatArray withAll:#(1 2 3 4 5 6).

     f2 := f1 copyFrom:1 to:3.

     f2                      

    "

!

replaceFrom:start to:stop with:aCollection startingAt:replStart

%{

    if ((__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0))

         && __isFloats(aCollection)

         && (__ClassInstPtr(__qClass(aCollection))->c_ninstvars == __mkSmallInteger(0))

         && __bothSmallInteger(start, stop)

         && __isSmallInteger(replStart)

         && !__isImmutable(self)

    ) {

        INT __start = __intVal(start) - 1;

        INT __stop = __intVal(stop) - 1 ;

        INT __replStart = __intVal(replStart) - 1 ;

        if (__stop >= __start) {

            INT __sz = __floatArraySize(self);

            INT __otherSz = __floatArraySize(aCollection);

            INT __replStop = __replStart + (__stop-__start);

            if (((unsigned INT)__start < __sz)

             && ((unsigned INT)__stop < __sz)

             && ((unsigned INT)__replStart < __otherSz)

             && ((unsigned INT)__replStop < __otherSz)) {

                INT __n = __stop - __start + 1;

                if (aCollection == self) {

                    memmove(&(__FloatArrayInstPtr(self)->f_element[__start]),

                            &(__FloatArrayInstPtr(aCollection)->f_element[__replStart]),

                            sizeof(float) * __n);

                } else {

                    memcpy(&(__FloatArrayInstPtr(self)->f_element[__start]),

                           &(__FloatArrayInstPtr(aCollection)->f_element[__replStart]),

                           sizeof(float) * __n);

                }

                RETURN(self);

            }

        }

    }

%}.

    "/ arrive here only in case of an error

    self isImmutable ifTrue:[

        self noModificationError

    ].    

    ^ super replaceFrom:start to:stop with:aCollection startingAt:replStart

    "

     |f1 f2|

     f1 := (1 to:5) asFloatArray.

     f2 := #(10 9 8 7 6) asFloatArray.

     f1 replaceFrom:1 to:3 with:f2 startingAt:3

    "

    "Modified: / 09-06-2019 / 15:33:14 / Claus Gittinger"

! !

!FloatArray methodsFor:'destructive arithmetic support'!

primAbs

    "destructive absolute value of each element;

     does not check for immutability: only use internally after cloning"

%{

    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0)) {

        INT _sz = __floatArraySize(self);

        INT i;

        float *_p = __FloatArrayInstPtr(self)->f_element;

        float prev_p;

        if (_sz > 0) {

            /* how about inline-mmx-asm for this ... */

            prev_p = _p[0];

            for (i=1; i<_sz; i++) {

                float next_p = _p[i];

                if (prev_p < 0) {

                    _p[i-1] = -prev_p;

                }

                prev_p = next_p;

            }

            if (prev_p < 0) {

                _p[i-1] = -prev_p;

            }

        }

        RETURN (self);

    }

%}.

    super primAbs

    "

     |f|

     f := FloatArray withAll:#(-1 2 -3 4 -5).

     f abs.

     f

    "

    "Created: / 30-05-2007 / 17:50:17 / cg"

    "Modified (comment): / 09-06-2019 / 15:34:21 / Claus Gittinger"

!

primAddArray: floatArray

    "add the vector argument into the receiver (destructive).

     The argument must be another vector.

     does not check for immutability: only use internally after cloning"

%{

    if ((__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0))

     && __isFloats(floatArray)

     && (__ClassInstPtr(__qClass(floatArray))->c_ninstvars == __mkSmallInteger(0))) {

        INT _sz1 = __floatArraySize(self);

        INT _sz2 = __floatArraySize(floatArray);

        INT i;

        float *_p1 = __FloatArrayInstPtr(self)->f_element;

        float *_p2 = __FloatArrayInstPtr(floatArray)->f_element;

        if (_sz1 > 0) {

            if (_sz2 >= _sz1) {

                /* how about inline-mmx-asm for this ... */

                float prev_p1 = _p1[0];

                float prev_p2 = _p2[0];

                for (i=1; i<_sz1; i++) {

                    float next_p1 = _p1[i];

                    float next_p2 = _p2[i];

                    _p1[i-1] = prev_p1 + prev_p2;

                    prev_p1 = next_p1;

                    prev_p2 = next_p2;

                }

                _p1[i-1] = prev_p1 + prev_p2;

            }

        }

        RETURN (self);

    }

%}.

    super primAddArray:floatArray

    "

     |f1 f2|

     f1 := FloatArray withAll:#(1 2 3 4 5).

     f2 := FloatArray withAll:#(2 2 2 3 3).

     f1 += f2.

     f1

    "

    "Modified (comment): / 09-06-2019 / 15:34:31 / Claus Gittinger"

!

primAddScalar: aScalar

    "add the scalar argument into the receiver (destructive).

     does not check for immutability: only use internally after cloning"

%{

    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0)) {

        INT _sz1 = __floatArraySize(self);

        INT i;

        float *_p1 = __FloatArrayInstPtr(self)->f_element;

        float v;

        float prev_p1;

        if (_sz1 > 0) {

            if (__isFloat(aScalar)) {

                v = (float)(__floatVal(aScalar));

            } else  if (__isShortFloat(aScalar)) {

                v = __shortFloatVal(aScalar);

            } else if (__isSmallInteger(aScalar)) {

                v = (float)(__intVal(aScalar));

            } else

                goto badArg;

            /* how about inline-mmx-asm for this ... */

            prev_p1 = _p1[0];

            for (i=1; i<_sz1; i++) {

                float next_p1 = _p1[i];

                _p1[i-1] = prev_p1 + v;

                prev_p1 = next_p1;

            }

            _p1[i-1] = prev_p1 + v;

        }

        RETURN (self);

    }

    badArg: ;

%}.

    super primAddScalar:aScalar

    "

     |f1 f2|

     f1 := FloatArray withAll:#(1 2 3 4 5).

     f1 += 2.0.

     Transcript showCR:f1.

     f1 += 2.0 asShortFloat.

     Transcript showCR:f1.

     f1 += 2.

     Transcript showCR:f1.

    "

    "Modified (comment): / 09-06-2019 / 15:34:37 / Claus Gittinger"

!

primDivArray: floatArray

    "divide the vector argument into the receiver (destructive).

     The argument must be another vector.

     does not check for immutability: only use internally after cloning"

%{

    if ((__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0))

     && __isFloats(floatArray)

     && (__ClassInstPtr(__qClass(floatArray))->c_ninstvars == __mkSmallInteger(0))) {

        INT _sz1 = __floatArraySize(self);

        INT _sz2 = __floatArraySize(floatArray);

        INT i;

        float *_p1 = __FloatArrayInstPtr(self)->f_element;

        float *_p2 = __FloatArrayInstPtr(floatArray)->f_element;

        if (_sz1 > 0) {

            if (_sz2 >= _sz1) {

                /* how about inline-mmx-asm for this ... */

                float prev_p1 = _p1[0];

                float prev_p2 = _p2[0];

                for (i=1; i<_sz1; i++) {

                    float next_p1 = _p1[i];

                    float next_p2 = _p2[i];

                    _p1[i-1] = prev_p1 / prev_p2;

                    prev_p1 = next_p1;

                    prev_p2 = next_p2;

                }

                _p1[i-1] = prev_p1 / prev_p2;

            }

        }

        RETURN (self);

    }

%}.

    super primDivArray: floatArray

    "

     |f1 f2|

     f1 := FloatArray withAll:#(1 2 3 4 5).

     f2 := FloatArray withAll:#(2 2 2 3 3).

     f1 /= f2.

     f1

    "

    "Modified: / 29-05-2007 / 16:01:34 / cg"

    "Modified (comment): / 09-06-2019 / 15:34:43 / Claus Gittinger"

!

primDivScalar: aScalar

    "divide the scalar argument into the receiver (destructive).

     does not check for immutability: only use internally after cloning"

%{

    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0)) {

        INT _sz1 = __floatArraySize(self);

        INT i;

        float *_p1 = __FloatArrayInstPtr(self)->f_element;

        float v;

        float prev_p1;

        if (_sz1 > 0) {

            if (__isFloat(aScalar)) {

                v = (float)(__floatVal(aScalar));

            } else  if (__isShortFloat(aScalar)) {

                v = __shortFloatVal(aScalar);

            } else if (__isSmallInteger(aScalar)) {

                v = (float)(__intVal(aScalar));

            } else

                goto badArg;

            /* how about inline-mmx-asm for this ... */

            prev_p1 = _p1[0];

            for (i=1; i<_sz1; i++) {

                float next_p1 = _p1[i];

                _p1[i-1] = prev_p1 / v;

                prev_p1 = next_p1;

            }

            _p1[i-1] = prev_p1 / v;

        }

        RETURN (self);

    }

    badArg: ;

%}.

    super primDivScalar:aScalar

    "

     |f1 f2|

     f1 := FloatArray withAll:#(1 2 3 4 5).

     f1 /= 2.0.

     Transcript showCR:f1.

     f1 /= 2.0 asShortFloat.

     Transcript showCR:f1.

     f1 /= 2.

     Transcript showCR:f1.

    "

    "Modified: / 29-05-2007 / 16:01:39 / cg"

    "Modified (comment): / 09-06-2019 / 15:34:48 / Claus Gittinger"

!

primMulArray: floatArray

    "multiply the vector argument into the receiver (destructive).

     The argument must be another vector.

     does not check for immutability: only use internally after cloning"

%{

    if ((__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0))

     && __isFloats(floatArray)

     && (__ClassInstPtr(__qClass(floatArray))->c_ninstvars == __mkSmallInteger(0))) {

        INT _sz1 = __floatArraySize(self);

        INT _sz2 = __floatArraySize(floatArray);

        INT i;

        float *_p1 = __FloatArrayInstPtr(self)->f_element;

        float *_p2 = __FloatArrayInstPtr(floatArray)->f_element;

        if (_sz1 > 0) {

            if (_sz2 >= _sz1) {

                float prev_p1 = _p1[0];

                float prev_p2 = _p2[0];

                for (i=1; i<_sz1; i++) {

                    float next_p1 = _p1[i];

                    float next_p2 = _p2[i];

                    _p1[i-1] = prev_p1 * prev_p2;