Пример #1
0
        public static uint _mfvc_impl(CpuThreadState cpuThreadState, VfpuControlRegistersEnum vfpuControlRegister)
        {
            Console.Error.WriteLine("Warning: _mfvc_impl");
            switch (vfpuControlRegister)
            {
            case VfpuControlRegistersEnum.VfpuPfxs: return(cpuThreadState.PrefixSource.Value);

            case VfpuControlRegistersEnum.VfpuPfxt: return(cpuThreadState.PrefixTarget.Value);

            case VfpuControlRegistersEnum.VfpuPfxd: return(cpuThreadState.PrefixDestination.Value);

            case VfpuControlRegistersEnum.VfpuCc: return(cpuThreadState.VfrCcValue);

            case VfpuControlRegistersEnum.VfpuRcx0:
                return((uint)MathFloat.ReinterpretFloatAsInt((float)new Random().NextDouble()));

            case VfpuControlRegistersEnum.VfpuRcx1:
            case VfpuControlRegistersEnum.VfpuRcx2:
            case VfpuControlRegistersEnum.VfpuRcx3:
            case VfpuControlRegistersEnum.VfpuRcx4:
            case VfpuControlRegistersEnum.VfpuRcx5:
            case VfpuControlRegistersEnum.VfpuRcx6:
            case VfpuControlRegistersEnum.VfpuRcx7:
                return((uint)MathFloat.ReinterpretFloatAsInt(1.0f));

            default:
                throw new NotImplementedException("_mfvc_impl: " + vfpuControlRegister);
            }
        }
Пример #2
0
        public static int _vf2iz(float value, int imm5)
        {
            var scalabValue = MathFloat.Scalb(value, imm5);
            var doubleValue = value >= 0 ? MathFloat.Floor(scalabValue) : MathFloat.Ceil(scalabValue);

            return(double.IsNaN(doubleValue) ? 0x7FFFFFFF : doubleValue);
        }
    public float getConcentration(float x, float z)                                 //"based" on the model from the article that Gustav sent us
    {
        float distPow2 = MathFloat.Pow(x - xCord, 2) + MathFloat.Pow(z - zCord, 2); //calculates the dist^2 just to make the next row more readable
        float c        = i_0 + max * MathFloat.Exp(-distPow2 / d);                  //calculatates c

        return(c);
    }
Пример #4
0
    void HandleWallCollision()
    {
        Vector2 direction = new Vector2(mDeltaVelocity.x > 0f ? 1f : -1f, 0f);

        RaycastHit2D[] collisionResults = new RaycastHit2D[5];
        int            collisionCount   = Physics2D.BoxCastNonAlloc(mPosition, mPlayerSize, 0f, direction, collisionResults, Mathf.Abs(mDeltaVelocity.x), CollisionLayer);

        bool collisionHappened = false;

        if (collisionCount > 0)
        {
            for (int index = 0; index < collisionCount; index++)
            {
                float yDistance = collisionResults[index].point.y - mPosition.y;
                float xSign     = collisionResults[index].point.x < mPosition.x ? -1f : 1f;
                if ((Mathf.Abs(yDistance) < (mHalfPlayerSize.y - 0.0001f)) && (xSign == direction.x))
                {
                    mWallDirection = (int)xSign;

                    collisionHappened = mWallCollision = true;
                    mDeltaVelocity.x  = mVelocity.x = 0f;
                    mPosition.x       = MathFloat.Round(collisionResults[index].point.x - (mHalfPlayerSize.x * direction.x), 2);
                    break;
                }
            }
        }

        if (!collisionHappened)
        {
            mWallCollision = false;
        }
    }
Пример #5
0
 public static void CheckVfpuRegister(string opcode, int regIndex, uint pc, float value)
 {
     //if (float.IsNaN(Value))
     {
         Console.WriteLine("VFPU_SET:{0:X4}:{1}:VR{2}:{3:X8}:{4},", pc, opcode, regIndex,
                           MathFloat.ReinterpretFloatAsUInt(value), value);
     }
 }
    protected void CalculateNextLocation(IPointAdapter location)
    {
        float dX = v * dT * MathFloat.Cos(angle), dZ = v * dT * MathFloat.Sin(angle);

        while (location.GetX() + dX > 14 || location.GetX() + dX < -14 || location.GetZ() + dZ > 14 || location.GetZ() + dZ < -14)
        {
            angle = CalculateTumbleAngle();
            dX    = v * dT * MathFloat.Cos(angle);
            dZ    = v * dT * MathFloat.Sin(angle);
        }
        location.Add(dX, dZ);
    }
