예제 #1
0
        public override int GetHashCode()
        {
            int hash = 23;

            if (ScheduleSymbols != null && ScheduleSymbols.Count != 0)
            {
                foreach (SymbolicValue ScheduleSymbol in ScheduleSymbols)
                {
                    hash = hash * 37 + ScheduleSymbol.GetHashCode();
                }
            }
            return(hash);
        }
예제 #2
0
        public void HardResetSchedule(HashSet <SymbolicValue> NewScheduleSymbols,
                                      Dictionary <string, HashSet <long> > resolvedSchedule)
        {
            Schedule.ScheduleSymbols = NewScheduleSymbols;
            this.RITEIds             = new HashSet <long>();
            if (resolvedSchedule != null)
            {
                this.ResolvedSchedule = resolvedSchedule;

                foreach (SymbolicValue ScheduleSymbol in this.Schedule.ScheduleSymbols)
                {
                    if (ResolvedSchedule != null)
                    {
                        if (ResolvedSchedule.ContainsKey(ScheduleSymbol.ToString()))
                        {
                            RITEIds.UnionWith(ResolvedSchedule[ScheduleSymbol.ToString()]);
                        }
                    }
                }
            }

            // If all dimensions are empty, then subject is not constrained

            if ((this.ResolvedExposureTypes.Count == 0) && (this.CausesOfLoss.Count == 0) && (this.RITEIds.Count == 0))
            {
                isNotConstrained = true;
            }

            // If any dimension is empty, set from universal subject

            if (UniversalSubject != null)
            {
                if (this.RITEIds.Count == 0)
                {
                    if (this.RITEIds.Count == 0)
                    {
                        this.RITEIds = UniversalSubject.AllRITEIds;
                    }
                }
            }

            // Rebuild components

            Components = new Dictionary <SymbolicValue, Dictionary <int, Tuple <HashSet <long>, HashSet <long> > > >();

            foreach (SymbolicValue CauseOfLoss in this.CausesOfLoss)
            {
                if (!Components.ContainsKey(CauseOfLoss))
                {
                    Components.Add(CauseOfLoss, new Dictionary <int, Tuple <HashSet <long>, HashSet <long> > >());
                }
                foreach (int ResolvedExposureType in this.ResolvedExposureTypes)
                {
                    if (!Components[CauseOfLoss].ContainsKey(ResolvedExposureType))
                    {
                        Components[CauseOfLoss].Add(ResolvedExposureType, Tuple.Create(new HashSet <long>(), new HashSet <long>()));
                    }
                    foreach (long RITEId in this.RITEIds)
                    {
                        if (CoverageIdAttrMap.ContainsKey(RITEId) && CoverageIdAttrMap[RITEId].ExposureType.Equals(ResolvedExposureType))
                        {
                            Components[CauseOfLoss][ResolvedExposureType].Item1.Add(RITEId);
                        }
                        else
                        {
                            Components[CauseOfLoss][ResolvedExposureType].Item2.Add(RITEId);
                        }
                    }
                    if (Components[CauseOfLoss][ResolvedExposureType].Item1.Count == 0)
                    {
                        Components[CauseOfLoss].Remove(ResolvedExposureType);
                    }
                }
                if (Components[CauseOfLoss].Count == 0)
                {
                    Components.Remove(CauseOfLoss);
                }
            }
        }
