public SimpleSetup(StateSpace space) : this(ompl_geometricPINVOKE.new_SimpleSetup__SWIG_1(StateSpace.getCPtr(space)), true) { if (ompl_geometricPINVOKE.SWIGPendingException.Pending) { throw ompl_geometricPINVOKE.SWIGPendingException.Retrieve(); } }
public SpaceInformation(StateSpace space) : this(ompl_basePINVOKE.new_SpaceInformation(StateSpace.getCPtr(space)), true) { if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } }
public SubspaceStateSampler(StateSpace space, StateSpace subspace, double weight) : this(ompl_basePINVOKE.new_SubspaceStateSampler(StateSpace.getCPtr(space), StateSpace.getCPtr(subspace), weight), true) { if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } }
public RealVectorDeterministicStateSampler(StateSpace space, DeterministicSequence sequence_ptr) : this(ompl_basePINVOKE.new_RealVectorDeterministicStateSampler__SWIG_3(StateSpace.getCPtr(space), DeterministicSequence.getCPtr(sequence_ptr)), true) { if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } }
public SO2DeterministicStateSampler(StateSpace space) : this(ompl_basePINVOKE.new_SO2DeterministicStateSampler__SWIG_1(StateSpace.getCPtr(space)), true) { if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } }
public RealVectorDeterministicStateSampler(StateSpace space, DeterministicStateSampler.DeterministicSamplerType type) : this(ompl_basePINVOKE.new_RealVectorDeterministicStateSampler__SWIG_0(StateSpace.getCPtr(space), (int)type), true) { if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } }
public ScopedStateStateSpace(StateSpace space, State state) : this(ompl_basePINVOKE.new_ScopedStateStateSpace__SWIG_3(StateSpace.getCPtr(space), State.getCPtr(state)), true) { if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } }
public SE2DeterministicStateSampler(StateSpace space, DeterministicSequence sequence_ptr, bool stretch_rv) : this(ompl_basePINVOKE.new_SE2DeterministicStateSampler__SWIG_3(StateSpace.getCPtr(space), DeterministicSequence.getCPtr(sequence_ptr), stretch_rv), true) { if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } }
public CompoundStateSampler(StateSpace space) : this(ompl_basePINVOKE.new_CompoundStateSampler(StateSpace.getCPtr(space)), true) { if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } }
public void getCommonSubspaces(StateSpace other, SWIGTYPE_p_std__vectorT_std__string_t subspaces) { ompl_basePINVOKE.StateSpace_getCommonSubspaces__SWIG_0(swigCPtr, StateSpace.getCPtr(other), SWIGTYPE_p_std__vectorT_std__string_t.getCPtr(subspaces)); if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } }
public static void setDeterministicStateSamplerAllocator(StateSpace space, uint dim) { ompl_basePINVOKE.Determinism_setDeterministicStateSamplerAllocator(StateSpace.getCPtr(space), dim); if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } }
public void SetInvalid_RemovesValidState9() { var sp = new StateSpace(); sp.SetInvalid(9); Assert.IsTrue(sp.GetValidStates().SequenceEqual(new int[] { 1, 2, 3, 4, 5, 6, 7, 8 })); }
public void addSubspace(StateSpace component, double weight) { ompl_basePINVOKE.CompoundStateSpace_addSubspace(swigCPtr, StateSpace.getCPtr(component), weight); if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } }
double P() { if (fb == null || fb.Count == 0) { throw new Exception("You have to call DoWork() first"); } return(StateSpace.Sum(state => fb[state][T - 1])); }
public static AdvancedStateCopyOperation copyStateData(StateSpace destS, State dest, StateSpace sourceS, State source, SWIGTYPE_p_std__vectorT_std__string_t subspaces) { AdvancedStateCopyOperation ret = (AdvancedStateCopyOperation)ompl_basePINVOKE.copyStateData__SWIG_2(StateSpace.getCPtr(destS), State.getCPtr(dest), StateSpace.getCPtr(sourceS), State.getCPtr(source), SWIGTYPE_p_std__vectorT_std__string_t.getCPtr(subspaces)); if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public static AdvancedStateCopyOperation copyStateData(StateSpace destS, State dest, StateSpace sourceS, State source) { AdvancedStateCopyOperation ret = (AdvancedStateCopyOperation)ompl_basePINVOKE.copyStateData__SWIG_0(StateSpace.getCPtr(destS), State.getCPtr(dest), StateSpace.getCPtr(sourceS), State.getCPtr(source)); if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public bool covers(StateSpace other) { bool ret = ompl_basePINVOKE.StateSpace_covers__SWIG_0(swigCPtr, StateSpace.getCPtr(other)); if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public StateSampler allocSubspaceStateSampler(StateSpace subspace) { global::System.IntPtr cPtr = ompl_basePINVOKE.StateSpace_allocSubspaceStateSampler__SWIG_0(swigCPtr, StateSpace.getCPtr(subspace)); StateSampler ret = (cPtr == global::System.IntPtr.Zero) ? null : new StateSampler(cPtr, true); if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public StateSpace getSubspace(string name) { global::System.IntPtr cPtr = ompl_basePINVOKE.CompoundStateSpace_getSubspace__SWIG_1(swigCPtr, name); StateSpace ret = (cPtr == global::System.IntPtr.Zero) ? null : new StateSpace(cPtr, true); if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public static StateSampler allocHalton(StateSpace space, uint dim) { global::System.IntPtr cPtr = ompl_basePINVOKE.Determinism_allocHalton(StateSpace.getCPtr(space), dim); StateSampler ret = (cPtr == global::System.IntPtr.Zero) ? null : new StateSampler(cPtr, true); if (ompl_basePINVOKE.SWIGPendingException.Pending) { throw ompl_basePINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public StateSpace getStateSpace() { global::System.IntPtr cPtr = ompl_geometricPINVOKE.SimpleSetup_getStateSpace(swigCPtr); StateSpace ret = (cPtr == global::System.IntPtr.Zero) ? null : new StateSpace(cPtr, true); if (ompl_geometricPINVOKE.SWIGPendingException.Pending) { throw ompl_geometricPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public override double P() { if (fb == null || fb.Count == 0) { throw new Exception("You have to call DoWork() first"); } return (StateSpace.Sum( state => InitialProbabilitiesOfStates[state] * EmissionMatrix[state, SequenceOfObservations[0]] * fb[state][0])); }
public static State MinusOneUnit(this StateSpace ss, IMDPState s, Route route) { IMDPState _s = s.Clone(); foreach (Product p in route) { foreach (Resource r in p) { if ((_s as State).Keys.Contains(r) && (_s as State)[r] > 0) { (_s as State)[r] -= 1; } } } return(ss.FirstOrDefault(i => i.Equals(_s)) as State); }
private void ValidateParameters() { if (EmissionMatrix == null || TransitionMatrix == null || SequenceOfObservations == null || StateSpace == null || ObservationSpace == null) { throw new ArgumentException("Parameters cannot be null"); } if (ObservationSpace.Length != EmissionMatrix.GetLength(1) || ObservationSpace.Length == 0) { throw new ArgumentException("N should be greater than 0 and consistent"); } #if _USE_ARRAYS_INSTEAD_OF_MATRIX_HASHTABLE if (StateSpace.Length != TransitionMatrix.GetLength(0) || TransitionMatrix.GetLength(0) != TransitionMatrix.GetLength(1) || TransitionMatrix.GetLength(1) != EmissionMatrix.GetLength(0) || EmissionMatrix.GetLength(0) != InitialProbabilitiesOfStates.Length || StateSpace.Length == 0) { throw new ArgumentException("K should be greater than 0 and consistent"); } #else if (StateSpace.Length != TransitionMatrix.GetLength(0) || TransitionMatrix.GetLength(0) != TransitionMatrix.GetLength(1) || TransitionMatrix.GetLength(1) != EmissionMatrix.GetLength(0) || EmissionMatrix.GetLength(0) != InitialProbabilitiesOfStates.Count || StateSpace.Length == 0) { throw new ArgumentException("K should be greater than 0 and consistent"); } #endif if (SequenceOfObservations.Length == 0) { throw new ArgumentException("T should be greater than 0 and consistent"); } if ( StateSpace.Select(state => ObservationSpace.Sum(observation => EmissionMatrix[state, observation])) .Any(sum => sum <= 0.99 || sum >= 1.01)) { throw new ArgumentException("EmissionMatrix has not normalized probabilities"); //Exception("Emi"); } if ( StateSpace.Select(state1 => StateSpace.Sum(state2 => TransitionMatrix[state1, state2])) .Any(sum => sum <= 0.99 || sum >= 1.01)) { throw new ArgumentException("TransitionMatrix has not normalized probabilities"); //Exception("Emi"); } }
public override void DoWork() { base.DoWork(); AlphaPass(); BetaPass(); _probabilitySuffix = StateSpace.Sum( state => InitialProbabilitiesOfStates[state] * EmissionMatrix[state, SequenceOfObservations[0]] * beta[state][0]); _probabilityPrefix = StateSpace.Sum(state => alpha[state][T - 1]); var TOLERANCE = 1e-3; if (Math.Abs((_probabilitySuffix - _probabilityPrefix) / _probabilityPrefix) > TOLERANCE) { throw new Exception("Probabilities are not equal"); } // Probability = (_probabilitySuffix + _probabilityPrefix)/2.0; LogProbability = 0.0; for (int i = 0; i < T; i++) { LogProbability -= Math.Log(c[i]); } Probability = Math.Exp(LogProbability); Output = new TState[T]; for (var i = 0; i < T; i++) { var mostProbableState = StateSpace.Aggregate( (s1, s2) => alpha[s1][i] * beta[s1][i] > alpha[s2][i] * beta[s2][i] ? s1 : s2); Output[i] = mostProbableState; } }
/// <summary> /// Populate states reachable from initial state within the current number of iterations /// </summary> private void ExtendStateSpace(IDeterministicPolicy <TState> policy) { var previousLayer = StateSpace[_iteration - 1]; if (StateSpace.ContainsKey(_iteration)) { return; } var layer = new HashSet <TState>(); if (_iteration > 2) { layer = StateSpace[_iteration - 2]; layer.Clear(); } var distinctLayer = new List <TState>(); var nextStates = new HashSet <TState>(); foreach (var state in previousLayer) { var action = policy[state]; if (action == null) { continue; } nextStates.UnionWith(action[state]); } foreach (var nextState in nextStates) { if (AllStateSpace.Add(nextState)) { distinctLayer.Add(nextState); } layer.Add(nextState); } StateSpace[_iteration] = layer; DistinctStateSpace[_iteration] = distinctLayer; }
public override void DoWork() { base.DoWork(); foreach (var state in StateSpace) { fb[state][T - 1] = 1; //InitialProbabilitiesOfStates[state] * EmissionMatrix[state, SequenceOfObservations[T - 1]]; } for (var i = T - 2; i >= 0; i--) { foreach (var kState in StateSpace) { fb[kState][i] = StateSpace.Sum( lState => TransitionMatrix[kState, lState] * EmissionMatrix[lState, SequenceOfObservations[i + 1]] * fb[lState][i + 1]); } } }
public IMDPStateSpace GenStateSpace(IMDPState s, IMDPDecision a) { //目前状态减去开放产品集中的产品 IMDPStateSpace subss = new StateSpace(); if ((s as State).CanSupportDecision(a as Decision)) { foreach (Product p in (a as Decision).OpenProductSet) { IMDPState _s = (_ss as StateSpace).MinusOneUnit(s, p); if (!subss.Contains(_s)) { subss.Add(_s); } } //再加入本身 subss.Add(s); } return(subss); }
public CasinoState(StateSpace stateSpace, int result) { StateSpace = stateSpace; Result = result; }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(StateSpace obj) { return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr); }