Пример #7
0
        static public void _cvt_w_s_impl(CpuThreadState CpuThreadState, int FD, int FS)
        {
            //Console.WriteLine("_cvt_w_s_impl: {0}", CpuThreadState.FPR[FS]);
            switch (CpuThreadState.Fcr31.RM)
            {
            case CpuThreadState.FCR31.TypeEnum.Rint: CpuThreadState.FPR_I[FD] = (int)MathFloat.Rint(CpuThreadState.FPR[FS]); break;

            case CpuThreadState.FCR31.TypeEnum.Cast: CpuThreadState.FPR_I[FD] = (int)CpuThreadState.FPR[FS]; break;

            case CpuThreadState.FCR31.TypeEnum.Ceil: CpuThreadState.FPR_I[FD] = (int)MathFloat.Ceil(CpuThreadState.FPR[FS]); break;

            case CpuThreadState.FCR31.TypeEnum.Floor: CpuThreadState.FPR_I[FD] = (int)MathFloat.Floor(CpuThreadState.FPR[FS]); break;
            }
        }
Пример #8
0
 static Quaternion()
 {
     if (typeof(T) == typeof(float))
     {
         math = new MathFloat() as Math <T>;
     }
     else if (typeof(T) == typeof(double))
     {
         math = new MathDouble() as Math <T>;
     }
     if (math == null)
     {
         throw new InvalidOperationException("Type " + typeof(T) + " is not supported by Quaternion.");
     }
 }
Пример #9
0
 static Transform()
 {
     if (typeof(T) == typeof(float))
     {
         math = new MathFloat() as Math <T>;
     }
     if (typeof(T) == typeof(double))
     {
         math = new MathDouble() as Math <T>;
     }
     if (math == null)
     {
         throw new InvalidOperationException("Type " + typeof(T) + " is not supported by Transform.");
     }
 }
        public void SendControllerFrame()
        {
            SceCtrlData.X = 0;
            SceCtrlData.Y = 0;

            bool AnalogXUpdated = false;
            bool AnalogYUpdated = false;

            if (AnalogUp)
            {
                AnalogY       -= 0.4f;
                AnalogYUpdated = true;
            }
            if (AnalogDown)
            {
                AnalogY       += 0.4f;
                AnalogYUpdated = true;
            }
            if (AnalogLeft)
            {
                AnalogX       -= 0.4f;
                AnalogXUpdated = true;
            }
            if (AnalogRight)
            {
                AnalogX       += 0.4f;
                AnalogXUpdated = true;
            }
            if (!AnalogXUpdated)
            {
                AnalogX /= 2.0f;
            }
            if (!AnalogYUpdated)
            {
                AnalogY /= 2.0f;
            }

            AnalogX = MathFloat.Clamp(AnalogX, -1.0f, 1.0f);
            AnalogY = MathFloat.Clamp(AnalogY, -1.0f, 1.0f);

            //Console.WriteLine("{0}, {1}", AnalogX, AnalogY);

            SceCtrlData.X = AnalogX;
            SceCtrlData.Y = AnalogY;

            PspController.InsertSceCtrlData(SceCtrlData);
            //Console.WriteLine("CommonGuiInput.SendControllerFrame()");
        }
Пример #11
0
    private Vector3Adapter CalculateNextPoint(float x, float z, AbstractEnvironment environment)
    {
        //calculates the angle that the cell should move towards based on the ligand gradient
        float alfa   = MathFloat.Atan2(environment.GradZ(x, z), environment.GradX(x, z));
        float factor = 1 - smartnessFactor;

        //calculates the x and z delta based on the angle and the sampled value
        float dx = MathFloat.Cos(alfa) * dT * v + (float)Normal.Sample(0.0, v * dT * factor);
        float dz = MathFloat.Sin(alfa) * dT * v + (float)Normal.Sample(0.0, v * dT * factor);

        //adds the delta to the x and z cords while making sure that it does not move outside the dish
        x = MathFloat.Clamp(x + dx, -14, 14);
        z = MathFloat.Clamp(z + dz, -14, 14);

        //create the new point
        return(new Vector3Adapter(x, z));
    }
