/// <summary>
/// Sprawdza, czy decyzja jest zwycieska
/// </summary>
/// <param name="mine"></param>
/// <param name="opponet"></param>
/// <returns></returns>
public static int Score(this Decision mine, Decision opponet)
{
if (mine == opponet)
return 0;
switch (mine)
{
case Decision.Rock:
if (opponet == Decision.Paper)
return -1;
else return 1;
case Decision.Paper:
if (opponet == Decision.Scissor)
return -1;
else
return 1;
case Decision.Scissor:
if (opponet == Decision.Rock)
return -1;
else
return 1;
default:
return 0;
}
}
static void Main(string[] args)
{
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
// ------------
// Parameters
Set city = new Set(Domain.IntegerNonnegative, "city");
Parameter dist = new Parameter(Domain.Real, "dist", city, city);
var arcs = from p1 in data
from p2 in data
select new Arc { City1 = p1.Name, City2 = p2.Name, Distance = p1.Distance(p2) };
dist.SetBinding(arcs, "Distance", "City1", "City2");
model.AddParameters(dist);
// ------------
// Decisions
Decision assign = new Decision(Domain.IntegerRange(0, 1), "assign", city, city);
Decision rank = new Decision(Domain.RealNonnegative, "rank", city);
model.AddDecisions(assign, rank);
// ------------
// Goal: minimize the length of the tour.
Goal goal = model.AddGoal("TourLength", GoalKind.Minimize,
Model.Sum(Model.ForEach(city, i => Model.ForEachWhere(city, j => dist[i, j] * assign[i, j], j => i != j))));
// ------------
// Enter and leave each city only once.
int N = data.Length;
model.AddConstraint("assign1",
Model.ForEach(city, i => Model.Sum(Model.ForEachWhere(city, j => assign[i, j],
j => i != j)) == 1));
model.AddConstraint("assign2",
Model.ForEach(city, j => Model.Sum(Model.ForEachWhere(city, i => assign[i, j], i => i != j)) == 1));
// Forbid subtours (Miller, Tucker, Zemlin - 1960...)
model.AddConstraint("no_subtours",
Model.ForEach(city,
i => Model.ForEachWhere(city,
j => rank[i] + 1 <= rank[j] + N * (1 - assign[i, j]),
j => Model.And(i != j, i >= 1, j >= 1)
)
)
);
Solution solution = context.Solve();
// Retrieve solution information.
Console.WriteLine("Cost = {0}", goal.ToDouble());
Console.WriteLine("Tour:");
var tour = from p in assign.GetValues() where (double)p[0] > 0.9 select p[2];
foreach (var i in tour.ToArray())
{
Console.Write(i + " -> ");
}
Console.WriteLine();
Console.WriteLine("Press enter to continue...");
Console.ReadLine();
}
public static double[] d2d(Decision[] d)
{
var result = new double[d.Length];
for (int i = 0; i < d.Length; i++)
result[i] = d[i].ToDouble();
return result;
}
static void Main(string[] args)
{
//4.1)
SimpleActivity greaterThan100Activity = new SimpleActivity(()=>Console.WriteLine("Value is greater than 100."));
//4.2)
SimpleActivity lessThan100Activity = new SimpleActivity(()=>Console.WriteLine("Value is less than 100."));
//3.)
Decision<int> greaterOrLess100Decision = new Decision<int>(multipliedValue => multipliedValue > 100, greaterThan100Activity, lessThan100Activity);
//2.)
InputOutputActivity<int,int> mutiplyBy10Activity = new InputOutputActivity<int, int>(inputValue => inputValue * 10, greaterOrLess100Decision);
//1.)
OutputActivity<int> getInputValueActivity = new OutputActivity<int>(()=>
{
Console.Write("Please type in value:");
var input = Console.ReadLine();
return Convert.ToInt32(input);
}, mutiplyBy10Activity);
WorkflowEngine engine = new WorkflowEngine();
engine.WorkflowProgressChanged += (arg1, arg2, arg3, arg4) => Console.WriteLine("Step:{0}\r\nContext:{1}\r\nSuccess:{2}\r\nException message:{3}", arg1, arg2, arg3, arg4 != null ? arg4.Message : string.Empty);
engine.WorkflowCompleted += (arg1, arg2) => Console.WriteLine("Completed:\r\nSucceeded:{0}\r\nException message:{1}", arg1, arg2 != null ? arg2.Message : string.Empty);
engine.Run(getInputValueActivity);
Console.ReadLine();
engine.Dispose();
}
public WinByPointsPrediction(Decision by, Boxer winner, PlayerPrediction playerPrediction)
{
By = by;
Winner = winner;
Type = "WinByPointsPrediction";
PlayerPrediction = playerPrediction;
}
public override Decision Decide(IEntityRecord opponent)
{
Decision trick = Decision.Undecided;
Outcome outcome = Outcome.Unknown;
int retries = 0;
int maxRetries = 5;
while (outcome == Outcome.Unknown || outcome == Outcome.Loss) {
// pick any hand and use it to see how opponent would react
// > note that it must have some amount of influence to be considered a real decision
trick = Decision.Next(1);
Decision reaction = new Decision();
foreach (Behavior behavior in opponent.GetComponents().OfType<Behavior>()) {
reaction += behavior.React(Record, trick);
}
outcome = trick.DetermineOutcome(reaction);
if (retries++ > maxRetries) {
break;
}
}
// > note that we do not use Decision.Counter on the reaction that resulted in a win, because
// it was actually the trick hand that caused the win
return Decision.Distribute(
trick.MostInfluencedHand, Influence);
}
/// <summary>
/// Initializes a new instance of the <see cref="DecisionTree"/> class.
/// </summary>
/// <param name="_decisions">_decisions.</param>
/// <param name="_actions">_actions.</param>
/// <param name="_callback">_callback.</param>
public DecisionTree(Decision[] _decisions, TreeAction[] _actions, Action<TreeAction> _callback)
{
decisions = _decisions;
actions = _actions;
callback = _callback;
doneEvent = new ManualResetEvent(true);
}
/// <summary>
/// Gets the decision that has occured later in time.
/// </summary>
public static Decision GetNewer(Decision a, Decision b)
{
if (a == null)
return b;
if (b == null)
return a;
return a.time > b.time ? a : b;
}
public bool Transfer(Guid competitionId, Decision decision)
{
var competition = this.repository.Get(competitionId);
if (competition == null) return false;
if (!this.stateService.CanUpdateResult(competition)) return false;
competition.RegisterWin(decision.Winner);
competition.RegisterLoss(decision.Looser);
return this.repository.Update(competition);
}
//public GameObject gameLogic;
// Use this for initialization
void Start () {
gameState = FindObjectOfType<PersistantState>();
currentDecision = gameState.Decisions[gameState.Stage];
textDay.text = string.Format("Day {0}", gameState.Stage + 1);
textQuery.text = currentDecision.query;
buttonAlternative1.GetComponentInChildren<Text>().text = currentDecision.alternatives[0];
buttonAlternative1.onClick.AddListener(delegate { onClick(0); });
buttonAlternative2.GetComponentInChildren<Text>().text = currentDecision.alternatives[1];
buttonAlternative2.onClick.AddListener(delegate { onClick(1); });
}
public override Decision React(IEntityRecord opponent, Decision decision)
{
Decision counter = Decision.Win(decision, Influence);
Hand choices =
counter.MostInfluencedHand |
decision.MostInfluencedHand;
return Decision.Next(
choices, Influence * 2);
}
public Decision[,] BuildDecisions()
{
for (int i = 0; i < Decisions.GetLength(0); i++)
{
for (int j = 0; j < Decisions.GetLength(1); j++)
{
Decisions[i, j] = new Decision(domain, "_" + i + "Decision" + j);
}
}
return Decisions;
}
public override Decision React(IEntityRecord opponent, Decision decision)
{
Decision reaction = Decision.Undecided;
History opponentHistory = opponent.GetComponent<History>();
if (opponentHistory != null) {
reaction = opponentHistory.PreviousDecision;
}
return Decision.Distribute(
reaction.MostInfluencedHand, Influence);
}
public bool MakeDecision(Guid sessionId, Decision decision)
{
var session = Get(sessionId);
if (session == null) return false;
if (session.IsClosed) return false;
var operationChecker = new OperationChecker(this.competitionRepository);
var gateway = new DecisionGateway(this.competitionRepository, operationChecker);
session.RegisterDecision(decision, gateway);
this.unitOfWork.Commit();
return true;
}
public void RegisterDecision(Decision decision, IDecisionGateway gateway)
{
if (this.IsClosed) return;
var duel = decision.Duel;
AssertScheduleContainsDuel(duel);
AssertDecisionIsNotRegisteredYet(duel);
this.Outcomes.Add(new Outcome(decision));
this.Schedule.Remove(duel);
gateway.Transfer(this.CompetitionId, decision);
}
/*
* Init method allow to pass a title and message that will be displayed to the user,
* and also a decision delegate
*/
public void init(string title, string message, Decision dec)
{
this.title.text = title;
this.message.text = message;
cancel.onClick.AddListener(delegate {
gameObject.SetActive(false);
dec(false);
});
ok.onClick.AddListener(delegate {
gameObject.SetActive(false);
dec(true);
});
gameObject.SetActive (true);
}
/// <summary>
/// Aktualizuje wejscia po kolejnej rundzie gry
/// </summary>
/// <param name="AIDecision">własna decyzja</param>
/// <param name="opponentDecision">decyzja przeciwnika</param>
public void updateInputs(Decision AIDecision, Decision opponentDecision )
{
//przesuwamy wejscia w prawo
double[] oldInputs = new double[inputs.Length];
inputs.CopyTo(oldInputs, 0);
for (int j = 3; j < inputs.Length; ++j)
inputs[j] = oldInputs[j - 3];
//dopisujemy nowe wejscia
for (int j = 0; j < 3; ++j)
{
inputs[j] = AIDecision.ToNeural()[j];
inputs[j + inputs.Length / 2] = opponentDecision.ToNeural()[j];
}
}
/// <summary>
/// Creates a new Result using the provided information.
/// </summary>
/// <param name="resourceId">The resource id for this result.</param>
/// <param name="decision">The decission of the evaluation.</param>
/// <param name="status">The status with information about the execution.</param>
/// <param name="obligations">The list of obligations</param>
/// <param name="schemaVersion">The version of the schema that was used to validate.</param>
public ResultElement(string resourceId, Decision decision, StatusElement status, ObligationCollection obligations, XacmlVersion schemaVersion)
: base(XacmlSchema.Context, schemaVersion)
{
_resourceId = resourceId;
Decision = decision;
// If the status is null, create an empty status
Status = status ?? new StatusElement(null, null, null, schemaVersion);
// If the obligations are null, leave the empty ObligationCollection.
if (obligations != null)
{
_obligations = obligations;
}
}
public void scoreRound(Decision playerDecision)
{
var opponentDecision = decisionMaker.getNextDecision();
int score = playerDecision.Score(opponentDecision);
if (score == -1)
opponentScore += 1;
else if (score == 1)
playerScore += 1;
ScoreLabel.Content = playerScore + " : " + opponentScore;
HistoryTextBox.Text = "Ty: " + playerDecision.toLocalString() + ", przeciwnik: " + opponentDecision.toLocalString();
decisionMaker.rememberDecision(playerDecision);
}
private void sendDecision(Decision decision)
{
BroadcastMessage("Decision", decision);
if(decision == Decision.left){
currentHorizontal--;
}
if(decision == Decision.right){
currentHorizontal++;
}
if(decision == Decision.up){
currentVertical++;
}
if(decision == Decision.down){
currentVertical--;
}
}
/// <summary>
/// Funkcja odpowiedzialna za proces nauki
/// </summary>
/// <param name="AIDecision">decyzja podjeta przez siec</param>
/// <param name="opponentDecision">decyzja przeciwnika</param>
public void updateWeights(Decision AIDecision, Decision opponentDecision)
{
Decision expectedDecision = opponentDecision.GetCounter(); //decyzja, ktora powinnismy podjac
if (expectedDecision == AIDecision)
return; //i tak sie wagi nie zmienia, wiec konczymy funkcje od razu
double[] desiredOutput = expectedDecision.ToNeural();
double[] currentOutput = AIDecision.ToNeural();
for (int i = 0; i < outputs.Length; ++i)
{
double diff = (desiredOutput[i] - currentOutput[i]) * learningRate; //obliczamy poprawke
for (int j = 0; j < inputs.Length; ++j)
weights[i, j] += diff * inputs[j]; //wprowadzamy poprawke do wag sieci
}
if (minLearningRate < learningRate - learnigEnstinguishRate)
learningRate -= learnigEnstinguishRate;
}
private void TestService1(Directive directive)
{
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
Decision x1 = new Decision(Domain.RealRange(0, 2), "x1");
Decision x2 = new Decision(Domain.RealRange(0, 2), "x2");
Decision z = new Decision(Domain.IntegerRange(0, 1), "z");
model.AddDecisions(x1, x2, z);
model.AddConstraint("Row0", x1 - z <= 1);
model.AddConstraint("Row1", x2 + z <= 2);
Goal goal = model.AddGoal("Goal0", GoalKind.Maximize, x1 + x2);
Solution solution = context.Solve(directive);
Assert.IsTrue(goal.ToInt32() == 3);
context.ClearModel();
}
List <Decision> Decide(DecisionTask task)
{
try
{
List <Decision> decisions = new List <Decision>();
var startEvent = task.Events.FirstOrDefault(x => x.EventType == EventType.WorkflowExecutionStarted);
if (startEvent != null)
{
var pollId = startEvent.WorkflowExecutionStartedEventAttributes.Input;
Logger.LogMessage("Processing decision task for poll id: " + pollId);
var poll = PollProcessor.Instance.GetPollAsync(pollId).Result;
if (poll != null)
{
if (poll.State == PollDefinition.POLL_STATE_UNSCHEDULE && DateTime.Now < poll.StartTime)
{
// Add second to compensate for the rounding
var timeDelay = (int)(new TimeSpan(poll.StartTime.Ticks - DateTime.Now.Ticks).TotalSeconds) + 1;
var decision = new Decision
{
DecisionType = DecisionType.StartTimer,
StartTimerDecisionAttributes = new StartTimerDecisionAttributes
{
StartToFireTimeout = timeDelay.ToString(),
TimerId = Guid.NewGuid().ToString()
}
};
decisions.Add(decision);
PollProcessor.Instance.UpdatePollStateAsync(pollId, PollDefinition.POLL_STATE_SCHEDULE).Wait();
Logger.LogMessage("Scheduled timer for {0} seconds till activating poll.", timeDelay);
}
else if (poll.State == PollDefinition.POLL_STATE_SCHEDULE)
{
Decision decision = new Decision()
{
DecisionType = DecisionType.ScheduleActivityTask,
ScheduleActivityTaskDecisionAttributes = new ScheduleActivityTaskDecisionAttributes()
{
ActivityType = new ActivityType()
{
Name = Constants.SWF_ACTIVTY_START_TIMER_EXPIRED,
Version = Constants.SWF_ACTIVTY_START_TIMER_EXPIRED_VERSION
},
TaskList = new TaskList
{
Name = Constants.SWF_ACTIVTY_START_TIMER_EXPIRED_TASKLIST
},
HeartbeatTimeout = Constants.SWF_TIMEOUT,
ScheduleToCloseTimeout = Constants.SWF_TIMEOUT,
ScheduleToStartTimeout = Constants.SWF_TIMEOUT,
StartToCloseTimeout = Constants.SWF_TIMEOUT,
ActivityId = string.Format("{0}:{1}", Constants.SWF_ACTIVTY_START_TIMER_EXPIRED, DateTime.Now.Ticks),
Input = poll.Id
}
};
decisions.Add(decision);
Logger.LogMessage("Start timer complete now deciding to run the {0} activity to activate poll.", Constants.SWF_ACTIVTY_START_TIMER_EXPIRED);
}
else if (poll.State == PollDefinition.POLL_STATE_ACTIVE && DateTime.Now < poll.EndTime)
{
// Add second to compensate for the rounding
var timeDelay = (int)(new TimeSpan(poll.EndTime.Ticks - DateTime.Now.Ticks).TotalSeconds) + 1;
var decision = new Decision
{
DecisionType = DecisionType.StartTimer,
StartTimerDecisionAttributes = new StartTimerDecisionAttributes
{
StartToFireTimeout = timeDelay.ToString(),
TimerId = Guid.NewGuid().ToString()
}
};
decisions.Add(decision);
Logger.LogMessage("Scheduled timer for {0} seconds till poll expires.", timeDelay);
}
else if (poll.State == PollDefinition.POLL_STATE_ACTIVE)
{
Decision decision = new Decision()
{
DecisionType = DecisionType.ScheduleActivityTask,
ScheduleActivityTaskDecisionAttributes = new ScheduleActivityTaskDecisionAttributes()
{
ActivityType = new ActivityType()
{
Name = Constants.SWF_ACTIVTY_END_TIMER_EXPIRED,
Version = Constants.SWF_ACTIVTY_END_TIMER_EXPIRED_VERSION
},
TaskList = new TaskList
{
Name = Constants.SWF_ACTIVTY_END_TIMER_EXPIRED_TASKLIST
},
HeartbeatTimeout = Constants.SWF_TIMEOUT,
ScheduleToCloseTimeout = Constants.SWF_TIMEOUT,
ScheduleToStartTimeout = Constants.SWF_TIMEOUT,
StartToCloseTimeout = Constants.SWF_TIMEOUT,
ActivityId = string.Format("{0}:{1}", Constants.SWF_ACTIVTY_END_TIMER_EXPIRED, DateTime.Now.Ticks),
Input = poll.Id
}
};
decisions.Add(decision);
Logger.LogMessage("End timer complete now deciding to run the {0} activity to expire poll.", Constants.SWF_ACTIVTY_END_TIMER_EXPIRED);
}
}
}
if (decisions.Count == 0)
{
Decision decision = new Decision()
{
DecisionType = DecisionType.CompleteWorkflowExecution,
CompleteWorkflowExecutionDecisionAttributes = new CompleteWorkflowExecutionDecisionAttributes
{
}
};
decisions.Add(decision);
Logger.LogMessage("Workflow execution complete for {0}", task.WorkflowExecution.WorkflowId);
}
return(decisions);
}
catch (Exception e)
{
string message = string.Format("Error processing work flow execution {0} and is being aborted: {1}\n", task.WorkflowExecution.WorkflowId, e.Message, e.StackTrace);
Logger.LogMessage(message);
Decision decision = new Decision()
{
DecisionType = DecisionType.CompleteWorkflowExecution,
CompleteWorkflowExecutionDecisionAttributes = new CompleteWorkflowExecutionDecisionAttributes
{
Result = message
}
};
return(new List <Decision> {
decision
});
}
}
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria)
{
if (searchCriteria != null && searchCriteria.UserInvokedSearch)
{
_logger.Debug("Ignoring delay for user invoked search");
return(Decision.Accept());
}
var profile = subject.Series.Profile.Value;
var delayProfile = _delayProfileService.BestForTags(subject.Series.Tags);
var delay = delayProfile.GetProtocolDelay(subject.Release.DownloadProtocol);
var isPreferredProtocol = subject.Release.DownloadProtocol == delayProfile.PreferredProtocol;
if (delay == 0)
{
_logger.Debug("Profile does not require a waiting period before download for {0}.", subject.Release.DownloadProtocol);
return(Decision.Accept());
}
var comparer = new QualityModelComparer(profile);
if (isPreferredProtocol)
{
foreach (var file in subject.Episodes.Where(c => c.EpisodeFileId != 0).Select(c => c.EpisodeFile.Value))
{
var upgradable = _qualityUpgradableSpecification.IsUpgradable(profile, file.Quality, subject.ParsedEpisodeInfo.Quality);
if (upgradable)
{
var revisionUpgrade = _qualityUpgradableSpecification.IsRevisionUpgrade(file.Quality, subject.ParsedEpisodeInfo.Quality);
if (revisionUpgrade)
{
_logger.Debug("New quality is a better revision for existing quality, skipping delay");
return(Decision.Accept());
}
}
}
}
// If quality meets or exceeds the best allowed quality in the profile accept it immediately
var bestQualityInProfile = new QualityModel(profile.LastAllowedQuality());
var isBestInProfile = comparer.Compare(subject.ParsedEpisodeInfo.Quality, bestQualityInProfile) >= 0;
if (isBestInProfile && isPreferredProtocol)
{
_logger.Debug("Quality is highest in profile for preferred protocol, will not delay");
return(Decision.Accept());
}
// var episodeIds = subject.Episodes.Select(e => e.Id);
//var oldest = _pendingReleaseService.OldestPendingRelease(subject.Series.Id, episodeIds);
//if (oldest != null && oldest.Release.AgeMinutes > delay)
//{
// return Decision.Accept();
//}
if (subject.Release.AgeMinutes < delay)
{
_logger.Debug("Waiting for better quality release, There is a {0} minute delay on {1}", delay, subject.Release.DownloadProtocol);
return(Decision.Reject("Waiting for better quality release"));
}
return(Decision.Accept());
}
public void DecisionFunctionTest()
{
BusinessRuleTask ruleTask = new BusinessRuleTask();
ruleTask.BusinessRule = new Definitions();
var decision = new Decision();
decision.Id = "decision_kowu89q";
decision.DecisionTable.HitPolicy = "COLLECT";
decision.DecisionTable.Aggregation = "SUM";
decision.DecisionTable.Inputs.Add(new DecisionTableInput()
{
InputExpression = new InputExpression()
{
Text = "person.age",
TypeRef = "number"
}
});
decision.DecisionTable.Inputs.Add(new DecisionTableInput()
{
InputExpression = new InputExpression()
{
Text = "person.name",
TypeRef = "string"
}
});
decision.DecisionTable.Inputs.Add(new DecisionTableInput()
{
InputExpression = new InputExpression()
{
Text = "person.dateOfBirth",
TypeRef = "date"
}
});
decision.DecisionTable.Outputs.Add(new DecisionTableOutput()
{
Name = "categoryOne",
TypeRef = "number"
});
decision.DecisionTable.Outputs.Add(new DecisionTableOutput()
{
Name = "categoryTwo",
TypeRef = "number"
});
var rule1 = new DecisionTableRule();
rule1.InputEntries.Add(new InputEntry()
{
Text = "18"
});
rule1.InputEntries.Add(new InputEntry()
{
Text = "\"Paul\""
});
rule1.InputEntries.Add(new InputEntry()
{
Text = string.Empty
});
rule1.OutputEntries.Add(new OutputEntry()
{
Text = "5"
});
rule1.OutputEntries.Add(new OutputEntry()
{
Text = "6"
});
decision.DecisionTable.Rules.Add(rule1);
var rule2 = new DecisionTableRule();
rule2.InputEntries.Add(new InputEntry()
{
Text = "> 18"
});
rule2.InputEntries.Add(new InputEntry()
{
Text = "\"Peter\""
});
rule2.InputEntries.Add(new InputEntry()
{
Text = string.Empty
});
rule2.OutputEntries.Add(new OutputEntry()
{
Text = "3"
});
rule2.OutputEntries.Add(new OutputEntry()
{
Text = "4"
});
decision.DecisionTable.Rules.Add(rule2);
var rule3 = new DecisionTableRule();
rule3.InputEntries.Add(new InputEntry()
{
Text = string.Empty
});
rule3.InputEntries.Add(new InputEntry()
{
Text = string.Empty
});
rule3.InputEntries.Add(new InputEntry()
{
Text = "> date(\"2000 - 01 - 01\")"
});
rule3.OutputEntries.Add(new OutputEntry()
{
Text = "1"
});
rule3.OutputEntries.Add(new OutputEntry()
{
Text = "2"
});
decision.DecisionTable.Rules.Add(rule3);
var rule4 = new DecisionTableRule();
rule4.InputEntries.Add(new InputEntry()
{
Text = string.Empty
});
rule4.InputEntries.Add(new InputEntry()
{
Text = string.Empty
});
rule4.InputEntries.Add(new InputEntry()
{
Text = string.Empty
});
rule4.OutputEntries.Add(new OutputEntry()
{
Text = "0"
});
rule4.OutputEntries.Add(new OutputEntry()
{
Text = "0"
});
decision.DecisionTable.Rules.Add(rule4);
ruleTask.BusinessRule.Decisions.Add(decision);
BusinessRuleTaskConverter ruleConverter = new BusinessRuleTaskConverter(ruleTask, null);
foreach (var decisionRC in ruleConverter.BusinessRuleTaskElement.BusinessRule.Decisions)
{
var decisionConverter = new DecisionConverter(decisionRC);
decisionConverter.ConvertElementLogic();
ruleConverter.DecisionConverters.Add(decisionConverter);
}
string given = string.Empty;
var components = new List <SolidityComponent>();
foreach (var decisionConverter in ruleConverter.DecisionConverters)
{
components.AddRange(decisionConverter.GetGeneratedSolidityComponents());
}
foreach (var component in components)
{
given += $"{component.ToString()}\n";
}
string expected = "struct Decision_kowu89qOutput{\n" +
"\tint categoryOne;\n" +
"\tint categoryTwo;\n" +
"}\n" +
"\n" +
"function decision_kowu89q() internal view returns(Decision_kowu89qOutput memory){\n" +
"\tDecision_kowu89qOutput memory output;\n" +
"\tbool matchedRule = false;\n" +
"\tif(person.age == 18 && keccak256(abi.encodePacked(person.name)) == keccak256(abi.encodePacked(\"Paul\"))){\n" +
"\t\toutput.categoryOne += 5;\n" +
"\t\toutput.categoryTwo += 6;\n" +
"\t\tmatchedRule = true;\n" +
"\t}\n" +
"\tif(person.age > 18 && keccak256(abi.encodePacked(person.name)) == keccak256(abi.encodePacked(\"Peter\"))){\n" +
"\t\toutput.categoryOne += 3;\n" +
"\t\toutput.categoryTwo += 4;\n" +
"\t\tmatchedRule = true;\n" +
"\t}\n" +
"\tif(person.dateOfBirth > 20000101){\n" +
"\t\toutput.categoryOne += 1;\n" +
"\t\toutput.categoryTwo += 2;\n" +
"\t\tmatchedRule = true;\n" +
"\t}\n" +
"\toutput.categoryOne += 0;\n" +
"\toutput.categoryTwo += 0;\n" +
"\tmatchedRule = true;\n" +
"\tif(!matchedRule){\n" +
"\t\trevert('Undefined output');\n" +
"\t}\n" +
"\treturn output;\n" +
"}\n\n";
Assert.Equal(expected, given);
}
/// <summary>
/// Called when a acknowledge message is received from the client
/// </summary>
internal async Task AcknowledgeDelivered(MqClient from, TmqMessage deliveryMessage)
{
MessageDelivery delivery = TimeKeeper.FindAndRemoveDelivery(from, deliveryMessage.MessageId);
//when server and consumer are in pc,
//sometimes consumer sends ack before server start to follow ack of the message
//that happens when ack message is arrived in less than 0.01ms
//in that situation, server can't find the delivery with FindAndRemoveDelivery, it returns null
//so we need to check it again after a few milliseconds
if (delivery == null)
{
await Task.Delay(1);
delivery = TimeKeeper.FindAndRemoveDelivery(from, deliveryMessage.MessageId);
//try again
if (delivery == null)
{
await Task.Delay(3);
delivery = TimeKeeper.FindAndRemoveDelivery(from, deliveryMessage.MessageId);
}
}
bool success = true;
if (deliveryMessage.Length > 0 && deliveryMessage.Content != null)
{
string msg = deliveryMessage.Content.ToString();
if (msg.Equals("FAILED", StringComparison.InvariantCultureIgnoreCase) || msg.Equals("TIMEOUT", StringComparison.InvariantCultureIgnoreCase))
{
success = false;
}
}
if (delivery != null)
{
delivery.MarkAsAcknowledged(success);
}
if (success)
{
Info.AddAcknowledge();
}
else
{
Info.AddUnacknowledge();
}
Decision decision = await DeliveryHandler.AcknowledgeReceived(this, deliveryMessage, delivery, success);
if (delivery != null)
{
if (Options.HideClientNames)
{
deliveryMessage.SetSource(null);
}
await ApplyDecision(decision, delivery.Message, deliveryMessage);
}
ReleaseAcknowledgeLock(true);
}
public async Task <PullResult> Pull(ChannelClient client, TmqMessage request)
{
QueueMessage message = null;
await _queue.RunInListSync(() =>
{
//pull from prefential messages
if (_queue.HighPriorityLinkedList.Count > 0)
{
message = _queue.HighPriorityLinkedList.First.Value;
_queue.HighPriorityLinkedList.RemoveFirst();
if (message != null)
{
message.IsInQueue = false;
}
}
//if there is no prefential message, pull from standard messages
if (message == null && _queue.RegularLinkedList.Count > 0)
{
message = _queue.RegularLinkedList.First.Value;
_queue.RegularLinkedList.RemoveFirst();
if (message != null)
{
message.IsInQueue = false;
}
}
});
//there is no pullable message
if (message == null)
{
await client.Client.SendAsync(MessageBuilder.ResponseStatus(request, KnownContentTypes.NotFound));
return(PullResult.Empty);
}
try
{
await ProcessPull(client, request, message);
}
catch (Exception ex)
{
_queue.Info.AddError();
try
{
Decision decision = await _queue.DeliveryHandler.ExceptionThrown(_queue, message, ex);
await _queue.ApplyDecision(decision, message);
if (decision.KeepMessage && !message.IsInQueue)
{
_queue.AddMessage(message, false);
}
}
catch //if developer does wrong operation, we should not stop
{
}
}
return(PullResult.Success);
}
/// <summary>
/// Deletes the decision.
/// </summary>
/// <param name="decision">The decision.</param>
/// <returns></returns>
public int DeleteDecision(Decision decision)
{
var result = _repositoryFactory.GetDecisionRepository.GetDecisionById(decision.Id);
return(_repositoryFactory.GetDecisionRepository.DeleteDecision(result));
}
partial void EditOverride(T4MVC_System_Web_Mvc_ActionResult callInfo, Decision.ViewModel.Role.EditRoleViewModel viewModel);
public override System.Threading.Tasks.Task<System.Web.Mvc.ActionResult> ListAjax(Decision.ViewModel.Role.RoleSearchRequest request)
{
var callInfo = new T4MVC_System_Web_Mvc_ActionResult(Area, Name, ActionNames.ListAjax);
ModelUnbinderHelpers.AddRouteValues(callInfo.RouteValueDictionary, "request", request);
ListAjaxOverride(callInfo, request);
return System.Threading.Tasks.Task.FromResult(callInfo as ActionResult);
}
/// <summary>
/// Reacts on an opponent's decision by always picking a losing hand.
/// </summary>
public override Decision React(IEntityRecord opponent, Decision decision)
{
return Decision.Loss(
decision, Influence);
}
// i've decided to make the node data it self viewable
public Info(Decision choices)
{
type = Type.Descision;
Data = choices;
}
protected override PatternResult <Overtrade?> ComputeByIndexImpl(int index)
{
var result = _rsiIndicator.ComputeByIndex(index);
return(new PatternResult <Overtrade?>(Equity[index].DateTime, Decision.IsOvertrade(result.Rsi)));
}
public Decision(Guard guard)
{
this.guard = guard;
this.trueNode = null;
this.falseNode = null;
}
public override Decision Next(Solver solver)
{
if (lastDecisionRoute1 == null || lastDecisionRoute2 == null)
{
ConstraintProblem.ConstraintModelNode[] startNodes =
(from node in csp.ModelNodes
where node.Route.Value() != 0 && node.NodeDescription.IsStart
select node).ToArray();
lastDecisionRoute1 = (from node in startNodes where node.Route.Value() == 1 select node).ToArray().First();
lastDecisionRoute2 = (from node in startNodes where node.Route.Value() == 2 select node).ToArray().First();
}
if (lastDecisionRoute1.NodeDescription.IsEnd &&
lastDecisionRoute2.NodeDescription.IsEnd)
{
return(null);
}
ConstraintProblem.ConstraintModelNode nextRoute1 = null;
ConstraintProblem.ConstraintModelNode nextRoute2 = null;
if (lastDecisionRoute1.Next.Bound())
{
nextRoute1 = csp.ModelNodes[lastDecisionRoute1.Next.Value()];
}
else
{
nextRoute1 = lastDecisionRoute1;
}
if (lastDecisionRoute2.Next.Bound())
{
nextRoute2 = csp.ModelNodes[lastDecisionRoute2.Next.Value()];
}
else
{
nextRoute2 = lastDecisionRoute2;
}
ConstraintProblem.ConstraintModelNode closestRoute1 = null;
ConstraintProblem.ConstraintModelNode closestRoute2 = null;
ConstraintProblem.ConstraintModelNode[] NextsFromNextNodes =
(from node in csp.ModelNodes
where nextRoute1.Next.Contains(node.Id) || nextRoute2.Next.Contains(node.Id)
orderby node.Id
select node).ToArray();
ConstraintProblem.ConstraintModelNode[] NextsFromNextNodeRoute1 =
(from node in NextsFromNextNodes
where node.Route.Value() == nextRoute1.Route.Value() && nextRoute1.Next.Contains(node.Id)
select node).ToArray();
ConstraintProblem.ConstraintModelNode[] NextsFromNextNodeRoute2 =
(from node in NextsFromNextNodes
where node.Route.Value() == nextRoute2.Route.Value() && nextRoute2.Next.Contains(node.Id)
select node).ToArray();
closestRoute1 = findClosestNode(nextRoute1, NextsFromNextNodeRoute1);
closestRoute2 = findClosestNode(nextRoute2, NextsFromNextNodeRoute2);
if (closestRoute1.NodeDescription.IsEnd)
{
lastDecisionRoute1 = closestRoute1;
}
else
{
lastDecisionRoute1 = nextRoute1;
}
if (closestRoute2.NodeDescription.IsEnd)
{
lastDecisionRoute2 = closestRoute2;
}
else
{
lastDecisionRoute2 = nextRoute2;
}
lastDecision = solver.MakeAssignVariablesValues(new IntVar[] { nextRoute1.Next, nextRoute2.Next }, new long[] { closestRoute1.Id, closestRoute2.Id });
return(lastDecision);
}
/// <summary>
/// 仿真机器鱼位姿到位姿镇定算法（位置坐标和方向弧度值） Modified by Zhangbo20111020
/// 场地坐标系定义为：X向右，Y向下，负X轴顺时针转回负X轴角度范围为(-PI,PI)的坐标系
/// </summary>
/// <param name="decision">决策变量 输出参数 会被修改</param>
/// <param name="fish">目标仿真机器鱼（其PositionMm/PolygonVertices[0]和BodyDirectionRad参数为起始位姿）</param>
/// <param name="destPtMm">目标位置坐标（目标点）</param>
/// <param name="destDirRad">目标方向弧度值（目标方向）</param>
/// <param name="angThreshold">关键调节参数（中间方向与鱼体方向度数差值绝对值）上限，默认30度</param>
/// <param name="disThreshold">关键调节参数（临时目标点与最终目标点距离）阈值</param>
/// <param name="msPerCycle">每个仿真周期的毫秒数，默认取100</param>
public static void PoseToPose(ref Decision decision, RoboFish fish, xna.Vector3 destPtMm, float destDirRad,
float angThreshold, float disThreshold, int msPerCycle, ref int times)
{
// 标志量为true则起始点为PositionMm即鱼体绘图中心false则起始点为PolygonVertices[0]即鱼头点（起始点）
xna.Vector3 srcPtMm = fish.PositionMm;
// 起始点到目标点的距离（目标距离）
double disSrcPtMmToDestPtMm = Math.Sqrt(Math.Pow(destPtMm.X - srcPtMm.X, 2.0)
+ Math.Pow(destPtMm.Z - srcPtMm.Z, 2.0));
// 沿目标方向的反方向偏离目标点阈值距离的临时目标点（临时目标点）
xna.Vector3 tmpPtMm = new xna.Vector3((float)(destPtMm.X - disThreshold * Math.Cos(destDirRad)),
0, (float)(destPtMm.Z - disThreshold * Math.Sin(destDirRad)));
double disSrcPtMmToTmpPtMm = Math.Sqrt(Math.Pow(tmpPtMm.X - srcPtMm.X, 2.0)
+ Math.Pow(tmpPtMm.Z - srcPtMm.Z, 2.0));
// 镇定阶段标志 1为远距离第一阶段2为近距离第二阶段
int phrase = 2;
if (disSrcPtMmToTmpPtMm > 0.2 * disThreshold && times == 0)
{// 起始点到临时目标点的距离大于阈值的20%，则认为尚未镇定到临时目标点，需要把目标点修正成临时目标点
destPtMm = tmpPtMm;
phrase = 1;
}
// 鱼体绘图中心指向目标点向量方向的弧度值（中间方向）
double dirFishToDestPtRad = xna.MathHelper.ToRadians((float)GetAngleDegree(destPtMm - fish.PositionMm));
// 中间方向与鱼体方向的差值（目标角度）
double deltaTheta = dirFishToDestPtRad - fish.BodyDirectionRad;
// 将目标角度规范化到(-PI,PI]
// 规范化之后目标角度为正，表示目标方向在鱼体方向右边
// 规范化之后目标角度为负，表示目标方向在鱼体方向左边
if (deltaTheta > Math.PI)
{ // 中间方向为正鱼体方向为负才可能目标角度大于PI
deltaTheta -= 2 * Math.PI; // 规范化到(-PI,0)
}
else if (deltaTheta < -Math.PI)
{ // 中间方向为负鱼体方向为正才可能目标角度小于-PI
deltaTheta += 2 * Math.PI; // 规范化到(0,PI)
}
if (Math.Abs(deltaTheta) > angThreshold * Math.PI / 180.0)
{// 目标角度绝对值超过某一阈值（默认30度）速度档位置次低进行小半径转弯。防止控制率过大。
//decision.VCode = 1;
//decision.TCode = (deltaTheta <= 0) ? 1 : 13;
decision.VCode = 2;
decision.TCode = (deltaTheta <= 0) ? 0 : 14;
}
else
{
if (phrase == 1)
{// 第一阶段（在阈值区域之外）镇定算法
times = 0;
//decision.VCode = (disSrcPtMmToTmpPtMm < 0.5 * disThreshold) ? 4 : 10;
//decision.VCode = 8;
decision.VCode = 10;
decision.TCode = 7;
float lamdadot = ((destPtMm.X - srcPtMm.X) * (fish.VelocityMmPs * (float)Math.Sin(fish.BodyDirectionRad))
- (-destPtMm.Z + srcPtMm.Z) * (fish.VelocityMmPs * (float)Math.Cos(fish.BodyDirectionRad)))
/ ((float)Math.Pow(destPtMm.X - srcPtMm.X, 2.0) + (float)Math.Pow(destPtMm.Z - srcPtMm.Z, 2.0));
double targetAngularV = 50 * lamdadot;
if (deltaTheta <= 0)
{ // 目标角度为负目标方向在鱼体方向左边需要给左转档位（注意左转档位对应的角速度值为负值）
while ((decision.TCode > 0) && (DataBasedOnExperiment.TCodeAndAngularVelocityTable[decision.TCode] > targetAngularV))
{ // 目标（转弯）档位对应的角速度值尚未达到目标角速度则调低目标（转弯）档位
decision.TCode--;
}
}
else
{ // 目标角度为正目标方向在鱼体方向右边需要给右转档位
while ((decision.TCode < 14) && (DataBasedOnExperiment.TCodeAndAngularVelocityTable[decision.TCode] < targetAngularV))
{ // 目标（转弯）档位对应的角速度值尚未达到目标角速度则调高目标（转弯）档位
decision.TCode++;
}
}
}
else
{// 第二阶段（进入阈值区域）镇定算法
times++;
float thetae = destDirRad - fish.BodyDirectionRad;
const float K1 = 0.6f;
const float K2 = 12.0f;
const float K3 = 18.0f;
xna.Vector3 srcPtMmLocal = new xna.Vector3(0, 0, 0);
UrwpgSimHelper.CoordinateTransformation(destDirRad, destPtMm, ref srcPtMmLocal, srcPtMm);
float u1 = -K1 * srcPtMmLocal.X * (float)Math.Pow(Math.Sin(times * msPerCycle / 1000.0f), 2.0);
float u2 = u1 * K2 * srcPtMmLocal.Z + u1 * K3 * (float)Math.Tan(thetae);
double targetVelocity = u1 / Math.Cos(thetae);
double targetAngularV = u2 * Math.Pow(Math.Cos(thetae), 2.0);
//if (disSrcPtMmToDestPtMm < 150.0f && Math.Abs(deltaTheta) < 10.0f * Math.PI / 180.0f)
if (disSrcPtMmToDestPtMm < 140.0f && Math.Abs(deltaTheta) < 10.0f * Math.PI / 180.0f)
{
decision.VCode = 0;
decision.TCode = 7;
}
else
{
decision.VCode = 2;
while ((decision.VCode < 14) && (DataBasedOnExperiment.VCodeAndVelocityTable[decision.VCode] < targetVelocity))
{// 目标（速度）档位对应的速度值尚未达到目标速度则调高目标（速度）档位
decision.VCode++;
}
decision.TCode = 7;
if (deltaTheta <= 0)
{ // 目标角度为负目标方向在鱼体方向左边需要给左转档位（注意左转档位对应的角速度值为负值）
while ((decision.TCode > 0) && (DataBasedOnExperiment.TCodeAndAngularVelocityTable[decision.TCode] > targetAngularV))
{ // 目标（转弯）档位对应的角速度值尚未达到目标角速度则调低目标（转弯）档位
decision.TCode--;
}
}
else
{ // 目标角度为正目标方向在鱼体方向右边需要给右转档位
while ((decision.TCode < 14) && (DataBasedOnExperiment.TCodeAndAngularVelocityTable[decision.TCode] < targetAngularV))
{ // 目标（转弯）档位对应的角速度值尚未达到目标角速度则调高目标（转弯）档位
decision.TCode++;
}
}
}
}
}
}
/// <summary>
/// Inserts the or update decision.
/// </summary>
/// <param name="decision">The decision.</param>
/// <returns></returns>
public int InsertOrUpdateDecision(Decision decision)
{
return(_repositoryFactory.GetDecisionRepository.InsertOrUpdateDecision(decision));
}
internal void Proceed(Decision decision, Duel duel)
{
if (decision != null)
{
duel.ClearAwaitingChoice();
}
if (decision == null && duel.AwaitingChoice != null)
{
return;
}
else if (PendingReplacementEffects.Any())
{
PendingReplacementEffect = PendingReplacementEffects.Single(x => x.Id == (decision as GuidDecision).Decision.Single());
PendingReplacementEffects.Clear();
Proceed(null, duel);
}
else if (PendingReplacementEffect != null)
{
PendingReplacementEffect.Replace(duel, decision);
if (duel.AwaitingChoice == null)
{
UsedReplacementEffects.Add(PendingReplacementEffect.Id);
PendingReplacementEffect = null;
}
Proceed(null, duel);
}
else if (duel.AwaitingEvents.Any())
{
CheckAwaitingEvents(duel);
}
else if (State == StepState.TurnBasedAction)
{
CheckTurnBasedAction(duel, decision);
}
else if (State == StepState.CheckGameOver)
{
CheckGameOver(duel);
}
else if (State == StepState.ResolveSpell)
{
ResolveSpells(duel, decision);
}
else if (State == StepState.StateBasedAction)
{
CheckStateBasedActions(duel);
}
else if (State == StepState.ShieldTrigger)
{
CheckShieldTriggers(duel, decision);
}
else if (State == StepState.SelectAbility)
{
SelectAbility(duel, decision);
}
else if (State == StepState.ResolveAbility)
{
ResolveAbility(duel, decision);
}
else if (State == StepState.PriorityAction)
{
CheckPriority(duel, decision);
}
else if (State != StepState.Over)
{
throw new ArgumentOutOfRangeException(State.ToString());
}
}
private void FindSolution(IEnumerable <Node> nodes, IEnumerable <Link> links, List <SolverWorker> workers)
{
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
var nodeSet = new Set(0, nodes.Count(), 1);
var workerSet = new Set(0, workers.Count(), 1);
//-------------Parameters--------------
var weights = new Parameter(Domain.IntegerNonnegative, "weights", nodeSet);
weights.SetBinding(nodes, "Weight", "ID");
var dependencies = new Parameter(Domain.IntegerRange(0, 1), "dependencies", nodeSet, nodeSet);
dependencies.SetBinding(links, "isDependent", "Source", "Parent");
model.AddParameters(weights, dependencies);
//-------------Decisions--------------
var startTimes = new Decision(Domain.IntegerNonnegative, "starts", nodeSet);
var finishTimes = new Decision(Domain.IntegerNonnegative, "finishes", nodeSet);
var makespan = new Decision(Domain.IntegerNonnegative, "makespan");
var allocation = new Decision(Domain.IntegerRange(0, 1), "allocation", nodeSet, workerSet);
model.AddDecisions(startTimes, finishTimes, makespan, allocation);
//-------------Constraints--------------
model.AddConstraint("FinishTime", Model.ForEach(nodeSet, (node) => startTimes[node] + weights[node] == finishTimes[node]));
//model.AddConstraint("OneAtATime", Model.ForEach(nodeSet, (n) =>
// Model.ForEachWhere(nodeSet, (n2) => Model.Or(finishTimes[n] < startTimes[n2], startTimes[n] > finishTimes[n2]), (n2) => n != n2)));
model.AddConstraint("Allocatee", Model.ForEach(nodeSet, (n) => Model.Sum(Model.ForEach(workerSet, (w) => allocation[n, w])) == 1));
//model.AddConstraint("Allocatee", Model.ForEach(nodeSet, (n) => Model.ExactlyMofN(1,allocation[n])));
model.AddConstraint("OneAtATime",
Model.ForEach(workerSet, (w) =>
Model.ForEach(nodeSet, (n) =>
Model.ForEachWhere(nodeSet, (n2) => Model.Implies(Model.And(allocation[n, w] == 1, allocation[n2, w] == 1),
Model.Or(finishTimes[n] <= startTimes[n2], startTimes[n] >= finishTimes[n2])), (n2) => n != n2))));
model.AddConstraint("PrecedenceConstraints", Model.ForEach(nodeSet, task =>
Model.ForEach(nodeSet, parent =>
Model.Implies(dependencies[task, parent] == 1, startTimes[task] >= finishTimes[parent]))));
//model.AddConstraint("ProjectFinish", Model.ForEach(nodeSet, (n) => makespan >= finishTimes[n]));
model.AddConstraint("ProjectFinish", makespan == Model.Max(Model.ForEach(nodeSet, (n) => finishTimes[n])));
model.AddGoal("MinMakeSpan", GoalKind.Minimize, makespan);
context.CheckModel();
//using (StreamWriter sw = new StreamWriter("Stadium.oml")) {
// context.SaveModel(FileFormat.OML, sw); ;
//}
Solution solution = context.Solve();
Report report = solution.GetReport();
Console.WriteLine(@"===== report =====");
Console.Write("{0}", report);
Console.ReadLine();
context.ClearModel();
}
public virtual Decision IsSatisfiedBy(RemoteMovie subject, SearchCriteriaBase searchCriteria)
{
if (searchCriteria != null && searchCriteria.UserInvokedSearch)
{
_logger.Debug("Ignoring delay for user invoked search");
return(Decision.Accept());
}
var profile = subject.Movie.Profile.Value;
var delayProfile = _delayProfileService.BestForTags(subject.Movie.Tags);
var delay = delayProfile.GetProtocolDelay(subject.Release.DownloadProtocol);
var isPreferredProtocol = subject.Release.DownloadProtocol == delayProfile.PreferredProtocol;
// Preferred word count
var title = subject.Release.Title;
var preferredWords = subject.Movie.Profile.Value.PreferredTags;
var preferredCount = 0;
if (preferredWords == null)
{
preferredCount = 1;
_logger.Debug("Preferred words is null, setting preffered count to 1.");
}
else
{
preferredCount = preferredWords.AsEnumerable().Count(w => title.ToLower().Contains(w.ToLower()));
}
if (delay == 0)
{
_logger.Debug("Profile does not require a waiting period before download for {0}.", subject.Release.DownloadProtocol);
return(Decision.Accept());
}
var comparer = new QualityModelComparer(profile);
if (isPreferredProtocol && (subject.Movie.MovieFileId != 0 && subject.Movie.MovieFile != null) && (preferredCount > 0 || preferredWords == null))
{
var upgradable = _qualityUpgradableSpecification.IsUpgradable(profile, subject.Movie.MovieFile.Value.Quality, subject.ParsedMovieInfo.Quality);
if (upgradable)
{
var revisionUpgrade = _qualityUpgradableSpecification.IsRevisionUpgrade(subject.Movie.MovieFile.Value.Quality, subject.ParsedMovieInfo.Quality);
if (revisionUpgrade)
{
_logger.Debug("New quality is a better revision for existing quality and preferred word count is {0}, skipping delay", preferredCount);
return(Decision.Accept());
}
}
}
// If quality meets or exceeds the best allowed quality in the profile accept it immediately
var bestQualityInProfile = new QualityModel(profile.LastAllowedQuality());
var isBestInProfile = comparer.Compare(subject.ParsedMovieInfo.Quality, bestQualityInProfile) >= 0;
if (isBestInProfile && isPreferredProtocol && (preferredCount > 0 || preferredWords == null))
{
_logger.Debug("Quality is highest in profile for preferred protocol and preferred word count is {0}, will not delay.", preferredCount);
return(Decision.Accept());
}
var oldest = _pendingReleaseService.OldestPendingRelease(subject.Movie.Id);
if (oldest != null && oldest.Release.AgeMinutes > delay)
{
return(Decision.Accept());
}
if (subject.Release.AgeMinutes < delay)
{
_logger.Debug("Waiting for better quality release, There is a {0} minute delay on {1}", delay, subject.Release.DownloadProtocol);
return(Decision.Reject("Waiting for better quality release"));
}
return(Decision.Accept());
}
/// <summary>
/// dirbble带球算法 Modified By Zhangbo 2011.10.22
/// </summary>
/// <param name="decision">每周期机器鱼执行策略，包含速度档位，转弯档位。</param>
/// <param name="fish">目标仿真机器鱼参数，包含当前位置、速度信息。</param>
/// <param name="destPtMm">目标点。</param>
/// <param name="destDirRad">目标方向。</param>
/// <param name="angleTheta1">鱼体方向与目标方向角度差的阈值一。
/// 角度差在此阈值范围内，则赋给机器鱼一个合理的速度档位（见参数disThreshold说明）。</param>
/// <param name="angleTheta2">鱼体方向与目标方向角度差的阈值二。角度差小于此阈值，则机器鱼直线游动；
/// 角度差大于此阈值，则机器鱼调整游动方向。</param>
/// <param name="disThreshold">距离阈值。距离大于此阈值，机器鱼以速度档位VCode1游动；
/// 距离小于此阈值，机器鱼以速度档位VCode2游动。</param>
/// /// <param name="VCode1">直游档位1（默认6档）。</param>
/// /// <param name="VCode2">直游档位2（默认4档）。</param>
/// <param name="cycles">速度和转弯档位之间切换所需周期数经验值。建议取值范围在5-20之间。此参数作用是防止机器鱼“转过”。</param>
/// <param name="msPerCycle">每个仿真周期的毫秒数，传递固定参数，不能修改。</param>
/// <param name="flag">机器鱼坐标选择标准，true为PositionMm，即鱼体绘图中心；false为PolygonVertices[0]，即鱼头点。</param>
public static void Dribble(ref Decision decision, RoboFish fish, xna.Vector3 destPtMm, float destDirRad,
float angleTheta1, float angleTheta2, float disThreshold, int VCode1, int VCode2, int cycles, int msPerCycle, bool flag)
{
// 调节所用周期数及每周期毫秒数转换得到秒数
double seconds1 = 15 * msPerCycle / 1000.0;
double seconds2 = cycles * msPerCycle / 1000.0;
// 标志量为true则起始点为PositionMm即鱼体绘图中心false则起始点为PolygonVertices[0]即鱼头点（起始点）
xna.Vector3 srcPtMm = (flag == true) ? fish.PositionMm : fish.PolygonVertices[0];
// 起始点到目标点的距离（目标距离）
double disSrcPtMmToDestPtMm = Math.Sqrt(Math.Pow(destPtMm.X - srcPtMm.X, 2.0)
+ Math.Pow(destPtMm.Z - srcPtMm.Z, 2.0));
// 鱼体绘图中心指向目标点向量方向的弧度值（中间方向）
double dirFishToDestPtRad = xna.MathHelper.ToRadians((float)GetAngleDegree(destPtMm - fish.PositionMm));
if (disSrcPtMmToDestPtMm < 30)
{// 起始点到目标点距离小于阈值（默认58毫米）将中间方向调为目标方向
dirFishToDestPtRad = destDirRad;
}
// 中间方向与鱼体方向的差值（目标角度）
double deltaTheta = dirFishToDestPtRad - fish.BodyDirectionRad;
// 将目标角度规范化到(-PI,PI]
// 规范化之后目标角度为正表示目标方向在鱼体方向右边
// 规范化之后目标角度为负表示目标方向在鱼体方向左边
if (deltaTheta > Math.PI)
{ // 中间方向为正鱼体方向为负才可能目标角度大于PI
deltaTheta -= 2 * Math.PI; // 规范化到(-PI,0)
}
else if (deltaTheta < -Math.PI)
{ // 中间方向为负鱼体方向为正才可能目标角度小于-PI
deltaTheta += 2 * Math.PI; // 规范化到(0,PI)
}
// 最大角速度取左转和右转最大角速度绝对值的均值
float maxAngularV = (Math.Abs(DataBasedOnExperiment.TCodeAndAngularVelocityTable[0])
+ Math.Abs(DataBasedOnExperiment.TCodeAndAngularVelocityTable[14])) / 2;
// 以最大角速度转过目标角度所需的预计时间（角度预计时间）
double estimatedTimeByAngle = Math.Abs((double)(deltaTheta / maxAngularV));
// 以角度预计时间游过目标距离所需平均速度值（目标速度）
double targetVelocity = disSrcPtMmToDestPtMm / estimatedTimeByAngle;
int code = 1; // 目标（速度）档位初值置1
while ((code < 10) && (DataBasedOnExperiment.VCodeAndVelocityTable[code] < targetVelocity))
{// 目标（速度）档位对应的速度值尚未达到目标速度则调高目标（速度）档位
code++;
}
decision.VCode = code;
if (Math.Abs(deltaTheta) > angleTheta2 * Math.PI / 180.0)
{// 目标角度绝对值超过某一阈值，速度档位置次低进行小半径转弯
decision.VCode = 1;
}
else if (Math.Abs(deltaTheta) < angleTheta1 * Math.PI / 180.0)
{// 目标角度绝对值小于某一阈值，若此时距离较远速度档置较高高全速前进，否则置适中档位前进。
if (disSrcPtMmToDestPtMm > disThreshold)
{
decision.VCode = VCode1;
}
else
{
decision.VCode = VCode2;
}
}
// 以最大速度游过目标距离所需的预计时间（距离预计时间）
double estimatedTimeByDistance = disSrcPtMmToDestPtMm / DataBasedOnExperiment.VCodeAndVelocityTable[14];
if (estimatedTimeByDistance > seconds1)
{// 距离预计时间超过一次档位切换所需平均时间则取为该时间（默认为1秒）
estimatedTimeByDistance = seconds1;
}
// 以距离预计时间游过目标角度所需平均角速度（目标角速度）
double targetAngularV = deltaTheta / estimatedTimeByDistance;
code = 7;
if (deltaTheta <= 0)
{ // 目标角度为负目标方向在鱼体方向左边需要给左转档位（注意左转档位对应的角速度值为负值）
while ((code > 0) && (DataBasedOnExperiment.TCodeAndAngularVelocityTable[code] > targetAngularV))
{ // 目标（转弯）档位对应的角速度值尚未达到目标角速度则调低目标（转弯）档位
code--;
}
if ((fish.AngularVelocityRadPs * seconds2) < deltaTheta)
{// 当前角速度值绝对值过大 一次档位切换所需平均时间内能游过的角度超过目标角度
// 则给相反方向次大转弯档位
code = 12;
}
}
else
{ // 目标角度为正目标方向在鱼体方向右边需要给右转档位
while ((code < 14) && (DataBasedOnExperiment.TCodeAndAngularVelocityTable[code] < targetAngularV))
{ // 目标（转弯）档位对应的角速度值尚未达到目标角速度则调高目标（转弯）档位
code++;
}
if ((fish.AngularVelocityRadPs * seconds2) > deltaTheta)
{// 当前角速度值绝对值过大 一次档位切换所需平均时间内能游过的角度超过目标角度
// 则给相反方向次大转弯档位
code = 2;
}
}
decision.TCode = code;
}
//1ターン = 深さ2
protected override void Solve()
{
for (int i = 0; i < 50; ++i)
{
dp1[i].Score = int.MinValue;
dp2[i].Score = int.MinValue;
}
int deepness = StartDepth;
int maxDepth = (TurnCount - CurrentTurn) * 2 + 2;
PointEvaluator.Base evaluator = (TurnCount / 3 * 2) < CurrentTurn ? PointEvaluator_Normal : PointEvaluator_Distance;
SearchState state = new SearchState(MyBoard, EnemyBoard, MyAgents, EnemyAgents);
int score = PointEvaluator_Normal.Calculate(ScoreBoard, state.MeBoard, 0, MyAgents, EnemyAgents) - PointEvaluator_Normal.Calculate(ScoreBoard, state.EnemyBoard, 0, EnemyAgents, MyAgents);
Log("TurnCount = {0}, CurrentTurn = {1}", TurnCount, CurrentTurn);
if (!(lastTurnDecided is null))
{
StringBuilder sb = new StringBuilder("AgentMoved: {");
for (int i = 0; i < AgentsCount; ++i)
{
sb.Append(IsAgentsMoved[i]);
sb.Append(", ");
}
string ismoved = sb.ToString();
Log("{0}}}, lastTurnDecided = {2}", ismoved.Substring(0, ismoved.Length - 2), lastTurnDecided);
}
if (!(lastTurnDecided is null) && IsAgentsMoved.GetEnumerable(AgentsCount).All(b => b == false) && score > 0) //勝っている状態で競合していたら
{
SolverResultList.Add(lastTurnDecided);
return;
}
for (; deepness <= maxDepth; deepness++)
{
Decided resultList = new Decided();
int greedyDepth = Math.Min(greedyMaxDepth, maxDepth - deepness);
if ((deepness + greedyDepth) % 2 == 1 && greedyDepth > 0)
{
greedyDepth--;
}
//普通にNegaMaxをして、最善手を探す
NegaMax(deepness, state, int.MinValue + 1, int.MaxValue, 0, evaluator, null, greedyDepth);
Decision best1 = new Decision(Unsafe8Array <VelocityPoint> .Create(dp1[0].Ways.GetEnumerable(AgentsCount).Select(x => x.Direction).ToArray()));
resultList.Add(best1);
//競合手.Agent == 最善手.Agent の数が半数以上になった場合、競合手をngMoveとして探索をおこない、最善手を探す
int UnMoveAgentNum = 0;
for (int i = 0; i < AgentsCount; ++i)
{
if (IsAgentsMoved[i] == false && lastTurnDecided.Agents[i] == best1.Agents[i])
{
++UnMoveAgentNum;
}
}
if (UnMoveAgentNum > AgentsCount / 2)
{
NegaMax(deepness, state, int.MinValue + 1, int.MaxValue, 0, evaluator, best1, greedyDepth);
Decision best2 = new Decision(Unsafe8Array <VelocityPoint> .Create(dp2[0].Ways.GetEnumerable(AgentsCount).Select(x => x.Direction).ToArray()));
resultList.Add(best2);
}
if (CancellationToken.IsCancellationRequested == false)
{
SolverResultList = resultList;
if (SolverResultList.Count == 2 && score <= 0) //現時点で引き分けか負けていたら競合を避けるのを優先してみる（デバッグ用）
{
var tmp = SolverResultList[0];
SolverResultList[0] = SolverResultList[1];
SolverResultList[1] = tmp;
Log("[SOLVER] Swaped! {0} {1}", SolverResult.Agents[0], SolverResult.Agents[1]);
}
Log("[SOLVER] SolverResultList.Count = {0}, score = {1}", SolverResultList.Count, score);
}
else
{
return;
}
Log("[SOLVER] deepness = {0}", deepness);
}
}
/// <summary>
/// Pushes a message into the queue.
/// </summary>
internal async Task <PushResult> Push(QueueMessage message, MqClient sender)
{
if (Status == QueueStatus.Stopped)
{
return(PushResult.StatusNotSupported);
}
if (Options.MessageLimit > 0 && HighPriorityLinkedList.Count + RegularLinkedList.Count >= Options.MessageLimit)
{
return(PushResult.LimitExceeded);
}
if (Options.MessageSizeLimit > 0 && message.Message.Length > Options.MessageSizeLimit)
{
return(PushResult.LimitExceeded);
}
//prepare properties
message.Message.FirstAcquirer = true;
message.Message.AcknowledgeRequired = Options.RequestAcknowledge;
//if message doesn't have message id and "UseMessageId" option is enabled, create new message id for the message
if (Options.UseMessageId && string.IsNullOrEmpty(message.Message.MessageId))
{
message.Message.SetMessageId(Channel.Server.MessageIdGenerator.Create());
}
//if we have an option maximum wait duration for message, set it after message joined to the queue.
//time keeper will check this value and if message time is up, it will remove message from the queue.
if (Options.MessageTimeout > TimeSpan.Zero)
{
message.Deadline = DateTime.UtcNow.Add(Options.MessageTimeout);
}
if (Options.HideClientNames)
{
message.Message.SetSource(null);
}
try
{
//fire message receive event
Info.AddMessageReceive();
Decision decision = await DeliveryHandler.ReceivedFromProducer(this, message, sender);
message.Decision = decision;
bool allow = await ApplyDecision(decision, message);
if (!allow)
{
return(PushResult.Success);
}
if (State.CanEnqueue(message))
{
await RunInListSync(() => AddMessage(message));
if (State.TriggerSupported && !_triggering)
{
_ = Trigger();
}
}
else
{
_ = State.Push(message);
}
return(PushResult.Success);
}
catch (Exception ex)
{
Info.AddError();
try
{
Decision decision = await DeliveryHandler.ExceptionThrown(this, State.ProcessingMessage, ex);
if (State.ProcessingMessage != null)
{
await ApplyDecision(decision, State.ProcessingMessage);
if (decision.KeepMessage && !State.ProcessingMessage.IsInQueue)
{
AddMessage(State.ProcessingMessage, false);
}
}
}
catch //if developer does wrong operation, we should not stop
{
}
}
return(PushResult.Success);
}
private async Task <PushResult> ProcessMessage(QueueMessage message, MqClient sender)
{
//if we need acknowledge from receiver, it has a deadline.
DateTime?ackDeadline = null;
if (_queue.Options.RequestAcknowledge)
{
ackDeadline = DateTime.UtcNow.Add(_queue.Options.AcknowledgeTimeout);
}
//if there are not receivers, complete send operation
List <ChannelClient> clients = _queue.Channel.ClientsClone;
if (clients.Count == 0)
{
_queue.Info.AddMessageRemove();
_ = _queue.DeliveryHandler.MessageRemoved(_queue, message);
return(PushResult.NoConsumers);
}
//if to process next message is requires previous message acknowledge, wait here
if (_queue.Options.RequestAcknowledge && _queue.Options.WaitForAcknowledge)
{
await _queue.WaitForAcknowledge(message);
}
message.Decision = await _queue.DeliveryHandler.BeginSend(_queue, message);
if (!await _queue.ApplyDecision(message.Decision, message))
{
return(PushResult.Success);
}
//create prepared message data
byte[] messageData = await _writer.Create(message.Message);
Decision final = new Decision(false, false, false, DeliveryAcknowledgeDecision.None);
bool messageIsSent = false;
//to all receivers
foreach (ChannelClient client in clients)
{
//to only online receivers
if (!client.Client.IsConnected)
{
continue;
}
//somehow if code comes here (it should not cuz of last "break" in this foreach, break
if (!message.Message.FirstAcquirer && _queue.Options.SendOnlyFirstAcquirer)
{
break;
}
//call before send and check decision
Decision ccrd = await _queue.DeliveryHandler.CanConsumerReceive(_queue, message, client.Client);
final = ChannelQueue.CreateFinalDecision(final, ccrd);
if (!ccrd.Allow)
{
continue;
}
//create delivery object
MessageDelivery delivery = new MessageDelivery(message, client, ackDeadline);
delivery.FirstAcquirer = message.Message.FirstAcquirer;
//send the message
bool sent = client.Client.Send(messageData);
if (sent)
{
messageIsSent = true;
//adds the delivery to time keeper to check timing up
_queue.TimeKeeper.AddAcknowledgeCheck(delivery);
//set as sent, if message is sent to it's first acquirer,
//set message first acquirer false and re-create byte array data of the message
bool firstAcquirer = message.Message.FirstAcquirer;
//mark message is sent
delivery.MarkAsSent();
//do after send operations for per message
_queue.Info.AddDelivery();
Decision d = await _queue.DeliveryHandler.ConsumerReceived(_queue, delivery, client.Client);
final = ChannelQueue.CreateFinalDecision(final, d);
//if we are sending to only first acquirer, break
if (_queue.Options.SendOnlyFirstAcquirer && firstAcquirer)
{
break;
}
if (firstAcquirer && clients.Count > 1)
{
messageData = await _writer.Create(message.Message);
}
}
else
{
Decision d = await _queue.DeliveryHandler.ConsumerReceiveFailed(_queue, delivery, client.Client);
final = ChannelQueue.CreateFinalDecision(final, d);
}
}
message.Decision = final;
if (!await _queue.ApplyDecision(final, message))
{
return(PushResult.Success);
}
//after all sending operations completed, calls implementation send completed method and complete the operation
if (messageIsSent)
{
_queue.Info.AddMessageSend();
}
message.Decision = await _queue.DeliveryHandler.EndSend(_queue, message);
await _queue.ApplyDecision(message.Decision, message);
if (message.Decision.Allow && !message.Decision.KeepMessage)
{
_queue.Info.AddMessageRemove();
_ = _queue.DeliveryHandler.MessageRemoved(_queue, message);
}
return(PushResult.Success);
}
public virtual Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria)
{
if (searchCriteria != null)
{
_logger.Debug("Skipping history check during search");
return(Decision.Accept());
}
var cdhEnabled = _configService.EnableCompletedDownloadHandling;
_logger.Debug("Performing history status check on report");
foreach (var episode in subject.Episodes)
{
_logger.Debug("Checking current status of episode [{0}] in history", episode.Id);
var mostRecent = _historyService.MostRecentForEpisode(episode.Id);
if (mostRecent != null && mostRecent.EventType == EpisodeHistoryEventType.Grabbed)
{
var recent = mostRecent.Date.After(DateTime.UtcNow.AddHours(-12));
if (!recent && cdhEnabled)
{
continue;
}
// The series will be the same as the one in history since it's the same episode.
// Instead of fetching the series from the DB reuse the known series.
var preferredWordScore = _preferredWordServiceCalculator.Calculate(subject.Series, mostRecent.SourceTitle, subject.Release?.IndexerId ?? 0);
var cutoffUnmet = _upgradableSpecification.CutoffNotMet(
subject.Series.QualityProfile,
subject.Series.LanguageProfile,
mostRecent.Quality,
mostRecent.Language,
preferredWordScore,
subject.ParsedEpisodeInfo.Quality,
subject.PreferredWordScore);
var upgradeable = _upgradableSpecification.IsUpgradable(
subject.Series.QualityProfile,
subject.Series.LanguageProfile,
mostRecent.Quality,
mostRecent.Language,
preferredWordScore,
subject.ParsedEpisodeInfo.Quality,
subject.ParsedEpisodeInfo.Language,
subject.PreferredWordScore);
if (!cutoffUnmet)
{
if (recent)
{
return(Decision.Reject("Recent grab event in history already meets cutoff: {0}", mostRecent.Quality));
}
return(Decision.Reject("CDH is disabled and grab event in history already meets cutoff: {0}", mostRecent.Quality));
}
if (!upgradeable)
{
if (recent)
{
return(Decision.Reject("Recent grab event in history is of equal or higher quality: {0}", mostRecent.Quality));
}
return(Decision.Reject("CDH is disabled and grab event in history is of equal or higher quality: {0}", mostRecent.Quality));
}
}
}
return(Decision.Accept());
}
public static Tuple <double, double> GetValue(State s, CorrelatedQTable q)
{
var contxt = SolverContext.GetContext();
contxt.ClearModel();
var model = contxt.CreateModel();
var actDecisions = new Dictionary <Tuple <Action, Action>, Decision>();
foreach (Action currentAction in Enum.GetValues(typeof(Action)))
{
foreach (Action player2Action in Enum.GetValues(typeof(Action)))
{
var decision = new Decision(Domain.RealNonnegative, currentAction.ToString() + player2Action.ToString());
model.AddDecisions(decision);
actDecisions.Add(new Tuple <Action, Action>(currentAction, player2Action), decision);
}
}
var actDecisionSum = new SumTermBuilder(25);
foreach (var decision in actDecisions.Values)
{
actDecisionSum.Add(decision);
}
model.AddConstraint("probSumConst", actDecisionSum.ToTerm() == 1.0);
rationalconsts(s, q.getCurrPQvalue, actDecisions, model, "A");
rationalityConstrPlayer2(s, q.getPlayer2Qval, actDecisions, model, "B");
var objectSum = new SumTermBuilder(10);
//Add my terms from my Q table to objective function
ObjFunctermAdd(s, q, actDecisions, objectSum);
model.AddGoal("MaximizeV", GoalKind.Maximize, objectSum.ToTerm());
var sol = contxt.Solve(new SimplexDirective());
if (sol.Quality != SolverQuality.Optimal)
{
contxt.ClearModel();
return(new Tuple <double, double>(1.0, 1.0));
}
double Player1nextVal = 0.0;
double Player2nextVal = 0.0;
foreach (Action currentAction in Enum.GetValues(typeof(Action)))
{
foreach (Action player2Action in Enum.GetValues(typeof(Action)))
{
var policy = getActDecision(currentAction, player2Action, actDecisions);
var qValue = q.getCurrPQvalue(s, currentAction, player2Action);
Player1nextVal += policy.ToDouble() * qValue;
var player2Qv = q.getPlayer2Qval(s, currentAction, player2Action);
Player2nextVal += policy.ToDouble() * player2Qv;
}
}
return(new Tuple <double, double>(Player1nextVal, Player2nextVal));
}
public Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria)
{
var cdhEnabled = _configService.EnableCompletedDownloadHandling;
if (!cdhEnabled)
{
_logger.Debug("Skipping already imported check because CDH is disabled");
return(Decision.Accept());
}
_logger.Debug("Performing already imported check on report");
foreach (var episode in subject.Episodes)
{
if (!episode.HasFile)
{
_logger.Debug("Skipping already imported check for episode without file");
continue;
}
var historyForEpisode = _historyService.FindByEpisodeId(episode.Id);
var lastGrabbed = historyForEpisode.FirstOrDefault(h => h.EventType == EpisodeHistoryEventType.Grabbed);
if (lastGrabbed == null)
{
continue;
}
var imported = historyForEpisode.FirstOrDefault(h =>
h.EventType == EpisodeHistoryEventType.DownloadFolderImported &&
h.DownloadId == lastGrabbed.DownloadId);
if (imported == null)
{
continue;
}
// This is really only a guard against redownloading the same release over
// and over when the grabbed and imported qualities do not match, if they do
// match skip this check.
if (lastGrabbed.Quality.Equals(imported.Quality))
{
continue;
}
var release = subject.Release;
if (release.DownloadProtocol == DownloadProtocol.Torrent)
{
var torrentInfo = release as TorrentInfo;
if (torrentInfo?.InfoHash != null && torrentInfo.InfoHash.ToUpper() == lastGrabbed.DownloadId)
{
_logger.Debug("Has same torrent hash as a grabbed and imported release");
return(Decision.Reject("Has same torrent hash as a grabbed and imported release"));
}
}
// Only based on title because a release with the same title on another indexer/released at
// a different time very likely has the exact same content and we don't need to also try it.
if (release.Title.Equals(lastGrabbed.SourceTitle, StringComparison.InvariantCultureIgnoreCase))
{
_logger.Debug("Has same release name as a grabbed and imported release");
return(Decision.Reject("Has same release name as a grabbed and imported release"));
}
}
return(Decision.Accept());
}
/// <summary>
/// Evaluates the policy.
/// </summary>
/// <param name="context">The evaluation context instance.</param>
/// <returns>The decission result for this policy.</returns>
public Decision Evaluate(EvaluationContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
context.Trace("Evaluating policy: {0}", _policy.Description);
context.AddIndent();
context.CurrentPolicy = this;
try
{
// Evaluate the variables
if (this._policy.SchemaVersion == XacmlVersion.Version20)
{
if (_variables == null)
{
context.Trace("Evaluating variables...");
_variables = new Hashtable();
foreach (pol.VariableDefinitionElement variableDef in _policy.VariableDefinitions.Values)
{
VariableDefinition variable = new VariableDefinition(variableDef);
_variables.Add(variableDef.Id, variable);
}
}
}
// Matches the target.
TargetEvaluationValue targetEvaluationValue = Match(context);
// If the target matches.
if (targetEvaluationValue == TargetEvaluationValue.Match)
{
context.Trace("Rule combination algorithm: {0}", _policy.RuleCombiningAlgorithm);
// Evaluate all rules and apply rule combination
inf.IRuleCombiningAlgorithm rca = EvaluationEngine.CreateRuleCombiningAlgorithm(_policy.RuleCombiningAlgorithm);
_evaluationValue = rca.Evaluate(context, _rules);
}
else if (targetEvaluationValue == TargetEvaluationValue.NoMatch)
{
_evaluationValue = Decision.NotApplicable;
}
else if (targetEvaluationValue == TargetEvaluationValue.Indeterminate)
{
_evaluationValue = Decision.Indeterminate;
}
context.Trace("Policy: {0}", _evaluationValue);
// Copy all the obligations.
_obligations = new pol.ObligationCollection();
if (_evaluationValue != Decision.Indeterminate &&
_evaluationValue != Decision.NotApplicable &&
_policy.Obligations != null && _policy.Obligations.Count != 0)
{
foreach (pol.ObligationElement obl in _policy.Obligations)
{
if ((obl.FulfillOn == pol.Effect.Deny && _evaluationValue == Decision.Deny) ||
(obl.FulfillOn == pol.Effect.Permit && _evaluationValue == Decision.Permit))
{
context.Trace("Adding obligation: {0} ", obl.ObligationId);
_obligations.Add(obl);
}
}
}
return(_evaluationValue);
}
finally
{
context.RemoveIndent();
context.CurrentPolicy = null;
}
}
public Add_Increase()
{
InitializeComponent();
db = new PersonelDBContext();
if (Login.currentUser.Rule == "تدريسي")
{
emp = (from p in db.SelfCards
where (p.Status != "بحكم المستقيل" && p.Status != "كف اليد" && p.Status != "مصروف من الخدمة" && p.FileClass == "تدريسي")
select p.FirstName + " " + p.FatherName + " " + p.LastName).ToList <string>();
list.ItemsSource = emp;
}
else if (Login.currentUser.Rule == "فني")
{
emp = (from p in db.SelfCards
where (p.Status != "بحكم المستقيل" && p.Status != "كف اليد" && p.Status != "مصروف من الخدمة" && p.FileClass == "فني")
select p.FirstName + " " + p.FatherName + " " + p.LastName).ToList <string>();
list.ItemsSource = emp;
}
else if (Login.currentUser.Rule == "معيد")
{
emp = (from p in db.SelfCards
where (p.Status != "بحكم المستقيل" && p.Status != "كف اليد" && p.Status != "مصروف من الخدمة" && p.FileClass == "معيد")
select p.FirstName + " " + p.FatherName + " " + p.LastName).ToList <string>();
list.ItemsSource = emp;
}
else if (Login.currentUser.Rule == "الأولى")
{
emp = (from p in db.SelfCards
where (p.Status != "بحكم المستقيل" && p.Status != "كف اليد" && p.Status != "مصروف من الخدمة" && p.Category == "الأولى")
select p.FirstName + " " + p.FatherName + " " + p.LastName).ToList <string>();
list.ItemsSource = emp;
}
else if (Login.currentUser.Rule == "الثانية")
{
emp = (from p in db.SelfCards
where (p.Status != "بحكم المستقيل" && p.Status != "كف اليد" && p.Status != "مصروف من الخدمة" && (p.Category == "الثانية/مخبريين" || p.Category == "الثانية/اداريين"))
select p.FirstName + " " + p.FatherName + " " + p.LastName).ToList <string>();
list.ItemsSource = emp;
}
else if (Login.currentUser.Rule == "الثالثة")
{
emp = (from p in db.SelfCards
where (p.Status != "بحكم المستقيل" && p.Status != "كف اليد" && p.Status != "مصروف من الخدمة" && (p.Category == "الثالثة" || p.Category == "الرابعة"))
select p.FirstName + " " + p.FatherName + " " + p.LastName).ToList <string>();
list.ItemsSource = emp;
}
else if (Login.currentUser.Rule == "الخامسة")
{
emp = (from p in db.SelfCards
where (p.Status != "بحكم المستقيل" && p.Status != "كف اليد" && p.Status != "مصروف من الخدمة" && p.Category == "الخامسة")
select p.FirstName + " " + p.FatherName + " " + p.LastName).ToList <string>();
list.ItemsSource = emp;
}
else if (Login.currentUser.Rule == "عقود")
{
emp = (from p in db.SelfCards
where (p.Status != "بحكم المستقيل" && p.Status != "كف اليد" && p.Status != "مصروف من الخدمة" && p.FileClass == "عقد")
select p.FirstName + " " + p.FatherName + " " + p.LastName).ToList <string>();
list.ItemsSource = emp;
}
else if (Login.currentUser.Rule == "admin")
{
emp = (from p in db.SelfCards
where (p.Status != "بحكم المستقيل" && p.Status != "كف اليد" && p.Status != "مصروف من الخدمة")
select p.FirstName + " " + p.FatherName + " " + p.LastName).ToList <string>();
list.ItemsSource = emp;
}
/////////////////////////////////////////////////////
Decision d = (Decision)DataContext;
}
public abstract void PerformTurnBasedAction(Duel duel, Decision decision);
public static Tuple<ICollection<SubCalendarEvent>, double> Run(ICollection<SubCalendarEvent> ListOfElements, int BeginningAndEnd=0)
{
#if EnableHive
if (ListOfElements.Count < 3)
{
return new Tuple<ICollection<SubCalendarEvent>, double>(ListOfElements, 0);
}
CitiesData citiesData = new CitiesData(ListOfElements.ToList());
int totalNumberBees = 100;
int numberInactive = 20;
int numberActive = 50;
int numberScout = 30;
int maxNumberVisits = 50;
int maxNumberCycles = 20;
Hive hive = new Hive(totalNumberBees, numberInactive, numberActive, numberScout, maxNumberVisits, maxNumberCycles, citiesData, BeginningAndEnd);
bool doProgressBar = false;
hive.Solve(doProgressBar);
return hive.getBestPath();
#endif
#if LinearTSP
Coordinate[] data = new Coordinate[ListOfElements.Count];
Dictionary<int, SubCalendarEvent> DictOFData = new Dictionary<int,SubCalendarEvent>();
int NameIndex = 0;
foreach (SubCalendarEvent eachSubCalendarEvent in ListOfElements)
{
data[NameIndex] = new Coordinate(NameIndex, eachSubCalendarEvent);
DictOFData.Add(NameIndex++, eachSubCalendarEvent);
}
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
// ------------
// Parameters
Set city = new Set(Domain.IntegerNonnegative, "city");
Parameter dist = new Parameter(Domain.Real, "dist", city, city);
var arcs = from p1 in data
from p2 in data
select new Arc { City1 = p1.Name, City2 = p2.Name, Distance = p1.Distance(p2, data.Length) };
dist.SetBinding(arcs, "Distance", "City1", "City2");
model.AddParameters(dist);
// ------------
// Decisions
Decision assign = new Decision(Domain.IntegerRange(0, 1), "assign", city, city);
Decision rank = new Decision(Domain.RealNonnegative, "rank", city);
model.AddDecisions(assign, rank);
// ------------
// Goal: minimize the length of the tour.
Goal goal = model.AddGoal("TourLength", GoalKind.Minimize,
Model.Sum(Model.ForEach(city, i => Model.ForEachWhere(city, j => dist[i, j] * assign[i, j], j => i != j))));
// ------------
// Enter and leave each city only once.
int N = data.Length;
model.AddConstraint("assign_1",
Model.ForEach(city, i => Model.Sum(Model.ForEachWhere(city, j => assign[i, j],
j => i != j)) == 1));
model.AddConstraint("assign_2",
Model.ForEach(city, j => Model.Sum(Model.ForEachWhere(city, i => assign[i, j], i => i != j)) == 1));
// Forbid subtours (Miller, Tucker, Zemlin - 1960...)
model.AddConstraint("no_subtours",
Model.ForEach(city,
i => Model.ForEachWhere(city,
j => rank[i] + 1 <= rank[j] + N * (1 - assign[i, j]),
j => Model.And(i != j, i >= 1, j >= 1)
)
)
);
Solution solution = context.Solve();
double Cost = goal.ToDouble();
List<SubCalendarEvent> OptimizedSubCalEvents = new List<SubCalendarEvent>();
var tour = from p in assign.GetValues() where (double)p[0] > 0.9 select p;
foreach (var i in tour.ToArray())
{
int MyIndex =Convert.ToInt32(i[2]);
OptimizedSubCalEvents.Add(DictOFData[MyIndex]);
//Console.WriteLine(i[1] + " -> " + );
}
context.ClearModel();
return new Tuple<ICollection<SubCalendarEvent>, double>(OptimizedSubCalEvents, Cost);
#endif
}
private void Raschot_Click(object sender, EventArgs e)
{
if (
#region ---
(_predel_B1.Text == "") ||
(_predel_B2.Text == "") ||
(_predel_B3.Text == "") ||
(kol_A1_B1.Text == "") ||
(kol_A1_B2.Text == "") ||
(kol_A1_B3.Text == "") ||
(kol_A2_B1.Text == "") ||
(kol_A2_B2.Text == "") ||
(kol_A2_B3.Text == "") ||
(kol_A3_B1.Text == "") ||
(kol_A3_B2.Text == "") ||
(kol_A3_B3.Text == "") ||
(sto_A1.Text == "") ||
(sto_A2.Text == "") ||
(sto_A3.Text == ""))
#endregion ---
{
Grafick.Parent = null;
MessageBox.Show("Не все поля заполнены!", "Ошибка");
return;
}
else
{
Grafick.Parent = tabControl1;
chart1.Series[0].Points.Clear();
chart1.Series[1].Points.Clear();
chart1.Series[2].Points.Clear();
H._predel_B1 = Double.Parse(_predel_B1.Text);
H._predel_B2 = Double.Parse(_predel_B2.Text);
H._predel_B3 = Double.Parse(_predel_B3.Text);
H.kol_A1_B1 = Double.Parse(kol_A1_B1.Text);
H.kol_A1_B2 = Double.Parse(kol_A1_B2.Text);
H.kol_A1_B3 = Double.Parse(kol_A1_B3.Text);
H.kol_A2_B1 = Double.Parse(kol_A2_B1.Text);
H.kol_A2_B2 = Double.Parse(kol_A2_B2.Text);
H.kol_A2_B3 = Double.Parse(kol_A2_B3.Text);
H.kol_A3_B1 = Double.Parse(kol_A3_B1.Text);
H.kol_A3_B2 = Double.Parse(kol_A3_B2.Text);
H.kol_A3_B3 = Double.Parse(kol_A3_B3.Text);
H.sto_A1 = Double.Parse(sto_A1.Text);
H.sto_A2 = Double.Parse(sto_A2.Text);
H.sto_A3 = Double.Parse(sto_A3.Text);
List <SolverRow> solverList = new List <SolverRow>();
solverList.Add(new SolverRow {
xId = 1, Koef = H.X1
});
solverList.Add(new SolverRow {
xId = 2, Koef = H.X2
});
solverList.Add(new SolverRow {
xId = 3, Koef = H.X3
});
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
Set users = new Set(Domain.Any, "users");
Parameter Koef = new Parameter(Domain.Real, "Koef", users);
Koef.SetBinding(solverList, "Koef", "xId");
model.AddParameter(Koef);
Decision choose = new Decision(Domain.RealNonnegative, "choose", users);
model.AddDecisions(choose);
model.AddGoal("goal", GoalKind.Minimize, Model.Sum(Model.ForEach(users, xId => choose[xId] * Koef[xId])));
model.AddConstraint("OgranT1", Model.Sum(Model.ForEach(users, xId => H.kol_A1_B1 * H.X1 + H.kol_A2_B1 * H.X2 + H.kol_A3_B1 * H.X3)) <= H._predel_B1);
model.AddConstraint("OgranT2", Model.Sum(Model.ForEach(users, xId => H.kol_A1_B2 * H.X1 + H.kol_A2_B2 * H.X2 + H.kol_A3_B2 * H.X3)) <= H._predel_B2);
model.AddConstraint("OgranT3", Model.Sum(Model.ForEach(users, xId => H.kol_A1_B3 * H.X1 + H.kol_A2_B3 * H.X2 + H.kol_A3_B3 * H.X3)) <= H._predel_B3);
try
{
Solution solution = context.Solve();
Report report = solution.GetReport();
String reportStr = "";
for (int i = 0; i < solverList.Count; i++)
{
reportStr += "Значение X" + (i + 1).ToString() + ": " + choose.GetDouble(solverList[i].xId) + "\n";
}
reportStr += "\n" + report.ToString();
}
catch (Exception ex)
{
MessageBox.Show("При решении задачи оптимизации возникла исключительная ситуация.");
}
double X1 = Math.Round(choose.GetDouble(solverList[0].xId), 3);
double X2 = Math.Round(choose.GetDouble(solverList[1].xId), 3);
double X3 = Math.Round(choose.GetDouble(solverList[2].xId), 3);
this.chart1.Series[0].Points.AddXY("", H.X1);
this.chart1.Series[1].Points.AddXY("", H.X2);
this.chart1.Series[2].Points.AddXY("", H.X3);
dataGridView1.Rows.Add(H.X1, H.X2, H.X3);
}
}
partial void ListAjaxOverride(T4MVC_System_Web_Mvc_ActionResult callInfo, Decision.ViewModel.Role.RoleSearchRequest request);
public Decision IsSatisfiedBy(RemoteEpisode subject, SearchCriteriaBase searchCriteria)
{
var queue = _queueService.GetQueue();
var matchingEpisode = queue.Where(q => q.RemoteEpisode?.Series != null &&
q.RemoteEpisode.Series.Id == subject.Series.Id &&
q.RemoteEpisode.Episodes.Select(e => e.Id).Intersect(subject.Episodes.Select(e => e.Id)).Any())
.ToList();
foreach (var queueItem in matchingEpisode)
{
var remoteEpisode = queueItem.RemoteEpisode;
var qualityProfile = subject.Series.QualityProfile.Value;
var languageProfile = subject.Series.LanguageProfile.Value;
// To avoid a race make sure it's not FailedPending (failed awaiting removal/search).
// Failed items (already searching for a replacement) won't be part of the queue since
// it's a copy, of the tracked download, not a reference.
if (queueItem.TrackedDownloadState == TrackedDownloadState.FailedPending)
{
continue;
}
_logger.Debug("Checking if existing release in queue meets cutoff. Queued: {0} - {1}", remoteEpisode.ParsedEpisodeInfo.Quality, remoteEpisode.ParsedEpisodeInfo.Language);
var queuedItemPreferredWordScore = _preferredWordServiceCalculator.Calculate(subject.Series, queueItem.Title);
if (!_upgradableSpecification.CutoffNotMet(qualityProfile,
languageProfile,
remoteEpisode.ParsedEpisodeInfo.Quality,
remoteEpisode.ParsedEpisodeInfo.Language,
queuedItemPreferredWordScore,
subject.ParsedEpisodeInfo.Quality,
subject.PreferredWordScore))
{
return(Decision.Reject("Release in queue already meets cutoff: {0} - {1}", remoteEpisode.ParsedEpisodeInfo.Quality, remoteEpisode.ParsedEpisodeInfo.Language));
}
_logger.Debug("Checking if release is higher quality than queued release. Queued: {0} - {1}", remoteEpisode.ParsedEpisodeInfo.Quality, remoteEpisode.ParsedEpisodeInfo.Language);
if (!_upgradableSpecification.IsUpgradable(qualityProfile,
languageProfile,
remoteEpisode.ParsedEpisodeInfo.Quality,
remoteEpisode.ParsedEpisodeInfo.Language,
queuedItemPreferredWordScore,
subject.ParsedEpisodeInfo.Quality,
subject.ParsedEpisodeInfo.Language,
subject.PreferredWordScore))
{
return(Decision.Reject("Release in queue is of equal or higher preference: {0} - {1}", remoteEpisode.ParsedEpisodeInfo.Quality, remoteEpisode.ParsedEpisodeInfo.Language));
}
_logger.Debug("Checking if profiles allow upgrading. Queued: {0} - {1}", remoteEpisode.ParsedEpisodeInfo.Quality, remoteEpisode.ParsedEpisodeInfo.Language);
if (!_upgradableSpecification.IsUpgradeAllowed(subject.Series.QualityProfile,
subject.Series.LanguageProfile,
remoteEpisode.ParsedEpisodeInfo.Quality,
remoteEpisode.ParsedEpisodeInfo.Language,
subject.ParsedEpisodeInfo.Quality,
subject.ParsedEpisodeInfo.Language))
{
return(Decision.Reject("Another release is queued and the Quality or Language profile does not allow upgrades"));
}
}
return(Decision.Accept());
}
partial void CreateOverride(T4MVC_System_Web_Mvc_ActionResult callInfo, Decision.ViewModel.Role.AddRoleViewModel viewModel);
protected override void EndSolve(object sender, EventArgs e)
{
base.EndSolve(sender, e);
lastTurnDecided = SolverResultList[0]; //0番目の手を指したとする。（次善手を人間が選んで競合した～ということがなければOK）
}
public override System.Threading.Tasks.Task<System.Web.Mvc.ActionResult> Edit(Decision.ViewModel.Role.EditRoleViewModel viewModel)
{
var callInfo = new T4MVC_System_Web_Mvc_ActionResult(Area, Name, ActionNames.Edit);
ModelUnbinderHelpers.AddRouteValues(callInfo.RouteValueDictionary, "viewModel", viewModel);
EditOverride(callInfo, viewModel);
return System.Threading.Tasks.Task.FromResult(callInfo as ActionResult);
}
//Meが動くとする。「Meのスコア - Enemyのスコア」の最大値を返す。
private int NegaMax(int deepness, SearchState state, int alpha, int beta, int count, PointEvaluator.Base evaluator, Decision ngMove, int greedyDepth)
{
if (deepness == 0)
{
for (int j = 0; j < greedyDepth; j++)
{
Way move = state.MakeGreedyMove(ScoreBoard, WayEnumerator);
state.Move(move.Agent1Way, move.Agent2Way);
//Ways moves = state.MakeMoves(WayEnumerator);
//SortMoves(ScoreBoard, state, moves, 49, null);
//state.Move(moves[0].Agent1Way, moves[1].Agent2Way);
}
int score = evaluator.Calculate(ScoreBoard, state.MeBoard, 0, state.Me, state.Enemy) - evaluator.Calculate(ScoreBoard, state.EnemyBoard, 0, state.Enemy, state.Me);
if (greedyDepth % 2 == 1)
{
return(-score);
}
return(score);
}
Ways ways = state.MakeMoves(WayEnumerator);
SortMoves(ScoreBoard, state, ways, count, ngMove);
for (int i = 0; i < ways.Count; i++)
{
if (CancellationToken.IsCancellationRequested == true)
{
return(alpha);
} //何を返しても良いのでとにかく返す
//if (count == 0 && !(ngMove is null) && new Decided(ways[i].Agent1Way, ways[i].Agent2Way).Equals(ngMove)) { continue; } //競合手を避ける場合
if (count == 0 && !(ngMove is null) && (ways[i].Agent1Way.Equals(ngMove.Agents[0]) || ways[i].Agent2Way.Equals(ngMove.Agents[1])))
{
continue;
} //2人とも競合手とは違う手を指す
SearchState nextState = state;
nextState.Move(ways[i].Agent1Way, ways[i].Agent2Way);
int res = -NegaMax(deepness - 1, nextState, -beta, -alpha, count + 1, evaluator, ngMove, greedyDepth);
if (alpha < res)
{
alpha = res;
if (ngMove is null)
{
dp1[count].UpdateScore(alpha, ways[i].Agent1Way, ways[i].Agent2Way);
}
else
{
dp2[count].UpdateScore(alpha, ways[i].Agent1Way, ways[i].Agent2Way);
}
if (alpha >= beta)
{
return(beta); //βcut
}
}
}
ways.Erase();
WaysPool.Return(ways);
return(alpha);
}
private void walk(Decision stateOne, Decision stateTwo)
{
Decision decision = Decision.none;
if(currentHorizontal < 0 && currentHorizontal <= -MaxHorizontal){
decision = Decision.right;
}
if(currentVertical < 0 && currentVertical <= -MaxVertical){
decision = Decision.up;
}
if(currentHorizontal > 0 && currentHorizontal >= MaxHorizontal){
decision = Decision.left;
}
if(currentVertical > 0 && currentVertical >= MaxVertical){
decision = Decision.down;
}
if(decision == Decision.none){
if((Random.Range(1,100) % 2) == 0){
decision = stateTwo;
}else{
decision = stateOne;
}
}
sendDecision(decision);
}
//遷移順を決める. 「この関数においては」MeBoard…手番プレイヤのボード, Me…手番プレイヤ、とします。
//引数: stateは手番プレイヤが手を打つ前の探索状態、(way1[i], way2[i])はi番目の合法手（移動量）です。
//以下のルールで優先順を決めます.
//ルール1. Killer手（優先したい手）があれば、それを優先する
//ルール2. 次のmoveで得られる「タイルポイント」の合計値が大きい移動（の組み合わせ）を優先する。
//ルール2では, タイル除去によっても「タイルポイント」が得られるとして計算する。
private void SortMoves(sbyte[,] ScoreBoard, SearchState state, Ways way, int deep, Decision ngMove)
{
Unsafe8Array <Point> Killer;
DP[] dp = ngMove is null ? dp1 : dp2;
if (dp[deep].Score == int.MinValue)
{
Killer = Unsafe8Array <Point> .Create(new Point(114, 191), new Point(114, 191), new Point(114, 191), new Point(114, 191), new Point(114, 191), new Point(114, 191), new Point(114, 191), new Point(114, 191));
}
else
{
Killer = new Unsafe8Array <Point>();
for (int i = 0; i < AgentsCount; ++i)
{
Killer[i] = state.Me[i] + dp[deep].AgentsWay[i];
}
}
for (int i = 0; i < way.Count; i++)
{
int score = 0;
Unsafe8Array <Point> nexts = new Unsafe8Array <Point>();
for (int n = 0; n < AgentsCount; ++i)
{
nexts[n] = state.Me[n] + way[i].AgentWays[n];
}
if (Killer.Agent1 == next1 && Killer.Agent2 == next2)
{
score = 100;
}
if (state.EnemyBoard[next1])
{
score += ScoreBoard[next1.X, next1.Y];
} //タイル除去によって有利になる
else if (!state.MeBoard[next1])
{
score += ScoreBoard[next1.X, next1.Y];
} //移動でMeの陣地が増えて有利になる
if (state.EnemyBoard[next2])
{
score += ScoreBoard[next2.X, next2.Y];
}
else if (!state.MeBoard[next2])
{
score += ScoreBoard[next2.X, next2.Y];
}
way[i].Point = score;
}
way.Sort();
}
