Beispiel #1
0
        public Direction(Fuzzy dx, Fuzzy dy)
        {
            // normalize the vector along the smallest axis

            if (Fuzzy.Abs(dx) > Fuzzy.Abs(dy))
            {
                this.dx = dy != 0 ? dx / Fuzzy.Abs(dy) : Fuzzy.Sign(dx);
                this.dy = Fuzzy.Sign(dy);
            }
            else
            {
                this.dx = Fuzzy.Sign(dx);
                this.dy = dx != 0 ? dy / Fuzzy.Abs(dx) : Fuzzy.Sign(dy);
            }
        }
 public void CreateTest()
 {
     Assert.Equal(0.5, Fuzzy.Create(0.5).Value, MathConstants.Precision);
     Assert.Equal(0.0, Fuzzy.Create(-1.0).Value, MathConstants.Precision);
     Assert.Equal(1.0, Fuzzy.Create(2.0).Value, MathConstants.Precision);
 }
 public void CreateMaxTest()
 {
     Assert.Equal(0.1, Fuzzy.Create(10, 100).Value, MathConstants.Precision);
     Assert.Equal(0.0, Fuzzy.Create(-1.0, 100).Value, MathConstants.Precision);
     Assert.Equal(1.0, Fuzzy.Create(200.0, 100).Value, MathConstants.Precision);
 }
 public static Fuzzy ToFuzzy(this double value) => Fuzzy.Create(value);
Beispiel #5
0
    Fuzzy fuzzy; //思考ルーチン

    // Use this for initialization
    void Start()
    {
        fuzzy       = GetComponent <Fuzzy>();
        personality = Random.Range(0, 2) == 0 ? Personality.NORMAL : Personality.HARD;
    }
Beispiel #6
0
 private bool IsMirrorAt(Fuzzy x, Fuzzy y)
 {
     return grid[Fuzzy.Floor(x), Fuzzy.Floor(y)] == '#';
 }
 public void TestTokenSetPartialRatio(string s1, string s2, int expected)
 {
     Assert.Equal(expected, Fuzzy.TokenSetPartialRatio(s1, s2));
 }
Beispiel #8
0
        private Fuzzy GetNextPositionOnGrid(Fuzzy position, Fuzzy direction, double step)
        {
            // positive directon
            if (direction > 0)
                return Fuzzy.Floor(position / step + 1) * step;

            // negative directon
            if (direction < 0)
                return Fuzzy.Ceiling(position / step - 1) * step;

            // null direction
            return position;
        }
 public void TestCaseSensitivePartialRatio(string s1, string s2, int expected)
 {
     Assert.Equal(expected, Fuzzy.PartialRatio(s1, s2, StringOptions.CaseSensitive, StringOptions.PreserveNonAlphaNumeric));
 }
 public void TestSpecialCharacterRatio()
 {
     Assert.Equal(96, Fuzzy.TokenSetRatio("Steve Ordonez", "Steve Ordoí±ez"));
 }
Beispiel #11
0
 public override void Execute()
 {
     Simulation.Reschedule(this, Fuzzy.Value(1));
 }
Beispiel #12
0
        private static int GetColumnIndex(IEnumerable <string> columnNames, string v)
        {
            string match = Fuzzy.GetBestMatch(columnNames, v);

            return(columnNames.ToList().IndexOf(match) + 1);
        }
Beispiel #13
0
 private void Start()
 {
     rigibody = GetComponent <Rigidbody> ();
     fuzzy    = GetComponentInChildren <Fuzzy> ();
     carView  = GetComponent <CarView> ();
 }
