I'm having an issue. I have to write a program for my calculator but I'm not sure how to do it. It uses a form of QBASIC language.
My statement is:
IF (y>0 and x>0) then it should calculate n:=ATAN(y/x);
IF (y<0 and x<0) then it should calculate n:=ATAN(y/x)+180;
IF (y>0 and x<0) then it should calculate n:=ATAN(y/x)+180;
IF (y<0 and x>0) then it should calculate n:=ATAN(y/x)+360;
I think I could only use (IF, ELSE, THEN)
your code is
cls
input x
input y
if y>0 and x>0 then
n=ATAN(y/x)
else if y<0 and x<0 then
n= ATAN(y/x)+ 180
else if y>0 and x<0 then
n=ATAN(y/x)+180
else if y<0 and x>0 then
n= ATAN(y/x)+360
endif
end
If IF, THEN, and ELSE are all you have then the following applies:
The rule for a statement containing several IFs and ELSEs is that the first ELSE is associated with the closest preceding IF, and each subsequent ELSE with the closest unassigned preceding IF.
first ELSE subsequent ELSE first ELSE
| | |
v v v
IF y<0 THEN IF x<0 THEN n:=ATAN(y/x)+180 ELSE n:=ATAN(y/x)+360 ELSE IF x<0 THEN n:=ATAN(y/x)+180 ELSE n:=ATAN(y/x)
^ ^ | | ^ |
| \--- closest preceding IF ---/ | \--- closest preceding IF ---/
\---unassigned closest preceding IF ---------------------------/
If possible, use the somewhat less complex:
n:=ATAN(y/x): IF y<0 THEN IF x<0 THEN n:=n+180 ELSE n:=n+360 ELSE IF x<0 THEN n:=n+180
Related
I'm new to SML and I'm at the point where I can write functional code but I'm unsure of whether there's a more proper or idiomatic way to do things. SML only allows value constructors in patterns, so a case statement doesn't work below. SML also doesn't allow multiple else-if statements.
The following works, but has an ugly triply-nested for-loop. Is there a more idiomatic way to write the following code?
datatype coins = penny | nickle | dime | quarter;
fun valueToCoins 0 = nil
| valueToCoins x =
if x >= 25
then quarter::valueToCoins(x-25)
else
if x >= 10
then dime::valueToCoins(x-10)
else
if x >= 5
then nickle::valueToCoins(x-5)
else penny::valueToCoins(x-1);
The comments have addressed this, but really you've done the right thing. You just need to format it properly and it looks reasonable.
datatype coins = penny | nickle | dime | quarter;
fun valueToCoins 0 = nil
| valueToCoins x =
if x >= 25 then
quarter :: valueToCoins(x - 25)
else if x >= 10 then
dime :: valueToCoins(x - 10)
else if x >= 5 then
nickle :: valueToCoins(x - 5)
else
penny :: valueToCoins(x - 1);
I want to write an if-else statement as a logical statement. I know that:
if (statement1){
b=c
}
else{
b=d
}
can be written as:
b=(statement1 && c)||(!statement1 && d)
But how do I write the following if-else statements as logical?:
if (statement1){
b=c
}
else if (statement2){
b=d
}
else{
b=e
}
I have thought of something like:
b=(statement1 && c)||(statement2 && d)||((!statement1&&!statement2) && e)
I'm sorry if there is already a post about this. I have tried, but couldn't find anything similar to my problem.
As with all logical statement building, it'll be easiest to create a truth table here. You'll end up with:
+--+--+--------+
|s2|s1| result |
+--+--+--------+
| 0| 0| e |
+--+--+--------+
| 0| 1| c |
+--+--+--------+
| 1| 0| d |
+--+--+--------+
| 1| 1| c |
+--+--+--------+
So un-simplified, that'll be
(!s1 & !s2 & e) || (!s2 & s1 & c) || (s2 & !s1 & d) || (s1 & s2 & c)
This can be simplified by combining the two c results and removing the s2:
(!s1 & !s2 & e) || (s2 & !s1 & d) || (s1 & c)
(note that this will be faster in C++ and match the if statements closer with s1 & c as the first term. This will especially make a difference if evaluating any of these values will cause outside effects)
Note that what you built,
(statement1 && c)||(statement2 && d)||((!statement1&&!statement2) && e)
will function incorrectly if statement1 is true, c is false, and both statement2 and d are true (you'll get a result of true when you should have false).
what's wrong with this range?
rangeTransDate = strFmt('(("%1.%2" <= "%3" && "%3" == "%5") || ("%1.%4" > "%3"))',tableStr(CustomTable),fieldStr(CustomTable,TransDate), date2str(dateTo,321,2,0,2,0,4),fieldStr(CustomTable,SettlementDate),SysQuery::valueEmptyString());
i'm getting this error:
Query extended range error: Right parenthesis expected next to position 72.
This page of AX 2012 documentation is still relevant (I cannot find a AX365 version). Highlighting the important bit gives:
The rules for creating query range value expressions are:
Enclose the whole expression in parentheses.
Enclose all subexpressions in parentheses.
Use the relational and logical operators available in X++.
Only use field names from the range's data source.
Use the dataSource.field notation for fields from other data sources in the query.
This means that X++ expects curly brackets around every comparison operator (a.k.a. "subexpression" in the documentation). You are missing some...
Also, use the date2strxpp() function to properly handle all date to string conversions. This function can handle empty date values (dateNull()) by translating these to 1900-01-01. I doubt that putting an empty string (SysQuery::valueEmptyString()) in there will work.
So try this, the commented subexpression levels show the bracket groupings:
// subexpressions lvl 2: 4 4
// subexpressions lvl 1: |1 1 2 2 3 3|
// || | | | | ||
rangeTransDate = strFmt('(("%1.%2" <= "%3") && ("%3" == "%5") || ("%1.%4" > "%3"))',
tableStr(CustomTable),
fieldStr(CustomTable,TransDate),
date2strxpp(dateTo),
fieldStr(CustomTable,SettlementDate),
date2strxpp(dateNull()));
If you still get a similar error at runtime, add even more brackets to group every subexpression in pairs:
// subexpressions lvl 3: 5 5
// subexpressions lvl 2: |4 4 3 3|
// subexpressions lvl 1: ||1 1 2 2| 3 3|
// ||| | | || | ||
rangeTransDate = strFmt('((("%1.%2" <= "%3") && ("%3" == "%5")) || ("%1.%4" > "%3"))',
tableStr(CustomTable),
fieldStr(CustomTable,TransDate),
date2strxpp(dateTo),
fieldStr(CustomTable,SettlementDate),
date2strxpp(dateNull()));
Assignment:
Translate the following natural language expressions to C++ expressions. Assume that all the variables are non-negative numbers or boolean (of value true or false).
Natural Language:
Either a and b are both false or c is true, but not both.
My solution:
(a==0 && b==0)xor(c==1)
Professors solution:
(!a && !b) != c
Questions:
I think I slightly understand the first bracket, by saying "not-a" and "not-b" I think that a and b must then be wrong, provided a b are assumed to be non-zero in the beginning. Right?
But what about the part that says "unequal to c"?
I don't understand the Professors solution, can anyone break it down for me?
Thank you for the help!
I'll assume that a, b and c are bool.
Let's draw some truth tables:
| a | !a | a==1 | a==0 |
| 0 | 1 | 0 | 1 |
| 1 | 0 | 1 | 0 |
As you can see, a and a==1 are equivalent, and !a and a==0 are also equivalent, so we can rewrite (a==0 && b==0)xor(c==1) as (!a && !b) xor c.
Now some more truth tables:
| a | b | a xor b | a != b |
| 0 | 0 | 0 | 0 |
| 0 | 1 | 1 | 1 |
| 1 | 0 | 1 | 1 |
| 1 | 1 | 0 | 0 |
So a!=b is equivalent to a xor b, so we can rewrite (!a && !b) xor c to (!a && !b)!=c. As you see, your solutions are fully equivalent, just written with different 'signs'.
UPD: Forgot to mention. There are reasons why professor's solution looks exactly in that way.
The professor's solution is more idiomatic. While your solution is technically correct, it's not an idiomatic C++ code.
First little issue is usage of types. Your solution relies on conversion between int and bool when you compare boolean value to a number or use xor, which is a 'bit-wise exclusive or' operator acting on ints too. In a modern C++ it is much more appreciated to use values of correct types and not to rely on such conversions as they're sometimes not so clear and hard to reason about. For bool such values are true and false instead of 1 and 0 respectively. Also != is more appropriate than xor because while technically bools are stored as numbers, but sematically you haven't any numbers, just logical values.
Second issue is about idiomacy too. It lies here: a == 0. It is not considered a good practice to compare boolean expressions to boolean constants. As you already know, a == true is fully equivalent to just a, and a == false is just !a or not a (I prefer the latter). To understand the reason why that comparing isn't good just compare two code snippets and decide, which is clearer:
if (str.empty() == false) { ... }
vs
if (not str.empty()) { ... }
Think booleans, not bits
In summary, your professor's solution is better (but still wrong, strictly speaking, see further down) because it uses boolean operators instead of bitwise operators and treating booleans as integers. The expression c==1 to represent "c is true" is incorrect because if c may be a number (according to the stated assignment) then any non-zero value of c is to be regarded as representing true.
See this question on why it's better not to compare booleans with 0 or 1, even when it's safe to do so.
One very good reason not to use xor is that this is the bit-wise exclusive or operation. It happens to work in your example because both the left hand side and right hand side are boolean expressions that convert to 1 or 0 (see again 1).
The boolean exclusive-or is in fact !=.
Breaking down the expression
To understand your professor's solution better, it's easiest to replace the boolean operators with their "alternative token" equivalents, which turns it into better redable (imho) and completely equivalent C++ code:
Using 'not' for '!' and 'and' for '&&' you get
(not a and not b) != c
Unfortunately, there is no logical exclusive_or operator other than not_eq, which isn't helpful in this case.
If we break down the natural language expression:
Either a and b are both false or c is true, but not both.
first into a sentence about boolean propositions A and B:
Either A or B, but not both.
this translates into A != B (only for booleans, not for any type A and B).
Then proposition A was
a and b are both false
which can be stated as
a is false and b is false
which translates into (not a and not b), and finally
c is true
Which simply translates into c.
Combining them you get again (not a and not b) != c.
For further explanation how this expression then works, I defer to the truth tables that others have given in their answers.
You're both wrong
And if I may nitpick: The original assignment stated that a, b and c can be non-negative numbers, but did not unambiguously state that if they were numbers, they should be limited to the values 0 and 1. If any number that is not 0 represents true, as is customary, then the following code would yield a surprising answer:
auto c = 2; // "true" in some way
auto a = 0; // "false"
auto b = 0; // "false"
std::cout << ((!a && !b) != c);
// this will output: 1 (!)
// fix by making sure that != compares booleans:
std::cout << ((!a && !b) != (bool)c);
I will tryto explain with some more words: Numbers can be implicitly converted to boolean values:
The value zero (for integral, floating-point, and unscoped enumeration) and the null pointer and the null pointer-to-member values become false. All other values become true.
Source on cppreference
This leads to the following conclusions:
a == 0 is the same as !a, because a is converted to a boolean and then inverted, which equals !(a != 0). The same goes for b.
c==1 will become only true when c equals 1. Using the conversion (bool)c would yield true when c != 0 not just if c == 1. So it can work, because one usually uses the value 1 to represent true, but it's not garantued.
a != b is the same as a xor b when a and b ar boolean expressions. It's true, when one value or the other is true, but not both. In this case the left hand side (a==0 && b==0) is boolean, so the right hand side c is converted to boolean too, thus, both sides are interpreted as boolean expressions, thus != is the same as xor in this case.
You can check all of this yourself with the truthtables that the other answers provided.
As we can see from the truth tables:
!(not) and ==0 give the same results.
!= and xor give the same results.
c==1 is the same as just c
So one under the other, shows why these 2 expressions give the same result:
(a==0 && b==0) xor (c==1)
(!a && !b) != c
Truth tables :
Not
| | ! |
| 0 | 1 |
| 1 | 0 |
==0
| |==0|
| 0 | 1 |
| 1 | 0 |
==1
| |==1|
| 0 | 0 |
| 1 | 1 |
And
| a | b | && |
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Not equal
| a | b | != |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
XOR
| a | b |xor|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
I'm trying to refactor an if-else chain that doesn't look particularly good. My common sense is telling me that I should be able to call my method only once but I can't figure out an elegant way to do it. Currently what I have is:
if(condition1)
do method1;
else if(condition2)
do method1;
Which looks hideous. There's repeat code! The best I can come up with is:
if(condition1 || (!condition1 && condition2))
do method1;
But this also looks bad, since I'm negating condition1 after the or, which seems unnecessary...
I made a truth table for this:
c1| c2| r
0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 1
And in case anyone is interested, the real-life problem I'm having is that I got 2 intances of Fancytree in javascript and I want to set some rules to transferring nodes between them. Tree A can only transfer lone nodes to Tree B, while Tree B can reorder itself freely, so I put this on Tree B's dragDrop event:
if(data.otherNode.tree === node.tree){
data.otherNode.moveTo(node, data.hitMode);
}
else if(!data.otherNode.hasChildren()){
data.otherNode.moveTo(node, data.hitMode);
}
You can simplify even more - if the first condition is true, the method should be invoked regardless of the second condition. So the !condition1 in your refactored code is redundant. Instead, you could just have:
if(condition1 || condition2)
do method1;
In modern programming languages the if condition will even short circuit. This means that when the first condition is evaluated as true, the second condition won't even get evaluated.
What you suggested,
if(condition1 || (!condition1 && condition2))
do method1;
Is logically the same as
if(condition1 || condition2)
do method1;
So I think that is your best answer.
It's not logically the same as your truth table though, so either your truth table or your current code is wrong, if truth table r is meant to do
do method1;
In writing
if (condition1 || condition2) {
//code1
}
if condition1 is correct code1 is executed and if condition1 is incorrect then only condition2 is checked and code proceeds accordingly. Hence it would be same as
if ( condition1 ) {
//method1
} else if ( condition2 ) {
//method1
}