Пример #1
0
            private static int BinPackComparer(BinPack a, BinPack b, Stuff s)
            {
                //tolerance
                double nearDecidingRate = 1.2;

                //binPackSet
                double aVolume = a.Volume;
                double bVolume = b.Volume;

                double aRemain = a.GetRemain();
                double bRemain = b.GetRemain();

                double aCost = Math.Abs(a.GetRemain() - s.Volume);
                double bCost = Math.Abs(b.GetRemain() - s.Volume);

                double sVolume = s.Volume;

                //decider
                bool IsAMoreProper = aCost < bCost;


                //compare
                //seive: subzero bin
                if (aVolume <= 0)
                {
                    if (bVolume <= 0)
                    {
                        if (IsAMoreProper)
                        {
                            return(-1);
                        }
                        return(1);
                    }

                    if (bRemain >= sVolume)
                    {
                        return(1);
                    }
                    else
                    {
                        if (IsAMoreProper)
                        {
                            return(-1);
                        }
                        return(1);
                    }
                }

                if (bVolume <= 0)
                {
                    if (aRemain >= sVolume)
                    {
                        return(-1);
                    }
                    else
                    {
                        if (IsAMoreProper)
                        {
                            return(-1);
                        }
                        return(1);
                    }
                }

                //actual comparer
                if (aRemain <= sVolume)
                {
                    if (bRemain <= sVolume)
                    {
                        if (IsAMoreProper)
                        {
                            return(-1);
                        }
                        return(1);
                    }

                    if (aRemain * nearDecidingRate >= sVolume)
                    {
                        return(-1);
                    }
                    return(1);
                }

                if (bRemain <= sVolume)
                {
                    if (bRemain * nearDecidingRate >= sVolume)
                    {
                        return(1);
                    }
                    return(-1);
                }

                if (IsAMoreProper)
                {
                    return(-1);
                }
                return(1);
            }