Пример #12
0
        public static int _cvt_w_s_impl(CpuThreadState cpuThreadState, float fs)
        {
            //Console.WriteLine("_cvt_w_s_impl: {0}", CpuThreadState.FPR[FS]);
            switch (cpuThreadState.Fcr31.Rm)
            {
            case CpuThreadState.Fcr31Struct.TypeEnum.Rint: return((int)MathFloat.Rint(fs));

            case CpuThreadState.Fcr31Struct.TypeEnum.Cast: return((int)MathFloat.Cast(fs));

            case CpuThreadState.Fcr31Struct.TypeEnum.Ceil: return((int)MathFloat.Ceil(fs));

            case CpuThreadState.Fcr31Struct.TypeEnum.Floor: return((int)MathFloat.Floor(fs));
            }

            throw new InvalidCastException("RM has an invalid value!!");
            //case CpuThreadState.FCR31.TypeEnum.Floor: CpuThreadState.FPR_I[FD] = (int)MathFloat.Floor(CpuThreadState.FPR[FS]); break;
        }
Пример #13
0
        public void SendControllerFrame()
        {
            if (IGuiExternalInterface.IsInitialized())
            {
                SceCtrlData.X = 0;
                SceCtrlData.Y = 0;

                bool AnalogXUpdated = false;
                bool AnalogYUpdated = false;
                if (AnalogUp)
                {
                    AnalogY -= 0.1f; AnalogYUpdated = true;
                }
                if (AnalogDown)
                {
                    AnalogY += 0.1f; AnalogYUpdated = true;
                }
                if (AnalogLeft)
                {
                    AnalogX -= 0.1f; AnalogXUpdated = true;
                }
                if (AnalogRight)
                {
                    AnalogX += 0.1f; AnalogXUpdated = true;
                }
                if (!AnalogXUpdated)
                {
                    AnalogX /= 2.0f;
                }
                if (!AnalogYUpdated)
                {
                    AnalogY /= 2.0f;
                }

                AnalogX = MathFloat.Clamp(AnalogX, -1.0f, 1.0f);
                AnalogY = MathFloat.Clamp(AnalogY, -1.0f, 1.0f);

                //Console.WriteLine("{0}, {1}", AnalogX, AnalogY);

                SceCtrlData.X = AnalogX;
                SceCtrlData.Y = AnalogY;

                this.PspController.InsertSceCtrlData(SceCtrlData);
            }
        }
Пример #14
0
        static void DelegatesMath()
        {
            OverMath math    = new OverMath();
            MathInt  mathInt = math.Plus;

            Console.WriteLine(n1 + " + " + n2 + " = " + mathInt(n1, n2));
            mathInt = math.Minus;
            Console.WriteLine(n1 + " - " + n2 + " = " + mathInt(n1, n2));
            mathInt = math.Gange;
            Console.WriteLine(n1 + " * " + n2 + " = " + mathInt(n1, n2));
            mathInt = math.Dividere;
            Console.WriteLine(n1 + " / " + n2 + " = " + mathInt(n1, n2));
            mathInt = math.Potens;
            Console.WriteLine(n1 + "^" + n2 + " = " + mathInt(n1, n2));
            MathFloat mathFloat = math.Plus;

            Console.WriteLine(n3 + " + " + n4 + " = " + mathFloat(n3, n4));
            mathFloat = math.Minus;
            Console.WriteLine(n3 + " - " + n4 + " = " + mathFloat(n3, n4));
            mathFloat = math.Gange;
            Console.WriteLine(n3 + " * " + n4 + " = " + mathFloat(n3, n4));
            mathFloat = math.Dividere;
            Console.WriteLine(n3 + " / " + n4 + " = " + mathFloat(n3, n4));
            mathFloat = math.Potens;
            Console.WriteLine(n3 + "^" + n4 + " = " + mathFloat(n3, n4));
            MathString mathString = math.Plus;

            Console.WriteLine(n5 + " + " + n6 + " = " + mathString(n5, n6));
            mathString = math.Minus;
            Console.WriteLine(n5 + " - " + n6 + " = " + mathString(n5, n6));
            mathString = math.Gange;
            Console.WriteLine(n5 + " * " + n6 + " = " + mathString(n5, n6));
            mathString = math.Dividere;
            Console.WriteLine(n5 + " / " + n6 + " = " + mathString(n5, n6));
            mathString = math.Potens;
            Console.WriteLine(n5 + "^" + n6 + " = " + mathString(n5, n6));
            Math1Int    math1Int    = math.Kvadratrod;
            Math1Float  math1Float  = math.Kvadratrod;
            Math1String math1String = math.Kvadratrod;

            Console.WriteLine("Kvadratroden af 64 = " + math1Int((int)64));
            Console.WriteLine("Kvadratroden af 9 = " + math1Float((float)9));
            Console.WriteLine("Kvadratroden af 625 = " + math1String("625"));
        }
