/// <summary>
/// The prediction method which can be called from SQL Server
/// </summary>
/// <param name="inputCase"></param>
/// <param name="predictionResult"></param>
protected override void Predict(MiningCase inputCase, PredictionResult predictionResult)
{
//the input values and predictec label
double[] values;
uint label = 0;
int attributeSize = 0;
//convert and scale the input
getValues(inputCase, out values, out label, out attributeSize);
Instance instance = new Instance(1, (int)label, values, getLabels());
//obtain the votes
int[] votes = getVotes(instance);
label = 0;
for (uint i = 1; i < votes.Length; i++)
{
if (votes[i] > votes[label])
{
label = i;
}
}
//construct the output
AttributeStatistics attStats = new AttributeStatistics();
attStats.Attribute = getTargetAttribute();
StateStatistics stateStat = new StateStatistics();
StateValue stateVal = new StateValue();
stateVal.SetIndex(label);
stateStat.Value = AttributeSet.TokenizeAttributeValue(attStats.Attribute, AttributeSet.UntokenizeAttributeValue(attStats.Attribute, stateVal));
attStats.StateStatistics.Add(stateStat);
predictionResult.AddPrediction(attStats);
}
protected override void LoadFromRepository()
{
if (IsDebugEnabled)
{
log.Debug("저장된 Page 상태정보를 저장소에서 로드합니다.. StateValue=[{0}]", StateValue);
}
if (StateValue.IsWhiteSpace())
{
return;
}
var stateEntity = Serializer.Deserialize(StateValue.Base64Decode()) as IPageStateEntity;
object pageState;
if (PageStateTool.TryParseStateEntity(stateEntity, Compressor, out pageState))
{
if (pageState is Pair)
{
ViewState = ((Pair)pageState).First;
ControlState = ((Pair)pageState).Second;
if (IsDebugEnabled)
{
log.Debug("압축된 Hidden Field의 값을 읽어와서 Page의 상태정보로 설정했습니다!!!");
}
}
}
}
void OnUserDataAction(UserData ud, UserData.Action act)
{
switch (act)
{
case UserData.Action.Load:
//update global states
if (mGlobalStates != null && mGlobalStates.Count > 0)
{
string[] keys = new string[mGlobalStates.Count];
mGlobalStates.Keys.CopyTo(keys, 0);
foreach (string key in keys)
{
StateValue val = mGlobalStates[key];
val.Apply(ud, string.Format(GlobalDataFormat, key));
mGlobalStates[key] = val;
}
}
//update states
if (mStates != null && mStates.Count > 0 && !string.IsNullOrEmpty(mScene))
{
string[] keys = new string[mStates.Count];
mStates.Keys.CopyTo(keys, 0);
foreach (string key in keys)
{
StateValue val = mStates[key];
val.Apply(ud, string.Format(DataFormat, mScene, key));
mStates[key] = val;
}
}
break;
}
}
public void StateValue_Test()
{
var hashArray = Hash.FromString("hash").ToByteArray();
var stateValue = StateValue.Create(hashArray);
var isDirty = stateValue.IsDirty;
isDirty.ShouldBeFalse();
var hashArray1 = stateValue.Get();
hashArray.ShouldBe(hashArray1);
var hashArray2 = Hash.FromString("hash1").ToByteArray();
stateValue.Set(hashArray2);
isDirty = stateValue.IsDirty;
isDirty.ShouldBeTrue();
var hashArray3 = stateValue.Get();
hashArray3.ShouldBe(hashArray2);
stateValue.OriginalValue.ShouldBe(hashArray);
stateValue.CurrentValue.ShouldBe(hashArray2);
}
void AppendInitData()
{
InitData[] dats;
if (mStartData.TryGetValue(mScene, out dats))
{
foreach (InitData dat in dats)
{
if (!string.IsNullOrEmpty(dat.name))
{
//check if data exists in user first
string key = string.Format(DataFormat, mScene, dat.name);
StateValue s = dat.stateValue;
s.Apply(UserData.main, key);
if (s.type != Type.Invalid)
{
if (mStates.ContainsKey(dat.name))
{
mStates[dat.name] = s;
}
else
{
mStates.Add(dat.name, s);
}
if (onValueChange != null)
{
onValueChange(false, dat.name, s);
}
}
}
}
}
}
void AppendGlobalInitData()
{
foreach (InitData dat in globalStartData)
{
if (!string.IsNullOrEmpty(dat.name))
{
//check if data exists in user first
string key = string.Format(GlobalDataFormat, dat.name);
StateValue s = dat.stateValue;
s.Apply(UserData.main, key);
if (s.type != Type.Invalid)
{
if (mGlobalStates.ContainsKey(dat.name))
{
mGlobalStates[dat.name] = s;
}
else
{
mGlobalStates.Add(dat.name, s);
}
if (onValueChange != null)
{
onValueChange(true, dat.name, s);
}
}
}
}
}
/// <summary>
/// ViewState 저장소로부터 저장된 ViewState 정보를 가져옵니다.
/// </summary>
protected override void LoadFromRepository()
{
if (IsDebugEnabled)
{
log.Debug("캐시에서 키[{0}]에 해당하는 페이지 상태정보를 로드합니다...", StateValue);
}
if (StateValue.IsWhiteSpace())
{
return;
}
var cacheKey = GetCacheKey();
Pair pair = CacheRepository.Get(cacheKey) as Pair;
if (pair != null)
{
ViewState = pair.First;
ControlState = pair.Second;
if (IsDebugEnabled)
{
log.Debug("Page 상태정보를 저장소로부터 로드했습니다. StateValue=[{0}], CacheKey=[{1}]", StateValue, cacheKey);
}
}
else
{
if (log.IsWarnEnabled)
{
log.Warn("Page 상태정보를 저장소로부터 로드했지만, NULL 값입니다!!! StateValue=[{0}]", StateValue);
}
}
}
public ShellController([StateDependency("State")] StateValue <ShuttleState> state,
[ServiceDependency] IHttpContextLocatorService contextLocator,
[ServiceDependency] IAuthorizationService authService)
: base(state, contextLocator, authService)
{
// code goes here
}
/// <summary>
/// Page의 ViewState 정보를 특정 저장소에 저장하고, 저장 토큰 값을 <see cref="AbstractServerPageStatePersister.StateValue"/>에 저장합니다.
/// </summary>
protected override void SaveToRepository()
{
if (IsDebugEnabled)
{
log.Debug("Page 상태정보를 저장합니다...");
}
RemoveExpires(Expiration);
var pageState = new Pair(ViewState, ControlState);
if (StateValue.IsWhiteSpace())
{
StateValue = Guid.NewGuid().ToString();
}
var stateEntity = (PageStateEntity)PageStateTool.CreateStateEntity(StateValue, pageState, Compressor, CompressThreshold);
using (var repository = CreateRepository()) {
var query = Query.EQ(MongoTool.IdString, stateEntity.Id);
var updated = Update.Set("Value", stateEntity.Value).Set("IsCompressed", stateEntity.IsCompressed).Set("CreatedDate",
stateEntity.
CreatedDate);
// UPSERT
var result = repository.FindAndModify(query, SortBy.Null, updated, true, true);
if (IsDebugEnabled)
{
log.Debug("캐시에 Page 상태정보를 저장했습니다!!! StateValue=[{0}], Expiration=[{1}] (min), Result=[{2}]", StateValue, Expiration,
result.Ok);
}
}
}
public void CanCreateInstanceSpecifyingValue()
{
Guid id = Guid.NewGuid();
StateValue <Guid> stateValue = new StateValue <Guid>(id);
Assert.AreEqual(id, stateValue.Value);
}
public void return_false_when_state_value_doesnt_exist()
{
var stateValueManager = new StateValueManagement();
var stateValueToAdd = new StateValue("sentinel1", "package1", "statename", 2, TypeOfValue.Int);
stateValueManager.AddStateValue(stateValueToAdd);
Check.That(stateValueManager.Exist(stateValueManager.GetStateValueKey("sentinel1", "package2", "statename"))).IsEqualTo(false);
}
/// <summary>
/// Métoo para verificar se o estado é final segundo a regra do ponto
/// </summary>
/// <returns></returns>
public bool VerifyFinal()
{
if (StateValue.Contains("."))
{
int lastIndex = StateValue.LastIndexOf('.');
return(StateValue[StateValue.Length - 1] == StateValue[lastIndex]);
}
return(false);
}
public void TestCanSaveValueTypeValuesToSession()
{
StateValue <bool> stateValue = new StateValue <bool>();
stateValue.SessionState = new MockSessionState();
stateValue.Value = true;
Assert.IsTrue(stateValue.Value);
}
public void UpdateStateValue(StateValue stateValue)
{
var stateValueKey = CreateKeyForStateValue(stateValue);
if (!_stateValues.ContainsKey(stateValueKey))
{
throw new StateValueNotExistException(stateValueKey);
}
_stateValues[stateValueKey].Value = stateValue.Value;
}
private CustomersController GetCustomersControllerInitialized(INavigationService navigationService, List <Customer> customers)
{
CustomersController controller = new CustomersController(navigationService);
StateValue <Customer> currentCustomerState = new StateValue <Customer>();
StateValue <List <Customer> > customersState = new StateValue <List <Customer> >(customers);
controller.InitializeState(currentCustomerState, customersState);
return(controller);
}
public FuncInfo()
{
a_funcValue = new FuncValue();
fault = "0";
recOverTimefault = "0";
a_stateValue = new StateValue();
cObjectString = "0";
cObjectString2 = "0";
configObject = new object();
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
StateValue sv = (value as StateValue);
//sanity checks
if (sv == StateValue.Player)
{
return(Colors.Red);
}
//etc
}
public void return_parameters_not_null_on_new_state_value_with_2_on_value()
{
var stateValue = new StateValue("sentinel", "package", "name", 2, TypeOfValue.Int);
Check.That(stateValue.Value).IsNotNull();
Check.That(stateValue.TypeOfValue).IsEqualTo(TypeOfValue.Int);
Check.That(stateValue.LastUpdate).IsInstanceOf <DateTime>();
Check.That(stateValue.SentinelName).IsNotEmpty();
Check.That(stateValue.PackageName).IsNotEmpty();
Check.That(stateValue.Name).IsNotEmpty();
}
public async Task <StateValueKey> Send(string sentinelName, string packageName, string name, object value)
{
var typeOfValue = value.GetType().GetTypeOfValue();
var stateValue = new StateValue(sentinelName, packageName, name, value, typeOfValue);
using (var client = new HomeConnectionClient(HomeHubConnection))
{
return(await client.PostAsJson <StateValueKey>("statesvalues", stateValue));
}
}
public void AddStateValue(StateValue stateValue)
{
var stateValueKey = CreateKeyForStateValue(stateValue);
if (_stateValues.ContainsKey(stateValueKey))
{
throw new StateValueNotUniqueException();
}
_stateValues.AddOrUpdate(stateValueKey, stateValue, (key, value) => value);
AddingStateValue?.Invoke(stateValueKey);
}
public async Task <JObject> GetDbValue(string key)
{
string type = string.Empty;
JToken id;
try
{
object value;
if (key.StartsWith(GlobalConfig.StatePrefix))
{
type = "State";
id = key.Substring(GlobalConfig.StatePrefix.Length, key.Length - GlobalConfig.StatePrefix.Length);
var valueBytes = KeyValueDatabase.GetAsync(type, key).Result;
value = StateValue.Create(valueBytes);
}
else if (key.StartsWith(GlobalConfig.TransactionReceiptPrefix))
{
type = "TransactionReceipt";
id = key.Substring(GlobalConfig.TransactionReceiptPrefix.Length, key.Length - GlobalConfig.TransactionReceiptPrefix.Length);
var valueBytes = KeyValueDatabase.GetAsync(type, key).Result;
value = valueBytes?.Deserialize <TransactionReceipt>();
}
else
{
var keyObj = Key.Parser.ParseFrom(ByteArrayHelpers.FromHexString(key));
type = keyObj.Type;
id = JObject.Parse(keyObj.ToString());
var valueBytes = KeyValueDatabase.GetAsync(type, key).Result;
var obj = this.GetInstance(type);
obj.MergeFrom(valueBytes);
value = obj;
}
var response = new JObject
{
["Type"] = type,
["Id"] = id,
["Value"] = JObject.Parse(value.ToString())
};
return(JObject.FromObject(response));
}
catch (Exception e)
{
var response = new JObject
{
["Type"] = type,
["Value"] = e.Message
};
return(JObject.FromObject(response));
}
}
protected void Start()
{
foreach (var item in EnumUtils.EnumValues <Item>())
{
if (item == Item.None)
{
continue;
}
worldData[item.ToString()] = new StateValue(container.items[item]);
}
worldData["hasTool"] = new StateValue(container.tool != null);
}
public void SetDefaultWorksAsExpected()
{
StateValue <Guid> stateValue = new StateValue <Guid>();
stateValue.Value = Guid.NewGuid();
Assert.AreNotEqual(GetDefault <Guid>(), stateValue.Value);
stateValue.SetDefault();
Assert.AreEqual(GetDefault <Guid>(), stateValue.Value);
}
protected override void Awake()
{
state ["searchedHere"] = new StateValue(false);
foreach (Item item in possibleItemsInPile)
{
bool val = RandomUtils.RandBool(0.2f);
int number = val ? 1 : 0;
state[item.ToString()] = new StateValue(number);
Debug.LogError(val);
}
base.Awake();
}
public Move DoSomething(GameState state)
{
Move selectedMove = null;
var rnd = _rnd.NextDouble();
var currentState = States.FirstOrDefault(x => x.State.Equals(state.ToString()));
if (currentState == null)
{
currentState = new StateValue {
State = state.ToString(), Value = 0.5
};
States.Add(currentState);
}
var allMoves = state.GetAllMoves();
if (rnd < _learn)
{
selectedMove = allMoves[_rnd.Next(allMoves.Count())];
return(selectedMove);
}
var possibleStates = new List <StateValue>();
foreach (var move in allMoves)
{
var newState = state.MakeMove(move);
var newStateString = newState.ToString();
var found = States.FirstOrDefault(x => x.State.Equals(newStateString));
if (found == null)
{
PieceColor winner;
var value = newState.HasWinner(out winner) ? winner == PieceColor.White ? 1 : 0 : 0.5;
found = new StateValue
{
State = newStateString,
Value = value,
};
States.Add(found);
}
found.Move = move;
possibleStates.Add(found);
}
var bestState = possibleStates.OrderByDescending(x => x.Value).First();
currentState.Value = (currentState.Value + bestState.Value) / 2;
return(bestState.Move);
}
protected override void Awake()
{
base.Awake();
foreach (var item in EnumUtils.EnumValues <Item>())
{
if (item == Item.None)
{
continue;
}
state[item.ToString()] = new StateValue(backpack.items[item]);
}
state["hasTool"] = new StateValue(backpack.tool != null);
}
static StateValue Cast(ParameterType type, StateValue value)
{
switch (type)
{
case ParameterType.Signal: return(new StateValue(value.ToDateTime()));
case ParameterType.Bool: return(new StateValue(value.ToBool()));
case ParameterType.Integer: return(new StateValue(value.ToInt()));
case ParameterType.Float: return(new StateValue(value.ToFloat()));
default: throw new NotImplementedException();
}
}
IEnumerable <string> RunLogic(Logic logic, ItemId itemId, StateValue signal)
{
var updatedKeys = new Queue <string>();
foreach (var statement in logic.Statements)
{
if (statement == null)
{
continue;
}
RunStatement(statement, itemId, updatedKeys, signal);
}
return(updatedKeys);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (!(value is StateValue))
{
throw ArgumentException("value not of type StateValue");
}
StateValue sv = (StateValue)value;
//sanity checks
if (sv == StateValue.Player)
{
return(Colors.Red);
}
//etc
}
public override State GetState()
{
foreach (var item in EnumUtils.EnumValues <Item>())
{
if (item == Item.None)
{
continue;
}
state[item.ToString()].value = backpack.items[item];
}
state["x"] = new StateValue(transform.position.x);
state["y"] = new StateValue(transform.position.y);
return(state);
}
public void SetGlobalValueString(string name, string val, bool persistent)
{
if (mGlobalStates == null)
{
mGlobalStates = new Dictionary <string, StateValue>();
}
bool isValueSet = false;
StateValue curVal;
if (mGlobalStates.TryGetValue(name, out curVal))
{
if (curVal.type == Type.String)
{
isValueSet = curVal.sval != val;
if (isValueSet)
{
curVal.sval = val;
mGlobalStates[name] = curVal;
}
}
else
{
isValueSet = true;
mGlobalStates[name] = curVal = new StateValue(val);
}
}
else
{
isValueSet = true;
mGlobalStates.Add(name, curVal = new StateValue(val));
}
if (isValueSet)
{
if (persistent)
{
string key = string.Format(GlobalDataFormat, name);
UserData.main.SetString(key, val);
}
if (onValueChange != null)
{
onValueChange(true, name, curVal);
}
}
}
public void InitializeState([StateDependency("CurrentCustomer")] StateValue<Customer> currentCustomerState,
[StateDependency("Customers")] StateValue<List<Customer>> customersState)
{
_currentCustomer = currentCustomerState;
_customers = customersState;
}
private LineStateMap AngleStateValueMap(StateValue val, string name,string format="{0:0}",string missing="?")
{
return new LineStateMap (s => {
if (s.StateValues.ContainsKey (val)) {
double angle = s.StateValues [val];
//show "left" angles as negative
if (angle > 180) {
angle = angle - 360;
}
return string.Format (format, angle);
} else {
return missing;
}
}
,name);
}
private LineStateMap StateValueMap(StateValue val, string name,string format="{0:0.0}",string missing="")
{
return new LineStateMap (s=>s.StateValues.ContainsKey(val) ? string.Format(format,s.StateValues[val]) : missing,name);
}
public void InitializeState([StateDependency("CurrentOrder")]StateValue<Order> orderState)
{
_currentOrder = orderState;
}
private CustomersController GetCustomersControllerInitialized(INavigationService navigationService, List<Customer> customers)
{
CustomersController controller = new CustomersController(navigationService);
StateValue<Customer> currentCustomerState = new StateValue<Customer>();
StateValue<List<Customer>> customersState = new StateValue<List<Customer>>(customers);
controller.InitializeState(currentCustomerState, customersState);
return controller;
}
public SampleClass([StateDependency("stringKey")] StateValue<string> myStringValue)
{
_myStringValue = myStringValue;
}
public void Set(string key, bool value)
{
StateValue stateValue = new StateValue();
stateValue.Active = true;
stateValue.Type = StateValue.ValueType.Bool;
stateValue.Value.BoolValue = value;
_stateValues[key] = stateValue;
}
public void Set(string key, Point value)
{
StateValue stateValue = new StateValue();
stateValue.Active = true;
stateValue.Type = StateValue.ValueType.Point;
stateValue.Value.PointValue = value;
_stateValues[key] = stateValue;
}
