public void RunStructFldScenario(VectorTernaryOpTest__ConditionalSelectUInt16 testClass)
            {
                var result = Vector256.ConditionalSelect(_fld1, _fld2, _fld3);

                Unsafe.Write(testClass._dataTable.outArrayPtr, result);
                testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
            }
        public void RunClassFldScenario()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));

            var result = Vector256.ConditionalSelect(_fld1, _fld2, _fld3);

            Unsafe.Write(_dataTable.outArrayPtr, result);
            ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
        }
        public void RunStructLclFldScenario()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));

            var test   = TestStruct.Create();
            var result = Vector256.ConditionalSelect(test._fld1, test._fld2, test._fld3);

            Unsafe.Write(_dataTable.outArrayPtr, result);
            ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
        }
        public void RunClassLclFldScenario()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));

            var test   = new VectorTernaryOpTest__ConditionalSelectUInt16();
            var result = Vector256.ConditionalSelect(test._fld1, test._fld2, test._fld3);

            Unsafe.Write(_dataTable.outArrayPtr, result);
            ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
        }
        public void RunLclVarScenario_UnsafeRead()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));

            var op1    = Unsafe.Read <Vector256 <UInt16> >(_dataTable.inArray1Ptr);
            var op2    = Unsafe.Read <Vector256 <UInt16> >(_dataTable.inArray2Ptr);
            var op3    = Unsafe.Read <Vector256 <UInt16> >(_dataTable.inArray3Ptr);
            var result = Vector256.ConditionalSelect(op1, op2, op3);

            Unsafe.Write(_dataTable.outArrayPtr, result);
            ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
        }
        private static unsafe void ReplacePlusWithSpaceCore(Span <char> buffer, IntPtr state)
        {
            fixed(char *ptr = &MemoryMarshal.GetReference(buffer))
            {
                var input  = (ushort *)state.ToPointer();
                var output = (ushort *)ptr;

                var i = (nint)0;
                var n = (nint)(uint)buffer.Length;

                if (Vector256.IsHardwareAccelerated && n >= Vector256 <ushort> .Count)
                {
                    var vecPlus  = Vector256.Create((ushort)'+');
                    var vecSpace = Vector256.Create((ushort)' ');

                    do
                    {
                        var vec  = Vector256.Load(input + i);
                        var mask = Vector256.Equals(vec, vecPlus);
                        var res  = Vector256.ConditionalSelect(mask, vecSpace, vec);
                        res.Store(output + i);
                        i += Vector256 <ushort> .Count;
                    } while (i <= n - Vector256 <ushort> .Count);
                }

                if (Vector128.IsHardwareAccelerated && n - i >= Vector128 <ushort> .Count)
                {
                    var vecPlus  = Vector128.Create((ushort)'+');
                    var vecSpace = Vector128.Create((ushort)' ');

                    do
                    {
                        var vec  = Vector128.Load(input + i);
                        var mask = Vector128.Equals(vec, vecPlus);
                        var res  = Vector128.ConditionalSelect(mask, vecSpace, vec);
                        res.Store(output + i);
                        i += Vector128 <ushort> .Count;
                    } while (i <= n - Vector128 <ushort> .Count);
                }

                for (; i < n; ++i)
                {
                    if (input[i] != '+')
                    {
                        output[i] = input[i];
                    }
                    else
                    {
                        output[i] = ' ';
                    }
                }
            }
        }
        public void RunBasicScenario_UnsafeRead()
        {
            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));

            var result = Vector256.ConditionalSelect(
                Unsafe.Read <Vector256 <UInt32> >(_dataTable.inArray1Ptr),
                Unsafe.Read <Vector256 <UInt32> >(_dataTable.inArray2Ptr),
                Unsafe.Read <Vector256 <UInt32> >(_dataTable.inArray3Ptr)
                );

            Unsafe.Write(_dataTable.outArrayPtr, result);
            ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
        }