Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 3 years ago.
Improve this question
I try to increase number in while-loop as in c\c++, but its not correct working, whats wrong?
summ=0
i=0
while summ<p do
summ=p0+aug
i=i+1
end
There are several things wrong with the provided code.
p is nil which will cause an error for comparing a nil value with a number value.
p0 and aug are both nil which will cause an error for performing arithmetic operations on a nil value
Assuming that p, p0 and aug weren't nil they would not change value within the while loop. Hence p0+aug is a constant. So depending on p0+aug>p your loop would either never start, stop after the first run or run forever.
Related
This question already has an answer here:
Unexpected behavior SelectOutput block in AnyLogic
(1 answer)
Closed last year.
I have a SelectOutput block in my Anylogic model that tests the variable probabilityhub of the agent going through the process blocks. If it is higher than 0.5, it is false and the agent should go down.
The variable probabilityhub is given in the TOD delay block like agent.probabilityhub = some formula. I checked to see if the variable is given to the agents correctly, by writing them in a dataset at the exit of delay block TOD (like dataset.add(agent.othervariable,agent.probabilityhub);) and as you can see in the dataset, it works and the probabilityhub sometimes is higher than 0.5. However, as you also can see in the figure below, the SelectOutput is always true and none of the agents are going down... Does anyone know why this could be the case?
the action "on exit" of the delay block occurs AFTER the selectOutput condition calculation, so if you change the value of your probability on the on exit action, it's too late... This is counterintuitive in anylogic but things happen in the reverse order of the flow... which is weird, but it is like that
So calculate it in the "on at exit" action instead, and everything will work
Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 6 years ago.
Improve this question
*warning: iteration 5u invokes undefined behavior [-Waggressive-loop-optimizations]
if([user1 isEqualToString:account1[i].name])
^
main.m:33:2: note: containing loop
for(i=0;i<=6;i++)
^
please somebody correct this code
Almost certainly you have:
Thing account1[6] = { ... };
for (i = 0; i <= 6; i++)
{
if ([user1 isEqualToString:account1[i].name])
and the compiler knows that <= 6 will go beyond the bounds of the array (last index is 5 not 6).
To correct:
for (i = 0; i < 6; i++)
^
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 6 years ago.
Improve this question
I know that in static analysis of program, we need to find fixpoint to analysis the info loop provided.
I have read the wiki as well as related meterials in the book Secure_programming_with_Static_Analysis.
But I am still confused with the concept fixpoint, so my questions are:
could anyone give me some explanations of the concept, fixpoint?
What is the practical way(ways) to find the fixpoint in static analysis?
What information can we get after finding the fixpoint?
Thank you!
Conceptually, the fixpoint corresponds to the most information you obtain about the loop by repeatedly iterating it on some set of abstract values. I'm going to guess that by "static analysis" you're referring here to "data flow analysis" or the version of "abstract interpretation" that most closely follows data flow analysis: a simulation of program execution using abstractions of the possible program states at each point. (Model checking follows a dual intuition in that you're simulating program states using an abstraction of possible execution paths. Both are approximations of concrete program behavior. )
Given some knowledge about a program point, this "simulation" corresponds to the effect that we know a particular program construct must have on what we know. For example, at some point in a program, we may know that x could (a) be uninitialized, or else have its value from statements (b) x = 0 or (c) x = f(5), but after (d) x = 42, its value can only have come from (d). On the other hand, if we have
if ( foo() ) {
x = 42; // (d)
bar();
} else {
baz();
x = x - 1; // (e)
}
then the value of x afterwards might have come from either of (d) or (e).
Now think about what can happen with a loop:
while ( x != 0 ) {
if ( foo() ) {
x = 42; // (d)
bar();
} else {
baz();
x = x - 1; // (e)
}
}
On entry, we have possible definitions of x from {a,b,c}. One pass through the loop means that the possible definitions are instead drawn from {d,e}. But what happens if foo() fails initially so that the loop does not run at all? What are the possibilities for x then? Well, in this case, the loop body has no effect, so the definitions of x would come from {a,b,c}. But if it ran, even once, then the answer is {d,e}. So what we know about x at the end of the loop is that the loop either ran or it didn't, which means that the assignment to x could be any one or {a,b,c,d,e}: the only safe answer here is the union of the property known at loop entry ({a,b,c}) and the property know at the end of one iteration ({d,e}).
But this also means that we must associate x with {a,b,c,d,e} at the beginning of the loop body, too, since we have no way of determining whether this is the first or the four thousandth time through the loop. So we have to consider again what we can have on loop exit: the union of the loop body's effect with the property assumed to hold on entry to the last iteration. Happily, this is just {a,b,c,d,e} ∪ {d,e} = {a,b,c,d,e}. In other words, we've not obtained any additional information through this second simulation of the loop body, and thus we can stop, since no further simulated iterations will change the result.
That's the fixpoint: the abstraction of the program state that will cause simulation to produce exactly the same result.
Now as for ways to find it, there are many, though the most straightforward ("chaotic iteration") simply runs the simulation of every program point (according to some fair strategy) until the answer doesn't change. A good starting point for learning better algorithms can be found in most any compilers textbook, though it isn't usually taught in a first course. Steven Muchnick's Advanced Compiler Design and Implementation is a more thorough and very readable treatment of the subject. If you can find a copy, Matthew Hecht's Flow Analysis of Computer Programs is another classic treatment. Both books focus on the "data flow analysis" technique for static analysis. You might also try out Principles of Program Analysis, by Nielson/Nielson/Hankin, though the technical details in the book can be pretty hairy. On the other hand, it offers a more general treatment of static analysis overall.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 8 years ago.
Improve this question
Can anyone help me to understand that Is 2^(n^2 )=Θ(2^(n^3 )) ? it will be great if also provide the proof for this. As per my view this does not need to be equal.
The given assumption is not true:
First of all, 2^(n^2) is a function and Theta(2^(n^3)) is a set of functions, so it would be correct to say that 2^(n^2) ∈ Theta(2^(n^3)). The = is just a common abuse of notation, but it actually means ∈. To find out whether that statement is true, solve the following limit:
lim (n->infinity) of (2^(n^2)) / (2^(n^3))
If the result is 0 or infinite then the function does not belong to that particular Theta class. If it is some other value, it does belong to that class.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking for code must demonstrate a minimal understanding of the problem being solved. Include attempted solutions, why they didn't work, and the expected results. See also: Stack Overflow question checklist
Closed 8 years ago.
Improve this question
I need to prove that for every k, there's a DFA M with k+2 states, so in every automat M' who accepts the language reverse(L(M)) there are at least 2^k states.
Help would be really appreciated.
Thanks :)
Assuming that the alphabet set contains at least two elements, let it be {0,1}.
Next, let M be the automata accepting the language L defined as:
All the strings which k-th position is 1
defined as:
M = {Q,{0,1},q0,{qk+1},δ}, where
Q={q0,q1,...,qk,qF}
δ(qi,a) = qi+1, for a in {0,1} and i=0,1,...,k-2
δ(qk-1,0) = qF,
δ(qk-1,1) = qk,
δ(qF,a) = qF, for a in {0,1}
Note that M has exactly k+2 states, and that it accepts the language L.
Now, note that the language reverse(L(M)) can be translated as:
All the strings which k-th position from the end is 1
To recognize that language, note that we need to remember the last k symbols, because we don't know when the string will end. We know that there are at least 2k possible strings of length k (since the alphabet size is at least 2).
So using a DFA, we need at least 2k states, each to represent one possible string of length k. ▢
Author's note:
The idea of this proof is to find a language which is "easy" to be recognized in normal way, but "difficult" when is read backward. Through experience, I remember that fixing the k-th position from the beginning is "easy", while k-th position from the end is "difficult", hence my answer.