예제 #3
0
        public Subject(UniversalSubjectPosition universalSubject,
                       Schedule Schedule,
                       HashSet <SymbolicValue> CausesOfLoss,
                       HashSet <SymbolicValue> ExposuresTypes,
                       Dictionary <string, HashSet <long> > resolvedSchedule = null,
                       Dictionary <long, RiskItemCharacteristicIDAttributes> CoverageIdAttrMap = null,
                       bool Resolution = false)
        {
            SetID();

            this.UniversalSubject  = universalSubject;
            this.CoverageIdAttrMap = CoverageIdAttrMap;

            this.Schedule = Schedule;
            this.RITEIds  = new HashSet <long>();
            if (resolvedSchedule != null)
            {
                this.ResolvedSchedule = resolvedSchedule;

                foreach (SymbolicValue ScheduleSymbol in this.Schedule.ScheduleSymbols)
                {
                    if (ResolvedSchedule != null)
                    {
                        if (ResolvedSchedule.ContainsKey(ScheduleSymbol.ToString()))
                        {
                            RITEIds.UnionWith(ResolvedSchedule[ScheduleSymbol.ToString()]);
                        }
                    }
                }
            }

            //this.RiskItemIds = new HashSet<long>(this.RITEIds.Select(x => CoverageIdAttrMap[x].RITExposureId).Distinct());

            this.CausesOfLoss = CausesOfLoss;

            this.ExposureTypes         = ExposuresTypes;
            this.ResolvedExposureTypes = new HashSet <int>();
            foreach (SymbolicValue _ExposureType in ExposureTypes)
            {
                //ExposureType.ExposureTypeGroup ExposureTypeGroup = new ExposureType.ExposureTypeGroup();
                //ExposureTypeGroup.Set((ExposureType.EExposureType)(Enum.Parse(typeof(ExposureType.EExposureType), _ExposureType.ToString())));
                //ResolvedExposureTypes.UnionWith(ExposureTypeGroup.GetIndividualIntExposureTypes());
                //TODO : Use the above approach (3 lines of code) when platform is fixed and ready
                ResolvedExposureTypes.UnionWith(
                    ExposureType.GetIndividualIntExposureTypes(
                        (ExposureType.EExposureType)(Enum.Parse(typeof(ExposureType.EExposureType), _ExposureType.ToString()))
                        )
                    );
            }

            // If all dimensions are empty, then subject is not constrained

            if ((this.ResolvedExposureTypes.Count == 0) && (this.CausesOfLoss.Count == 0) && (this.RITEIds.Count == 0))
            {
                isNotConstrained = true;
            }

            // If any dimension is empty, set from universal subject

            if (UniversalSubject != null)
            {
                if (this.ResolvedExposureTypes.Count == 0)
                {
                    this.ResolvedExposureTypes = UniversalSubject.ResolvedExposureTypes;
                }

                if (this.CausesOfLoss.Count == 0)
                {
                    this.CausesOfLoss = UniversalSubjectPosition.CausesOfLoss;
                }

                if (this.RITEIds.Count == 0)
                {
                    this.RITEIds = UniversalSubject.AllRITEIds;
                }
            }

            this.PerRisk = Resolution;

            // Build components

            //Components = new HashSet<Tuple<int, long, SymbolicValue>>();
            Components = new Dictionary <SymbolicValue, Dictionary <int, Tuple <HashSet <long>, HashSet <long> > > >();

            if (this.RITEIds == null)
            {
                throw new NullReferenceException("Universal Subject RITEs cannot be null (can be empty)!");
            }
            if (this.RITEIds.Count != 0)
            {
                foreach (SymbolicValue CauseOfLoss in this.CausesOfLoss)
                {
                    if (!Components.ContainsKey(CauseOfLoss))
                    {
                        Components.Add(CauseOfLoss, new Dictionary <int, Tuple <HashSet <long>, HashSet <long> > >());
                    }
                    foreach (int ResolvedExposureType in this.ResolvedExposureTypes)
                    {
                        if (!Components[CauseOfLoss].ContainsKey(ResolvedExposureType))
                        {
                            Components[CauseOfLoss].Add(ResolvedExposureType, Tuple.Create(new HashSet <long>(), new HashSet <long>()));
                        }
                        foreach (long RITEId in this.RITEIds)
                        {
                            if (CoverageIdAttrMap.ContainsKey(RITEId) && CoverageIdAttrMap[RITEId].ExposureType.Equals(ResolvedExposureType))
                            {
                                Components[CauseOfLoss][ResolvedExposureType].Item1.Add(RITEId);
                            }
                            else
                            {
                                Components[CauseOfLoss][ResolvedExposureType].Item2.Add(RITEId);
                            }
                        }
                        if (Components[CauseOfLoss][ResolvedExposureType].Item1.Count == 0)
                        {
                            Components[CauseOfLoss].Remove(ResolvedExposureType);
                        }
                    }
                    if (Components[CauseOfLoss].Count == 0)
                    {
                        Components.Remove(CauseOfLoss);
                    }
                }
            }
        }