Beispiel #14
0
 public fuzstate(T stateName, Fuzzy brain, float minDuration) : base(stateName, brain, minDuration)
 {
     this.brain = brain;
 }
 public void TestWeightedRatio(string s1, string s2, int expected)
 {
     Assert.Equal(expected, Fuzzy.WeightedRatio(s1, s2));
 }
        public IEnumerator CompararDatos(HandRecord _leftHand, HandRecord _rightHand, float _tiempoEntreTirajes)
        {
            float tiempoTMp = _tiempoEntreTirajes / _leftHand.v_NumeroDeTirajes;

            bool[] isLeft  = new bool[_leftHand.v_NumeroDeTirajes];
            bool[] isRight = new bool[_rightHand.v_NumeroDeTirajes];
            for (int i = 0; i < _leftHand.v_NumeroDeTirajes; i++)
            {
                //Debug.Log("> Tiraje" + i);
                if (v_ManoIzquierdaActiva && _leftHand.v_ManoActiva)
                {
                    bool rot_Palma    = _leftHand.v_RotacionPalma[i] == v_PosicionManoIzquierda;
                    bool estadoThumb  = _leftHand.v_EstadoThumb[i] == v_EstadoThumbIzquierdo;
                    bool estadoIndex  = _leftHand.v_EstadoIndex[i] == v_EstadoIndexIzquierdo;
                    bool estadoMiddle = _leftHand.v_EstadoMiddle[i] == v_EstadoMiddleIzquierdo;
                    bool estadoRing   = _leftHand.v_EstadoRing[i] == v_EstadoRingIzquierdo;
                    bool estadoPinky  = _leftHand.v_EstadoPinky[i] == v_EstadoPinkyIzquierdo;

                    bool dedosExtendidos = _leftHand.v_DedosExtendidos[i] == v_NumeroDeDedosActivosHIzquierda;


                    //Posiciones

                    bool[] posBonesIndex = new bool[3];
                    posBonesIndex[0] = Fuzzy.CompareVector(_leftHand.v_PosBonesIndex0[i], IndexI[0].transform.position);
                    posBonesIndex[1] = Fuzzy.CompareVector(_leftHand.v_PosBonesIndex1[i], IndexI[1].transform.position);
                    posBonesIndex[2] = Fuzzy.CompareVector(_leftHand.v_PosBonesIndex2[i], IndexI[2].transform.position);

                    bool[] posBonesMiddle = new bool[3];
                    posBonesMiddle[0] = Fuzzy.CompareVector(_leftHand.v_PosBonesMiddle0[i], MiddleI[0].transform.position);
                    posBonesMiddle[1] = Fuzzy.CompareVector(_leftHand.v_PosBonesMiddle1[i], MiddleI[1].transform.position);
                    posBonesMiddle[2] = Fuzzy.CompareVector(_leftHand.v_PosBonesMiddle2[i], MiddleI[2].transform.position);

                    bool[] posBonesRing = new bool[3];
                    posBonesRing[0] = Fuzzy.CompareVector(_leftHand.v_PosBonesRing0[i], RingI[0].transform.position);
                    posBonesRing[1] = Fuzzy.CompareVector(_leftHand.v_PosBonesRing1[i], RingI[1].transform.position);
                    posBonesRing[2] = Fuzzy.CompareVector(_leftHand.v_PosBonesRing2[i], RingI[2].transform.position);

                    bool[] posBonesPinky = new bool[3];
                    posBonesPinky[0] = Fuzzy.CompareVector(_leftHand.v_PosBonesPinky0[i], PinkyI[0].transform.position);
                    posBonesPinky[1] = Fuzzy.CompareVector(_leftHand.v_PosBonesPinky1[i], PinkyI[1].transform.position);
                    posBonesPinky[2] = Fuzzy.CompareVector(_leftHand.v_PosBonesPinky2[i], PinkyI[2].transform.position);

                    bool[] posBonesThumb = new bool[3];
                    posBonesThumb[0] = Fuzzy.CompareVector(_leftHand.v_PosBonesThumb0[i], ThumbI[0].transform.position);
                    posBonesThumb[1] = Fuzzy.CompareVector(_leftHand.v_PosBonesThumb1[i], ThumbI[1].transform.position);
                    posBonesThumb[2] = Fuzzy.CompareVector(_leftHand.v_PosBonesThumb2[i], ThumbI[2].transform.position);

                    //Rotaciones

                    bool[] rotBonesIndex = new bool[3];
                    rotBonesIndex[0] = Fuzzy.CompareVector(_leftHand.v_RotBonesIndex0[i], IndexI[0].transform.rotation.eulerAngles);
                    rotBonesIndex[1] = Fuzzy.CompareVector(_leftHand.v_RotBonesIndex1[i], IndexI[1].transform.rotation.eulerAngles);
                    rotBonesIndex[2] = Fuzzy.CompareVector(_leftHand.v_RotBonesIndex2[i], IndexI[2].transform.rotation.eulerAngles);

                    bool[] rotBonesMiddle = new bool[3];
                    rotBonesMiddle[0] = Fuzzy.CompareVector(_leftHand.v_RotBonesMiddle0[i], MiddleI[0].transform.rotation.eulerAngles);
                    rotBonesMiddle[1] = Fuzzy.CompareVector(_leftHand.v_RotBonesMiddle1[i], MiddleI[1].transform.rotation.eulerAngles);
                    rotBonesMiddle[2] = Fuzzy.CompareVector(_leftHand.v_RotBonesMiddle2[i], MiddleI[2].transform.rotation.eulerAngles);

                    bool[] rotBonesRing = new bool[3];
                    rotBonesRing[0] = Fuzzy.CompareVector(_leftHand.v_RotBonesRing0[i], RingI[0].transform.rotation.eulerAngles);
                    rotBonesRing[1] = Fuzzy.CompareVector(_leftHand.v_RotBonesRing1[i], RingI[1].transform.rotation.eulerAngles);
                    rotBonesRing[2] = Fuzzy.CompareVector(_leftHand.v_RotBonesRing2[i], RingI[2].transform.rotation.eulerAngles);

                    bool[] rotBonesPinky = new bool[3];
                    rotBonesPinky[0] = Fuzzy.CompareVector(_leftHand.v_RotBonesPinky0[i], PinkyI[0].transform.rotation.eulerAngles);
                    rotBonesPinky[1] = Fuzzy.CompareVector(_leftHand.v_RotBonesPinky1[i], PinkyI[1].transform.rotation.eulerAngles);
                    rotBonesPinky[2] = Fuzzy.CompareVector(_leftHand.v_RotBonesPinky2[i], PinkyI[2].transform.rotation.eulerAngles);

                    bool[] rotBonesThumb = new bool[3];
                    rotBonesThumb[0] = Fuzzy.CompareVector(_leftHand.v_RotBonesThumb0[i], ThumbI[0].transform.rotation.eulerAngles);
                    rotBonesThumb[1] = Fuzzy.CompareVector(_leftHand.v_RotBonesThumb1[i], ThumbI[1].transform.rotation.eulerAngles);
                    rotBonesThumb[2] = Fuzzy.CompareVector(_leftHand.v_RotBonesThumb2[i], ThumbI[2].transform.rotation.eulerAngles);

                    bool posBrazo = Fuzzy.CompareVector(_leftHand.v_PosBrazo[i], ForI.transform.position);
                    bool rotBrazo = Fuzzy.CompareVector(_leftHand.v_RotBrazo[i], ForI.transform.rotation.eulerAngles);

                    bool posPalma = Fuzzy.CompareVector(_leftHand.v_PosPalma[i], PalmI.transform.position);
                    bool rotPalma = Fuzzy.CompareVector(_leftHand.v_RotPalma[i], PalmI.transform.rotation.eulerAngles);

                    if (rot_Palma && estadoThumb && estadoIndex && estadoMiddle && estadoRing && estadoPinky)
                    {
                        if (posBonesIndex[0] && posBonesIndex[1] && posBonesIndex[2] &&
                            posBonesMiddle[0] && posBonesMiddle[1] && posBonesMiddle[2] &&
                            posBonesRing[0] && posBonesRing[1] && posBonesRing[2] &&
                            posBonesPinky[0] && posBonesPinky[1] && posBonesPinky[2] &&
                            posBonesThumb[0] && posBonesThumb[1] && posBonesThumb[2] &&
                            rotBonesIndex[0] && rotBonesIndex[1] && rotBonesIndex[2] &&
                            rotBonesMiddle[0] && rotBonesMiddle[1] && rotBonesMiddle[2] &&
                            rotBonesRing[0] && rotBonesRing[1] && rotBonesRing[2] &&
                            rotBonesPinky[0] && rotBonesPinky[1] && rotBonesPinky[2] &&
                            rotBonesThumb[0] && rotBonesThumb[1] && rotBonesThumb[2])
                        {
                            if (posBrazo && rotBrazo && posPalma && rotPalma)
                            {
                                isLeft[i] = true;
                            }
                        }
                    }
                }

                if (v_ManoDerechaActiva && _rightHand.v_ManoActiva)
                {
                    bool rot_Palma    = _rightHand.v_RotacionPalma[i] == v_PosicionManoDerecha;
                    bool estadoThumb  = _rightHand.v_EstadoThumb[i] == v_EstadoThumbDerecho;
                    bool estadoIndex  = _rightHand.v_EstadoIndex[i] == v_EstadoIndexDerecho;
                    bool estadoMiddle = _rightHand.v_EstadoMiddle[i] == v_EstadoMiddleDerecho;
                    bool estadoRing   = _rightHand.v_EstadoRing[i] == v_EstadoRingDerecho;
                    bool estadoPinky  = _rightHand.v_EstadoPinky[i] == v_EstadoPinkyDerecho;

                    Debug.Log("Rot palma: " + _rightHand.v_RotacionPalma[i] + " - " + v_PosicionManoDerecha + "\n" +
                              "Estado Thumb: " + _rightHand.v_EstadoThumb[i] + " - " + v_EstadoThumbDerecho + "\n" +
                              "Estado Index: " + _rightHand.v_EstadoIndex[i] + " - " + v_EstadoIndexDerecho + "\n" +
                              "Estado Middle: " + _rightHand.v_EstadoMiddle[i] + " - " + v_EstadoMiddleDerecho + "\n" +
                              "Estado Ring: " + _rightHand.v_EstadoRing[i] + " - " + v_EstadoPinkyDerecho + "\n" +
                              "Estado Pinky: " + _rightHand.v_EstadoPinky[i] + " - " + v_EstadoPinkyDerecho + "\n");

                    bool dedosExtendidos = Fuzzy.CompareInt(_rightHand.v_DedosExtendidos[i], v_NumeroDeDedosActivosHDerecha);


                    //Posiciones
                    #region POSICIONES
                    bool[] posBonesIndex = new bool[3];
                    posBonesIndex[0] = Fuzzy.CompareVector(_rightHand.v_PosBonesIndex0[i], IndexD[0].transform.position);
                    posBonesIndex[1] = Fuzzy.CompareVector(_rightHand.v_PosBonesIndex1[i], IndexD[1].transform.position);
                    posBonesIndex[2] = Fuzzy.CompareVector(_rightHand.v_PosBonesIndex2[i], IndexD[2].transform.position);

                    bool[] posBonesMiddle = new bool[3];
                    posBonesMiddle[0] = Fuzzy.CompareVector(_rightHand.v_PosBonesMiddle0[i], MiddleD[0].transform.position);
                    posBonesMiddle[1] = Fuzzy.CompareVector(_rightHand.v_PosBonesMiddle1[i], MiddleD[1].transform.position);
                    posBonesMiddle[2] = Fuzzy.CompareVector(_rightHand.v_PosBonesMiddle2[i], MiddleD[2].transform.position);

                    bool[] posBonesRing = new bool[3];
                    posBonesRing[0] = Fuzzy.CompareVector(_rightHand.v_PosBonesRing0[i], RingD[0].transform.position);
                    posBonesRing[1] = Fuzzy.CompareVector(_rightHand.v_PosBonesRing1[i], RingD[1].transform.position);
                    posBonesRing[2] = Fuzzy.CompareVector(_rightHand.v_PosBonesRing2[i], RingD[2].transform.position);

                    bool[] posBonesPinky = new bool[3];
                    posBonesPinky[0] = Fuzzy.CompareVector(_rightHand.v_PosBonesPinky0[i], PinkyD[0].transform.position);
                    posBonesPinky[1] = Fuzzy.CompareVector(_rightHand.v_PosBonesPinky1[i], PinkyD[1].transform.position);
                    posBonesPinky[2] = Fuzzy.CompareVector(_rightHand.v_PosBonesPinky2[i], PinkyD[2].transform.position);

                    bool[] posBonesThumb = new bool[3];
                    posBonesThumb[0] = Fuzzy.CompareVector(_rightHand.v_PosBonesThumb0[i], ThumbD[0].transform.position);
                    posBonesThumb[1] = Fuzzy.CompareVector(_rightHand.v_PosBonesThumb1[i], ThumbD[1].transform.position);
                    posBonesThumb[2] = Fuzzy.CompareVector(_rightHand.v_PosBonesThumb2[i], ThumbD[2].transform.position);
                    #endregion

                    //Rotaciones
                    #region ROTACIONES
                    bool[] rotBonesIndex = new bool[3];
                    rotBonesIndex[0] = Fuzzy.CompareVector(_rightHand.v_RotBonesIndex0[i], IndexD[0].transform.rotation.eulerAngles);
                    rotBonesIndex[1] = Fuzzy.CompareVector(_rightHand.v_RotBonesIndex1[i], IndexD[1].transform.rotation.eulerAngles);
                    rotBonesIndex[2] = Fuzzy.CompareVector(_rightHand.v_RotBonesIndex2[i], IndexD[2].transform.rotation.eulerAngles);

                    bool[] rotBonesMiddle = new bool[3];
                    rotBonesMiddle[0] = Fuzzy.CompareVector(_rightHand.v_RotBonesMiddle0[i], MiddleD[0].transform.rotation.eulerAngles);
                    rotBonesMiddle[1] = Fuzzy.CompareVector(_rightHand.v_RotBonesMiddle1[i], MiddleD[1].transform.rotation.eulerAngles);
                    rotBonesMiddle[2] = Fuzzy.CompareVector(_rightHand.v_RotBonesMiddle2[i], MiddleD[2].transform.rotation.eulerAngles);

                    bool[] rotBonesRing = new bool[3];
                    rotBonesRing[0] = Fuzzy.CompareVector(_rightHand.v_RotBonesRing0[i], RingD[0].transform.rotation.eulerAngles);
                    rotBonesRing[1] = Fuzzy.CompareVector(_rightHand.v_RotBonesRing1[i], RingD[1].transform.rotation.eulerAngles);
                    rotBonesRing[2] = Fuzzy.CompareVector(_rightHand.v_RotBonesRing2[i], RingD[2].transform.rotation.eulerAngles);

                    bool[] rotBonesPinky = new bool[3];
                    rotBonesPinky[0] = Fuzzy.CompareVector(_rightHand.v_RotBonesPinky0[i], PinkyD[0].transform.rotation.eulerAngles);
                    rotBonesPinky[1] = Fuzzy.CompareVector(_rightHand.v_RotBonesPinky1[i], PinkyD[1].transform.rotation.eulerAngles);
                    rotBonesPinky[2] = Fuzzy.CompareVector(_rightHand.v_RotBonesPinky2[i], PinkyD[2].transform.rotation.eulerAngles);

                    bool[] rotBonesThumb = new bool[3];
                    rotBonesThumb[0] = Fuzzy.CompareVector(_rightHand.v_RotBonesThumb0[i], ThumbD[0].transform.rotation.eulerAngles);
                    rotBonesThumb[1] = Fuzzy.CompareVector(_rightHand.v_RotBonesThumb1[i], ThumbD[1].transform.rotation.eulerAngles);
                    rotBonesThumb[2] = Fuzzy.CompareVector(_rightHand.v_RotBonesThumb2[i], ThumbD[2].transform.rotation.eulerAngles);
                    #endregion

                    bool posBrazo = Fuzzy.CompareVector(_rightHand.v_PosBrazo[i], ForD.transform.position);
                    bool rotBrazo = Fuzzy.CompareVector(_rightHand.v_RotBrazo[i], ForD.transform.rotation.eulerAngles);

                    bool posPalma = Fuzzy.CompareVector(_rightHand.v_PosPalma[i], PalmD.transform.position);
                    bool rotPalma = Fuzzy.CompareVector(_rightHand.v_RotPalma[i], PalmD.transform.rotation.eulerAngles);

                    if (rot_Palma && estadoThumb && estadoIndex && estadoMiddle || estadoRing || estadoPinky)
                    {
                        if (
                            (
                                ((posBonesThumb[0] || posBonesThumb[1] || posBonesThumb[2]) &&
                                 (posBonesIndex[0] || posBonesIndex[1] || posBonesIndex[2])) &&
                                ((posBonesMiddle[0] || posBonesMiddle[1] || posBonesMiddle[2]) ||
                                 (posBonesRing[0] || posBonesRing[1] || posBonesRing[2]) ||
                                 (posBonesPinky[0] || posBonesPinky[1] || posBonesPinky[2]))
                            ) ||
                            (
                                ((rotBonesThumb[0] || rotBonesThumb[1] || rotBonesThumb[2]) &&
                                 (rotBonesIndex[0] || rotBonesIndex[1] || rotBonesIndex[2])) &&
                                ((rotBonesMiddle[0] || rotBonesMiddle[1] || rotBonesMiddle[2]) ||
                                 (rotBonesRing[0] || rotBonesRing[1] || rotBonesRing[2]) ||
                                 (rotBonesPinky[0] || rotBonesPinky[1] || rotBonesPinky[2]))
                            )
                            )
                        {
                            Debug.Log("I got all pos and rot right!");
                            //isRight[i] = true;
                            if ((posBrazo || rotBrazo) || (posPalma || rotPalma))
                            {
                                Debug.Log("This part is tricku");
                                isRight[i] = true;
                            }
                        }
                    }
                }

                yield return(new WaitForSeconds(tiempoTMp));
            }

            //Si si coinciden, entonces activar


            if ((_leftHand.v_ManoActiva && Comparar(isLeft)) || (_rightHand.v_ManoActiva && Comparar(isRight)))
            {
                StartCoroutine(WaitToTurnPanelOff(matchFound));
                FindObjectOfType <SCR_GameManager>().LoadNextGesture();
            }
        }