Пример #15
0
    //Method that returns the number of cells that are within a given distance of the given location
    //only to be used with cells that have a ForwardsInternals as their internals (since iteration does not make sense otherwise)
    public int GetNumOfCloseCells(int iteration, float distance, IPointAdapter location)
    {
        int num = 0;

        distance *= distance; //removes the need for sqrt operation

        foreach (Cell cell in cells[iteration])
        {
            if (!(cell.GetInternals() is ForwardInternals))
            {
                continue;
            }
            IPointAdapter cellLocation = ((ForwardInternals)cell.GetInternals()).GetPosition(iteration);
            if (MathFloat.Pow(cellLocation.GetX() - location.GetX(), 2) + MathFloat.Pow(cellLocation.GetZ() - location.GetZ(), 2) <= distance)
            {
                num++;
            }
        }

        return(num);
    }
Пример #16
0
        public static float ToFloat(int imm16)
        {
            var s = (imm16 >> 15) & 0x00000001; // Sign
            var e = (imm16 >> 10) & 0x0000001f; // Exponent
            var f = (imm16 >> 0) & 0x000003ff;  // Fraction

            // Need to handle 0x7C00 INF and 0xFC00 -INF?
            if (e == 0)
            {
                // Need to handle +-0 case f==0 or f=0x8000?
                if (f == 0)
                {
                    // Plus or minus zero
                    return(MathFloat.ReinterpretIntAsFloat(s << 31));
                }
                // Denormalized number -- renormalize it
                while ((f & 0x00000400) == 0)
                {
                    f <<= 1;
                    e  -= 1;
                }
                e += 1;
                f &= ~0x00000400;
            }
            else if (e == 31)
            {
                if (f == 0)
                {
                    // Inf
                    return(MathFloat.ReinterpretIntAsFloat((s << 31) | 0x7f800000));
                }
                // NaN
                return(MathFloat.ReinterpretIntAsFloat((s << 31) | 0x7f800000 | (f << 13)));
            }

            e = e + (127 - 15);
            f = f << 13;

            return(MathFloat.ReinterpretIntAsFloat((s << 31) | (e << 23) | f));
        }