예제 #4
0
        public Subject(UniversalSubjectPosition universalSubject,
                       Schedule Schedule,
                       HashSet <SymbolicValue> CausesOfLoss,
                       HashSet <SymbolicValue> ExposuresTypes,
                       Dictionary <string, HashSet <long> > resolvedSchedule = null,
                       Dictionary <long, int> coverageIdExposureTypeMap      = null,
                       bool Resolution = false)
        {
            this.UniversalSubject          = universalSubject;
            this.CoverageIdExposureTypeMap = coverageIdExposureTypeMap;

            this.Schedule = Schedule;
            this.RITEIds  = new HashSet <long>();
            if (resolvedSchedule != null)
            {
                this.ResolvedSchedule = resolvedSchedule;

                foreach (SymbolicValue ScheduleSymbol in this.Schedule.ScheduleSymbols)
                {
                    if (ResolvedSchedule != null)
                    {
                        if (ResolvedSchedule.ContainsKey(ScheduleSymbol.ToString()))
                        {
                            RITEIds.UnionWith(ResolvedSchedule[ScheduleSymbol.ToString()]);
                        }
                    }
                }
            }

            this.CausesOfLoss = CausesOfLoss;

            this.ExposureTypes         = ExposuresTypes;
            this.ResolvedExposureTypes = new HashSet <int>();
            foreach (SymbolicValue _ExposureType in ExposureTypes)
            {
                //ExposureType.ExposureTypeGroup ExposureTypeGroup = new ExposureType.ExposureTypeGroup();
                //ExposureTypeGroup.Set((ExposureType.EExposureType)(Enum.Parse(typeof(ExposureType.EExposureType), _ExposureType.ToString())));
                //ResolvedExposureTypes.UnionWith(ExposureTypeGroup.GetIndividualIntExposureTypes());
                //TODO : Use the above approach (3 lines of code) when platform is fixed and ready
                ResolvedExposureTypes.UnionWith(
                    ExposureType.GetIndividualIntExposureTypes(
                        (ExposureType.EExposureType)(Enum.Parse(typeof(ExposureType.EExposureType), _ExposureType.ToString()))
                        )
                    );
            }

            // If all dimensions are empty, then subject is not constrained

            if ((this.ResolvedExposureTypes.Count == 0) && (this.CausesOfLoss.Count == 0) && (this.RITEIds.Count == 0))
            {
                isNotConstrained = true;
            }

            // If any dimension is empty, set from universal subject

            if (UniversalSubject != null)
            {
                if (this.ResolvedExposureTypes.Count == 0)
                {
                    this.ResolvedExposureTypes = UniversalSubject.GetResolvedExposureTypes();
                }

                if (this.CausesOfLoss.Count == 0)
                {
                    this.CausesOfLoss = UniversalSubjectPosition.GetCausesOfLoss();
                }

                if (this.RITEIds.Count == 0)
                {
                    this.RITEIds = UniversalSubject.GetAllRITEIds();
                }
            }

            this.PerRisk = Resolution;

            // Build components

            //Components = new HashSet<Tuple<int, long, SymbolicValue>>();
            Components = new Dictionary <SymbolicValue, Dictionary <int, HashSet <long> > >();

            foreach (SymbolicValue CauseOfLoss in this.CausesOfLoss)
            {
                if (!Components.ContainsKey(CauseOfLoss))
                {
                    Components.Add(CauseOfLoss, new Dictionary <int, HashSet <long> >());
                }
                foreach (int ResolvedExposureType in this.ResolvedExposureTypes)
                {
                    if (!Components[CauseOfLoss].ContainsKey(ResolvedExposureType))
                    {
                        Components[CauseOfLoss].Add(ResolvedExposureType, new HashSet <long>());
                    }
                    foreach (long RITEId in this.RITEIds)
                    {
                        if (CoverageIdExposureTypeMap.ContainsKey(RITEId) && CoverageIdExposureTypeMap[RITEId].Equals(ResolvedExposureType))
                        {
                            //Components.Add(new Tuple<int, long, SymbolicValue>(ResolvedExposureType, RITEId, CauseOfLoss));
                            Components[CauseOfLoss][ResolvedExposureType].Add(RITEId);
                        }
                    }
                    if (Components[CauseOfLoss][ResolvedExposureType].Count == 0)
                    {
                        Components[CauseOfLoss].Remove(ResolvedExposureType);
                    }
                }
                if (Components[CauseOfLoss].Count == 0)
                {
                    Components.Remove(CauseOfLoss);
                }
            }
        }