Beispiel #17
0
 public still(T stateName, Fuzzy controller, float minDuration) : base(stateName, controller, minDuration)
 {
 }
Beispiel #18
0
 public bool IsOnGrid(Fuzzy x)
 {
     return x - Fuzzy.Round(x) == 0;
 }
Beispiel #19
0
        public ActionResult StockPrediction(ViewModel obj)
        {
            var supplierName = User.Identity.Name;

            var context = new ATokoDb();

            if (!string.IsNullOrEmpty(obj.ProductCode))
            {
                //string productCode = "";

                ViewBag.productName = context.Products.Where(o => o.ProductCode == obj.ProductCode).FirstOrDefault().ProductName;

                string querySales = string.Format("EXEC [dbo].[sp_GetSalesByProductCodeAndSupplierName] @productCode = '{0}', @supplierName = '{1}'", obj.ProductCode, supplierName);
                string queryStock = string.Format("EXEC [dbo].[sp_GetStockByProductCodeAndSupplierName] @productCode = '{0}', @supplierName = '{1}'", obj.ProductCode, supplierName);
                string queryOrder = string.Format("EXEC [dbo].[sp_GetProductInByProductCodeAndSupplierName] @productCode = '{0}', @supplierName = '{1}'", obj.ProductCode, supplierName);

                IEnumerable <FuzzyViewModel> listSalesByMonth  = db.Database.SqlQuery <FuzzyViewModel>(querySales);
                IEnumerable <FuzzyViewModel> listStocksByMonth = db.Database.SqlQuery <FuzzyViewModel>(queryStock);
                IEnumerable <FuzzyViewModel> listOrderByMonth  = db.Database.SqlQuery <FuzzyViewModel>(queryOrder);


                if (listOrderByMonth.Count() > 0 && listSalesByMonth.Count() > 0 && listStocksByMonth.Count() > 0)
                {
                    if (listOrderByMonth.Count() != listSalesByMonth.Count())
                    {
                        int count = listStocksByMonth.Count();

                        List <FuzzyViewModel> newList = new List <FuzzyViewModel>();

                        bool isSales = false;

                        if (listOrderByMonth.Count() != count)
                        {
                            isSales = false;
                        }
                        else if (listSalesByMonth.Count() != count)
                        {
                            isSales = true;
                        }

                        if (isSales)
                        {
                            foreach (var item in listStocksByMonth)
                            {
                                if (listSalesByMonth.Where(o => o.Year == item.Year && o.Month == item.Month).Count() > 0)
                                {
                                    newList.Add(listSalesByMonth.Where(o => o.Year == item.Year && o.Month == item.Month).FirstOrDefault());
                                }
                                else
                                {
                                    newList.Add(new FuzzyViewModel {
                                        Month = item.Month, Year = item.Year, ProductCode = item.ProductCode, Qty = 0
                                    });
                                }
                            }

                            listSalesByMonth = newList;
                        }
                        else
                        {
                            foreach (var item in listStocksByMonth)
                            {
                                if (listOrderByMonth.Where(o => o.Year == item.Year && o.Month == item.Month).Count() > 0)
                                {
                                    newList.Add(listOrderByMonth.Where(o => o.Year == item.Year && o.Month == item.Month).FirstOrDefault());
                                }
                                else
                                {
                                    newList.Add(new FuzzyViewModel {
                                        Month = item.Month, Year = item.Year, ProductCode = item.ProductCode, Qty = 0
                                    });
                                }
                            }

                            listOrderByMonth = newList;
                        }
                    }

                    int maxSales     = listSalesByMonth.Max(o => o.Qty);
                    int minSales     = listSalesByMonth.Min(o => o.Qty);
                    var lastSalesObj = listSalesByMonth.OrderByDescending(o => o.Year).ThenByDescending(o => o.Month).FirstOrDefault();
                    int lastSales    = lastSalesObj.Qty;

                    int maxStock     = listStocksByMonth.Max(o => o.Qty);
                    int minStock     = listStocksByMonth.Min(o => o.Qty);
                    var lastStockObj = listStocksByMonth.OrderByDescending(o => o.Year).ThenByDescending(o => o.Month).FirstOrDefault();
                    int lastStock    = lastStockObj.Qty;

                    int maxOrder     = listOrderByMonth.Max(o => o.Qty);
                    int minOrder     = listOrderByMonth.Min(o => o.Qty);
                    var lastOrderObj = listOrderByMonth.OrderByDescending(o => o.Year).ThenByDescending(o => o.Month).FirstOrDefault();
                    int lastOrder    = lastOrderObj.Qty;

                    var sales = new Fuzzy();
                    sales.MaxNumber = maxSales;
                    sales.MinNumber = minSales;
                    sales.Input     = lastSales;
                    sales.CalculateLinearUp();
                    sales.CalculateLinearDown();

                    var stock = new Fuzzy();
                    stock.MaxNumber = maxStock;
                    stock.MinNumber = minStock;
                    stock.Input     = lastStock;
                    stock.CalculateLinearUp();
                    stock.CalculateLinearDown();

                    var order = new Fuzzy();
                    order.MaxNumber = maxOrder;
                    order.MinNumber = minOrder;
                    order.Input     = lastOrder;
                    order.CalculateLinearUp();
                    order.CalculateLinearDown();

                    var ruleSet = new Fuzzy();

                    var item1 = new Fuzzy();
                    item1.InputSales = sales.ResultLinearDown;
                    item1.InputStock = stock.ResultLinearUp;
                    ruleSet.Rule1    = item1.ImplicationFunction();

                    var item2 = new Fuzzy();
                    item2.InputSales = sales.ResultLinearDown;
                    item2.InputStock = stock.ResultLinearDown;
                    ruleSet.Rule2    = item2.ImplicationFunction();

                    var item3 = new Fuzzy();
                    item3.InputSales = sales.ResultLinearUp;
                    item3.InputStock = stock.ResultLinearUp;
                    ruleSet.Rule3    = item3.ImplicationFunction();

                    var item4 = new Fuzzy();
                    item4.InputSales = sales.ResultLinearUp;
                    item4.InputStock = stock.ResultLinearDown;
                    ruleSet.Rule4    = item4.ImplicationFunction();

                    ruleSet.RuleComposition();

                    if (ruleSet.DownResult < ruleSet.UpResult)
                    {
                        ruleSet.OrderStatus = 1; // Up
                    }
                    else if (ruleSet.DownResult > ruleSet.UpResult)
                    {
                        ruleSet.OrderStatus = 2; // Down
                    }
                    else
                    {
                        ruleSet.OrderStatus = 1;
                    }
                    //else if(ruleSet.UpResult == ruleSet.DownResult)
                    //{
                    //    ruleSet.OrderStatus = 3;
                    //}

                    var membershipFunction = new Fuzzy();

                    if (ruleSet.OrderStatus == 1) // Up
                    {
                        membershipFunction.OrderMax    = (order.Range * ruleSet.UpResult) + order.MinNumber;
                        membershipFunction.OrderMin    = (order.Range * ruleSet.DownResult) + order.MinNumber;
                        membershipFunction.OrderStatus = 1;
                    }
                    else if (ruleSet.OrderStatus == 2) // Down
                    {
                        membershipFunction.OrderMax    = (order.Range * ruleSet.UpResult) + order.MaxNumber;
                        membershipFunction.OrderMin    = (order.Range * ruleSet.DownResult) + order.MaxNumber;
                        membershipFunction.OrderStatus = 2;
                    }
                    //else if (ruleSet.OrderStatus == 3)
                    //{
                    //    membershipFunction.OrderMax = (order.Range * ruleSet.UpResult) + order.MaxNumber;
                    //    membershipFunction.OrderMin = (order.Range * ruleSet.DownResult) + order.MaxNumber;
                    //    membershipFunction.OrderStatus = 3;
                    //}

                    membershipFunction.MaxNumber = order.MaxNumber;
                    membershipFunction.MinNumber = order.MinNumber;

                    membershipFunction.UpResult   = ruleSet.UpResult;
                    membershipFunction.DownResult = ruleSet.DownResult;

                    //ViewBag.Result = membershipFunction.Defuzzyfication();

                    var listSeries = new List <ReportFuzzyViewModel>();

                    var date      = new DateTime(lastOrderObj.Year, lastOrderObj.Month, 1);
                    var nextMonth = date.AddMonths(1);

                    var listOrder = listOrderByMonth.OrderBy(o => o.Year).ThenBy(o => o.Month);
                    var listSales = listSalesByMonth.OrderBy(o => o.Year).ThenBy(o => o.Month).ToList();

                    foreach (var item in listOrder)
                    {
                        listSeries.Add(new ReportFuzzyViewModel
                        {
                            Date     = new DateTime(item.Year, item.Month, 1).ToString("MMM yy"),
                            Quantity = item.Qty
                        });
                    }

                    listSeries.Add(new ReportFuzzyViewModel
                    {
                        Date     = nextMonth.ToString("MMM yy"),
                        Quantity = 0
                    });

                    var listResult = new List <ReportFuzzyViewModel>();

                    listResult.Add(new ReportFuzzyViewModel
                    {
                        Date     = nextMonth.ToString("MMM yy"),
                        Quantity = decimal.Round(membershipFunction.Defuzzyfication())
                    });


                    var arrSalesQty    = "[";
                    var arrOrderQty    = "[";
                    var arrOrderDate   = "[";
                    var arrOrderResult = "[";

                    decimal lastSeries = 0;
                    int     indexLast  = 0;

                    for (int i = 0; i < listSeries.Count; i++)
                    {
                        var x = i + 1;
                        if (x >= listSeries.Count)
                        {
                            indexLast    = i - 1;
                            lastSeries   = listSeries[i - 1].Quantity;
                            arrSalesQty  = arrSalesQty + "null";
                            arrOrderQty  = arrOrderQty + "null";//string.Format("{0}", listSeries[i].Quantity);
                            arrOrderDate = arrOrderDate + string.Format("'{0}'", listSeries[i].Date);
                        }
                        else
                        {
                            arrSalesQty  = arrSalesQty + string.Format("{0},", listSales[i].Qty);
                            arrOrderQty  = arrOrderQty + string.Format("{0},", listSeries[i].Quantity);
                            arrOrderDate = arrOrderDate + string.Format("'{0}',", listSeries[i].Date);
                        }
                    }

                    for (int i = 0; i < listSeries.Count; i++)
                    {
                        var x = i + 1;
                        if (x >= listSeries.Count)
                        {
                            arrOrderResult = arrOrderResult + "{y:" + listResult[0].Quantity + ",marker: {enabled: true,states: {hover: {enabled: true}}}}";//string.Format("{0}", listResult[0].Quantity);
                        }
                        else if (i == indexLast)
                        {
                            arrOrderResult = arrOrderResult + "{y:" + lastSeries + ",marker: {enabled: false,states: {hover: {enabled: false}}}},";
                        }
                        else
                        {
                            arrOrderResult = arrOrderResult + "null,";
                        }
                    }


                    //if (arrOrderQty.Length > 2)
                    //{
                    //    arrOrderQty = arrOrderQty.Remove(arrOrderQty.Length - 1);
                    //}

                    //if (arrOrderDate.Length > 2)
                    //{
                    //    arrOrderDate = arrOrderDate.Remove(arrOrderDate.Length - 1);
                    //}

                    arrSalesQty    = arrSalesQty + "]";
                    arrOrderQty    = arrOrderQty + "]";
                    arrOrderDate   = arrOrderDate + "]";
                    arrOrderResult = arrOrderResult + "]";

                    ViewBag.arrSalesQty    = arrSalesQty;
                    ViewBag.arrOrderQty    = arrOrderQty;
                    ViewBag.arrOrderDate   = arrOrderDate;
                    ViewBag.arrOrderResult = arrOrderResult;

                    ViewBag.Result = "According to the calculations, the number of products (" + ViewBag.productName + ") should be ordered on the next month (" + nextMonth.ToString("MMM yy") + ") is about (" + decimal.Round(membershipFunction.Defuzzyfication()) + ") pieces";
                }
                else
                {
                    ViewBag.ErrMsg = "Insufficient data, cannot calculating stock prediction";
                }
            }
            else
            {
                ViewBag.ErrMsg = "Please select a product";
            }

            List <Product> list = new List <Product>();

            Supplier ret = context.Suppliers.Where(o => o.SupplierName == supplierName).FirstOrDefault();

            if (ret != null)
            {
                list = context.Products.Where(o => o.SupplierID == ret.SupplierID).ToList();
            }
            else if (User.IsInRole("admin") || User.IsInRole("sales"))
            {
                list = context.Products.ToList();
            }

            List <Product> listproduct = list;

            foreach (var item in listproduct)
            {
                item.ProductName = item.ProductCode + " - " + item.ProductName;
            }

            obj.listProduct = listproduct;

            return(View(obj));
        }