Пример #17
0
        //public ushort Value;
        //
        //public bool Sign { get { return BitUtils.Extract(Value, 15, 1) != 0; } }
        //public uint Exponent { get { return BitUtils.Extract(Value, 10, 5); } }
        //public uint Fraction { get { return BitUtils.Extract(Value, 0, 10); } }

        //public static ushort FloatToHalfFloat(float f)
        //{
        //	return FloatToHalfFloat(MathFloat.ReinterpretFloatAsUInt(f));
        //}
        //
        //public static ushort FloatToHalfFloat(uint f)
        //{
        //	const uint f32infty = 255 << 23;
        //	const uint f16infty = 31 << 23;
        //	const uint magic = 15 << 23;
        //
        //	const uint round_mask = ~0xfffu;
        //	const uint sign_mask = 0x80000000u;
        //
        //	ushort o;
        //
        //	uint sign = f & sign_mask;
        //	f ^= sign;
        //
        //	// Inf or NaN (all exponent bits set)
        //	if (f >= f32infty)
        //	{
        //		o = (ushort)((f > f32infty) ? 0x7e00 : 0x7c00); // NaN->qNaN and Inf->Inf
        //	}
        //	// (De)normalized number or zero
        //	else
        //	{
        //		f &= round_mask;
        //		f = MathFloat.ReinterpretFloatAsUInt(MathFloat.ReinterpretUIntAsFloat(f) * MathFloat.ReinterpretUIntAsFloat(magic));
        //		f -= round_mask;
        //		if (f > f16infty) f = f16infty; // Clamp to signed infinity if overflowed
        //
        //		o = (ushort)(f >> 13); // Take the bits!
        //	}
        //
        //	o |= (ushort)(sign >> 16);
        //	return o;
        //}

        public static int FloatToHalfFloat(float Float)
        {
            var i = MathFloat.ReinterpretFloatAsInt(Float);
            var s = ((i >> 16) & 0x00008000);              // sign
            var e = ((i >> 23) & 0x000000ff) - (127 - 15); // exponent
            var f = ((i >> 0) & 0x007fffff);               // fraction

            // need to handle NaNs and Inf?
            if (e <= 0)
            {
                if (e < -10)
                {
                    if (s != 0)
                    {
                        // handle -0.0
                        return(0x8000);
                    }
                    return(0);
                }
                f = (f | 0x00800000) >> (1 - e);
                return(s | (f >> 13));
            }
            else if (e == 0xff - (127 - 15))
            {
                if (f == 0)
                {
                    // Inf
                    return(s | 0x7c00);
                }
                // NAN
                f >>= 13;
                return(s | 0x7c00 | f | ((f == 0) ? 1 : 0));
            }
            if (e > 30)
            {
                // Overflow
                return(s | 0x7c00);
            }
            return(s | (e << 10) | (f >> 13));
        }
Пример #18
0
    void HandleGroundCollisions()
    {
        float   ySpeed    = mVelocity.y < 0f ? mDeltaVelocity.y : -0.02f;
        Vector2 direction = new Vector2(0f, mDeltaVelocity.y > 0f ? 1f : -1f);

        RaycastHit2D[] collisionResults = new RaycastHit2D[5];
        int            collisionCount   = Physics2D.BoxCastNonAlloc(mPosition, mPlayerSize, 0f, direction, collisionResults, Mathf.Abs(ySpeed), CollisionLayer);

        bool collisionHappened = false;

        if (collisionCount > 0)
        {
            RaycastHit2D collision;
            mGrounded = true;
            for (int index = 0; index < collisionCount; index++)
            {
                collision = collisionResults[index];
                float xDistance = collision.point.x - mPosition.x;
                if (Mathf.Abs(xDistance) < (mHalfPlayerSize.x - 0.0001f))
                {
                    collisionHappened = mGrounded = true;
                    mDeltaVelocity.y  = mVelocity.y = 0f;
                    mPosition.y       = MathFloat.Round(collision.collider.bounds.max.y + mHalfPlayerSize.y, 2);
                    break;
                }
            }

            if ((false == collisionHappened) && (mVelocity.y < 0f))
            {
                mGrounded = false;
            }
        }
        else
        {
            mGrounded = false;
        }
    }
Пример #19
0
 public void floor_w_s() => AdvancePC().SetFD_I(MathFloat.Floor(FS));
Пример #20
0
 public void ceil_w_s() => AdvancePC().SetFD_I(MathFloat.Ceil(FS));
Пример #21
0
 public void round_w_s() => AdvancePC().SetFD_I(MathFloat.Round(FS));
Пример #22
0
 public void trunc_w_s() => AdvancePC().SetFD_I(MathFloat.Cast(FS));
Пример #23
0
 public void abs_s() => AdvancePC().SetFD(MathFloat.Abs(FS));
Пример #24
0
 public void sqrt_s() => AdvancePC().SetFD(MathFloat.Sqrt(FS));
 public void SetSmartnessFactor(float smartnessFactor)
 {
     this.smartnessFactor = MathFloat.Clamp(smartnessFactor, 0, 1);
 }
    public float GradZ(float x, float z)
    {
        float dist = -MathFloat.Pow(x - xCord, 2) - MathFloat.Pow(z - zCord, 2);

        return(-2 * MathFloat.Exp(dist / d) * (z - zCord) / d);
    }