Beispiel #20
0
        public bool SolveDirection(Direction direction)
        {
            var distance = new Fuzzy(0.0);
            var position = startPosition;

            Log("----");

            while (true)
            {
                Log("(X ; Y) = ({0} ; {1})", position.X, position.Y);
                Log("(dX ; dY) = ({0} ; {1})", direction.Dx, direction.Dy);

                distance += position.MoveAlong(direction, step, out position);

                if (distance > maxDistance)
                {
                    Log("Max distance reached");
                    return false;
                }

                if (position.Equals(startPosition))
                {
                    Log("Start position reached !!!");
                    return true;
                }

                bool reflectionOnX, reflectionOnY;
                var xOnGrid = Fuzzy.Floor(position.X);
                var yOnGrid = Fuzzy.Floor(position.Y);

                Log("(X ; Y) = ({0} ; {1})", position.X, position.Y);

                var isOnHorizontalGrid = position.Y == yOnGrid;
                var isOnVerticalGrid = position.X == xOnGrid;

                Log("isOnHorizontalGrid = {0}", isOnHorizontalGrid);
                Log("isOnVerticalGrid = {0}", isOnVerticalGrid);

                if (isOnHorizontalGrid && isOnVerticalGrid)
                {
                    var mirrorOnUpperLeft = IsMirrorAt(position.X - step, position.Y - step);
                    var mirrorOnUpperRight = IsMirrorAt(position.X + step, position.Y - step);
                    var mirrorOnLowerLeft = IsMirrorAt(position.X - step, position.Y + step);
                    var mirrorOnLowerRight = IsMirrorAt(position.X + step, position.Y + step);

                    // we can't possibly be in the middle of 4 mirrors
                    Debug.Assert(!(mirrorOnUpperLeft&&mirrorOnUpperRight&&mirrorOnLowerLeft&&mirrorOnLowerRight));

                    reflectionOnX =
                        mirrorOnUpperLeft && mirrorOnLowerLeft ||
                        mirrorOnUpperRight && mirrorOnLowerRight;

                    reflectionOnY =
                        mirrorOnUpperLeft && mirrorOnUpperRight ||
                        mirrorOnLowerLeft && mirrorOnLowerRight;
                }
                else if (isOnHorizontalGrid)
                {
                    var mirrorAbove = IsMirrorAt(position.X, position.Y - step);
                    var mirrorBelow = IsMirrorAt(position.X, position.Y + step);

                    reflectionOnY = mirrorAbove || mirrorBelow;
                    reflectionOnX = false;
                }
                else if (isOnVerticalGrid)
                {
                    var mirrorOnLeft = IsMirrorAt(position.X - step, position.Y);
                    var mirrorOnRight = IsMirrorAt(position.X + step, position.Y);

                    reflectionOnX = mirrorOnLeft || mirrorOnRight;
                    reflectionOnY = false;
                }
                else if (IsMirrorAt(position.X, position.Y))
                {
                    Log("ray is destroyed");
                    return false;
                }
                else
                {
                    reflectionOnY = false;
                    reflectionOnX = false;
                }

                if (position.X <= 1 || position.X >= grid.GetLength(0) - 1) Debug.Assert(reflectionOnX);
                if (position.Y <= 1 || position.Y >= grid.GetLength(1) - 1) Debug.Assert(reflectionOnY);
                if (reflectionOnX) Log("reflection on Y");
                if (reflectionOnY) Log("reflection on Y");

                direction = new Direction(
                    direction.Dx * (reflectionOnX ? -1 : 1),
                    direction.Dy * (reflectionOnY ? -1 : 1));
            }
        }
 public static Fuzzy ToFuzzy(this bool value) => Fuzzy.Create(value);
Beispiel #22
0
 public Position(Fuzzy x, Fuzzy y)
 {
     this.x = x;
     this.y = y;
 }
 public Event(EventType type, Fuzzy time, int car1, int car2)
     : this()
 {
     Type = type;
     Time = time;
     Car1 = car1;
     Car2 = car2;
 }