Tuesday, April 3, 2018

Swift 4 Introduction Series 1.7 - Swift Operators

Swift Operators

Swift support most of the standard operator other programming language uses. In addition, Swift improves the safety while using these operators.  


All standard operators are classified into 3 types of operator. They are:
  • Unary Operator: Unary operator works with a single operand. It can be placed in front of an operand (prefix) or placed behind an operand (postfix). Examples of prefix unary operator are -variable1, -10 and !variable2. Example of postfix unary operator is variable3!   
  • Binary Operator: Binary operator works in between 2 operand. Examples of binary operator are a + b, c / d and e * f
  • Ternary Operator: Ternary operator works with 3 operand. There is only one ternary operator in Swift; it is the ternary conditional operator (a ? b : c)


In a statement 1 + 2, the plus sign is the operator and the numbers are operands.

Assignment Operator

The most common and basic operator is the assignment operator. The basic syntax is as follows:


<variable_name> = <value/expression_that_fits_to_the_datatype>


Example:
var sampleNumber1 = 0

sampleNumber1 = 256

let sampleNumber2 = 242

sampleNumber1 = sampleNumber2

print(sampleNumber2)




For tuples, we can assign multiple value to multiple variables/constant at once.


Example:
let (a, b, c) = (12, 2.78, "Test")
a
b
c




Assignment Operator Do Not Return Value

Unlike other programming language, Swift assignment operator does not return a number or boolean value.


In C programming, we can combine assignment statement with if such as if a = b {...}. In C programming, a = b will return true if the assignment is successful.


We cannot combine assignment and if statement in Swift because the assignment statement in Swift do not return anything. To compare an assigned value we must use comparison operator.


Arithmetic Operator

Similar to other programming language, we have the standard arithmetic operator as shown below:


  • Addition (+)
  • Subtraction (-)
  • Multiplication (*)
  • Division (/)


The abovementioned arithmetic operator are binary operator and it work between 2 operand as shown in the example below:


12+54

132 - 65

23*65

9823 / 3

// For division, please be aware of floating point data type
9823 / 3.0




Additional Note:
  • Please use floating point for division to get accurate result.
  • Please note that any number divide by zero will return error




As previously mentioned in the data type section, we do not have integer overflow in Swift. Swift will return error for any attempt of integer overflow.


Example:
let intMax = Int.max

// intMax is 9223372036854775807

//let test1 = intMax + 1
//Above statement will generate error remove the comment for testing




Remainder Operator

Remainder operator is denoted as %. This operator will return the remainder after a division is performed. For example 11 % 3 will return a remainder of 2 and 11 % 2 will give a remainder of 1. See example below.


Example
11 % 3

10 % 3

11 % 2




Rules of Remainder Operator

Swift use the following formula: a = (b * some multiplier) + remainder to derived the remainder. The sign of b is always ignore. Therefore, a % b and a % -b always give same answer. -a % b will give you negative number. Please also note that Swift remainder operator only work with integer and it doesn't work on floating point number.


Remainder Operator with Negative Number

The remainder operator also work with negative number. However the remainder will be negative only if the first operand (dividend) is negative. If the divisor is negative, the remainder will still be positive.


Example:
11 % 3

-11 % 3

11 % -3

-11 % -3



Modulus and Remainder Operator

A lot of programmers confuse between modulus and remainder operator. Some programming languages uses % as modulus operator and some programming language uses % as remainder operator.


Modulus operator and remainder operator yield the same result when performing division with positive number. The difference between the two types of operator differs when dealing with negative number.


See example below:


The following is the remainder operation using Swift:




The following is the modulus operation in Python 2.7 (available in Mac OS)


As shown above, if both dividend and divisor is positive or negative; the operator return the same result.


However, if dividend or divisor is negative, the result is different.


We would like to check when divisor is positive; what will happen to the remainder if we move the dividend from positive number to negative number.


Example:


for i in -12...12 {
   
   print("\(i) % 3 is \(i % 3)")
}


The result is as follows


From the remainder operation, we know that once the dividend is negative, the remainder will be negative.




For modulus operation, whether the dividend is negative or positive, the remainder is always positive. In addition, the computation of mod is different from Swift when the dividend is negative. To derived -11 % 3, Python use the formula (-multiples x multiples) + modulus. In our example, the multiple is derived as -4 x 3 = -12. Therefore, -12 + modulus = -11 thus modulus is 1. Please note that modulus must be positive. we cannot use -9 and -2(modulus) to derived -11.

Please note that for C type of programming language, such as C, C#, Java, JavaScript and Swift; the implementation is the same. Programming language such as Python, Smalltalk, Perl, MATLAB, Haskell and Common LISP are using the other type of implementation.

Please also note that some programming language provides 2 difference kind of implementation. In Python, to implement the remainder operation similar to Swift or C, we need to use math.fmod.


The previous section is not a comprehensive examination of difference between remainder and modulus operation. This is just a reminder to programmer that there are differences between modulus and remainder when we use them to deal with negative number.


Remainder for Floating Point Number

To use remainder for floating point number we can use the function remainder(_,_) or truncatingRemainder(dividingBy:)


Both functions produce different result. See example below"


We will not examine this in detail.


Unary Minus Operator

We can convert a positive number to negative number using the unary minus operator (-). See example below:


Example:


let a = 13

let b = -a

let c = -b




Note: We use the unary minus operator to convert from positive number to negative number. We can also use the same operator to convert negative number to positive number as shown above.


Unary plus operator has no effect in Swift.


Application of Arithmetic Operator



Example:


let unitPrice = 25.5
let quantity = 12546
let deposit = 10034.80

let amount = unitPrice * Double(quantity)

let discount = amount * 0.05

let discountAmount = -discount

let payableAmount = amount + discountAmount




// Continuation from previous code
let salesTax = payableAmount * 0.07

let totalAmount = payableAmount + salesTax

let cashPayment = totalAmount - deposit

let totalUnitCost = totalAmount / 12546




Compound Assignment Operator



Compound assignment operator such as a += x is a short form of writing a = a + x. We have the following type of compound assignment operator:


  • Addition (+=) same as a = a + x
  • Subtraction (-=) same as a = a - x
  • Multiplication (*=) same as a = a * x
  • Division (/=) same as a = a / x
  • Remainder (%=) same as a = a % x


Example:


var a = 10

a -= 1

a *= 2

a /= 2

a += 2

a %= 2




Note:
Compound statement do not return value.
You cannot use the following


   let var551 = var54 += 5
or
   let var551 = (var54 += 5)


Example:


var 54 = 10
//let var551 = (var54 += 5) // Will generate error warning


Comparison Operator

Comparison operator compare numbers and return if the test is true. The following are the comparison operators:


  • Equal (==)
  • Not Equal (!=)
  • Greater than (>)
  • Less than (<)
  • Greater than OR Equal to (>=)
  • Less than OR Equal to (<=)


Each comparison return a boolean value.


Example:


10 == 10
20 == 21

123 != 934
123 != 123

12476 > 887
12476 > 12476
12476 > 12477

768 < 409098
409098 < 409098
409099 < 409098




Example 2:


1776 >= 1775
1776 >= 1776
1776 >= 1777

7172 <= 7173
7172 <= 7172
7172 <= 7171




We can also compare tuples against tuples. The comparison worked by comparing each element from left to right. For equal (==) comparison, the system will compare the leftmost element with first element on the right; if it is equal and the result is true then the system will proceed to compare the second element. If it is not equal, the system will return false after the first comparison and stop the comparing operation.


let originalTuples = ("a", 12, 2.78)

// Only true when all element is true
originalTuples == ("a",12,2.78)
originalTuples == ("A",12,2.78)




Similarly, for not equal operation (!=), the system will compare each element. If the result is false (Equal), the system will compare the next element. If the comparison result is true (Not Equal), the system will stop comparing.

let originalTuples = ("z", 10, 2.788)

// Only false when all element is false
originalTuples != ("c",12,98)
originalTuples != ("z",10,2.788)
originalTuples != ("a",10,2.78)
// previous statement 2.78 is != 2.788




We can use the greater or less than sign to compare tuples element. The system


let originalTuples = ("a", 14, 2.7888) // For string or character it compares the ranking in the Unicode table // b is greater than a originalTuples > ("b", 14, 77.8) // character "2" is smaller than "a", did not compare 55.8 vs 2.788 originalTuples > ("2", 14, 55.8) // Return the last result since first 2 element is equal originalTuples > ("a", 14, 0.8) // Return the last result since first 2 element is equal originalTuples > ("a", 14, 55.8) // Return the second result since first element is equal, ignore last element originalTuples > ("a", 56, 0.08) // Return the second result since first element is equal, ignore last element originalTuples > ("a", 3, 55.8)





Note:
Please note that we can compare character or string in addition of numbers. However, we cannot use greater than or less than sign for boolean variables. Using greater for less than sign for boolean variables will generate error. For Boolean variables, we can use equal or not equal comparison.


Example:
The following examples shows tuples comparison with Boolean variables


let someOriginalTuples = (true, false, 12)
someOriginalTuples == (false, false,12)
someOriginalTuples == (true, false, 12)




If we use Boolean variable with greater or less than sign, it will generate error.




Important Note:
The comparator operator is able to compare tuples with 6 element or less. If our tuples have 7 or more element, we must implement the comparison individually.


Example:
The following example shows the maximum number of element tuples can be used for comparison with comparison operator.


let someOriginalTuples3 = (1, 2, 3, 4, 5, 6)
someOriginalTuples3 > (0, 1, 2, 3, 4, 5)




Example:
The following example shows failed comparison if we are comparing 7 or more element in a  tuples.




To perform 7 element comparison, use the example below:


let someOriginalTuples4 = (1, 2, 3, 4, 5, 6, 7)
someOriginalTuples4.0 > 0
someOriginalTuples4.1 > 1
someOriginalTuples4.2 > 2
someOriginalTuples4.3 > 3
someOriginalTuples4.4 > 4
someOriginalTuples4.5 > 5
someOriginalTuples4.6 > 6




Ternary Conditional Operator

Ternary operator consist of 3 parts. The syntax is as follows:


<query>?<answer1>:<answer2>


The system will evaluate the query and if the expression evaluate to true, then the system will return the evaluated value of answer1. If the query is false, the system will return the evaluated value of answer2.


Ternary operator is the condensed version of the following code:


if query {
answer1
} else {
answer2
}


Example:


var result = ""
let student1 = 65

result = student1 > 50 ? "pass" : "fail"

print("Student 1 \(result)")






The ternary operator is similar to the code below:


var result = ""
let student1 = 65

if student1 > 50 {
  result = "pass"
} else {
   result = "fail"
}

print("Student 1 \(result)")




As ternary operator is hard to understand, so we are encourage to use it wisely and avoid combining multiple ternary operation into one compound statement


Nil-Coalescing Operator

Nil-coalescing operator (??) unwraps the value of an optional variable if it is not nil. If the optional variable is nil, it will default to the second provided value. The syntax is as follows:


<optional_variable> ?? <value_used_when_optionl_is_nil>
For example, let consider userDefineColor ?? defaultColor. The variable userDefineColor is an optional. If there is value in this variable then the system will unwrap the value in this variable. If on the other hand this variable is found to be nil, then the system will use the value defaultColor.


The whole construct can be form using the program below:


if userDefineColor != nil {
colorUsed = userDefineColor
} else {
colorUsed = defaultColor
}


Example:


let defaultColor = "red"
let userDefinedColor:String? = nil

let colorUsed = userDefinedColor ?? defaultColor

print("Color used is \(colorUsed).")


If our optional contains value, then the value will be unwrapped and utilized.


let defaultColor = "red"
let userDefinedColor:String? = "green"

let colorUsed = userDefinedColor ?? defaultColor

print("Color used is \(colorUsed).")





Range Operator

There are three types of range operator, the closed range operator, half-open range operator and one-sided range operator.


Closed Range Operator

Closed range operator is represented by (...). Closed range operator include the begin number and end number. To use closed range operator, please follow the syntax:


<begin_number>...<end_number>


Example:


1...10

let set1 = 1...16




We can use close range operator to define a range of index as shown in the example below:


for index in 1...10 {
    print("Item: \(index)")
}




Half-Open Range Operator

Half-open range operator is represented by (..<). It include the first number and the number less than the last number (last_number - 1). The syntax is as follows:


<begin_number>..<<last_number>


Example


for index in 1..<10 {
    print("Item:\(index)")
}




Half-range operator is useful when referencing arrays or any data index that starts from 0 and ends at total count less one.


Example:


let myArrays = [0,1,2,3,4,5,6,7,8,9]

let count = myArrays.count

for index in 0..<count {
    print("Number: \(index)")
}




Application of Range Operators

We can also use range operators as subscripts in an array. Listed below is an example using range operators with array.


let someArrayA = [1,2,3,4,5,6,7,8,9,10]
someArrayA[0]
someArrayA[9]
someArrayA.count
someArrayA.last

someArrayA[3...7]
someArrayA[3..<7]




We can also define range and use it in any other context besides subscripts:


// Define closed range
let someRange1 = 1...10
for index in someRange1 {
   print(index)
}
// Print 1 to 10

// Define half open range
let someRange2 = 1..<16
for index in someRange2 {
   print(index)
}
// Print 1 to 15





One-Sided Range Operator

One-sided range operator is range operator without a beginning or end number. It can be apply to any closed range operator or half-open range operator.

One-Sided Close Range Operator

One-sided close range operator can be written as


...5 or 1…


The interpretation of one-sided operator is as follows:
  • ...5 - tell the system to count from beginning of index (could be 0 or 1) to 5 inclusive.
  • 1… - tell the system to count from 1 to the end of index.


One-Sided Half Open Range Operator

One-sided half open range operator can be written as


..<10




For half open range operator, Swift only support the one-sided half open range operator with the end index included as shown above.


We cannot do (0..<) as shown in the screen below.

Listed below is an example of application of one-sided range operator.


let someArrayB = [1,2,3,4,5,6,7,8,9,10]
someArrayB[0]
someArrayB[9]
someArrayB.count
someArrayB.last

someArrayB[3...7]
someArrayB[1...]
someArrayB[...7]

someArrayB[3..<7]
someArrayB[..<5]




Limit of One-Sided Range Operator

We can also use one-sided range operator in any other context besides array subscripts. However, if the range is one-sided, what are the limits? The range is limited to the maximum and the minimum of an integer.


Please see example below:


// Define range from 1 t0 maximum of an Int can handle
let someRange3 = 1...
someRange3.contains(100)
someRange3.contains(100000000)
let rangeMax = Int.max
someRange3.contains(rangeMax)

// Define range from Int minimum to 100 inclusive
let someRange4 = ...100
someRange4.contains(10000)
someRange4.contains(100)
someRange4.contains(-11000000)
let rangeMin = Int.min
someRange4.contains(rangeMin)

// Define range from Int minimum to 100 inclusive
let someRange5 = ..<1000
someRange5.contains(1000)
someRange5.contains(999)
someRange5.contains(-766999)
someRange5.contains(rangeMin)




Please note that if we enter a number that is beyond the limits of an integer, runtime or compile error will occurs.


Logical Operator

In Swift, we support 3 logical operator, they are the NOT, AND and OR.


  • NOT operator is denoted as !
  • AND operator is denoted as &&
  • OR operator is denoted as ||


Logical NOT Operator

We can use logical NOT operator as a unary prefix. A NOT in front of true will be false and vice versa. The syntax of using NOT operator is as follows:


!<variable/data>


Example


let myTruth = false

let myNewTruth = !myTruth

print("My truth is \(myTruth) and my new truth is \(myNewTruth).")




Logical AND Operator

We use logical AND operator as a binary operator in between 2 operand. The syntax of using AND operator is as follows:


<variable/data> && <variable/data>


Example


let myDoorCode = true

let myFingerPrint = false

if myDoorCode && myFingerPrint == true {
   print("Access Granted")
} else {
   print("Access Denied")
}




Note:
Please note that for AND operator, the system use short circuit evaluation. This means that the system will evaluate the left most conditional statement and if the first evaluation is false, the system will stop further evaluation because even if the second evaluation is true the result will still be false. We should place the statement that commonly generate false result on the left hand side of evaluation to increase efficiency.


Logical OR Operator

We use logical OR operator as a binary operator in between 2 operand. The syntax of using OR operator is as follows:


<variable/data> || <variable/data>


Example:


let myDoorCode = true

let myFingerPrint = false

if myDoorCode || myFingerPrint == true {
   print("Access Granted")
} else {
   print("Access Denied")
}




Note:
Similarly, for OR operator, the system also use short circuit evaluation. This means that the system will evaluate the left most conditional statement and if the first evaluation is true, the system will stop further evaluation because even if the second evaluation is false the result will still be true. We should place the statement that commonly generate true result on the  left hand side of evaluation to increase efficiency.


Compound Logical Operator

We use multiple logical operator to form a compound expression. The system will evaluate the leftmost expression first and to the right. Please note that however && has precedence over ||. You need to evaluate && operation from left to right and then evaluate || from left to right.


Example:


let myDoorCode = true

let myFingerPrint = false

let keyOverride = true

let overridePassCode = true

if myDoorCode && myFingerPrint || keyOverride && overridePassCode {
   print("Access Granted")
} else {
   print("Access Denied")
}




In the example above, the system allowed 2 combination for user to enter the gate. Either the user enter the door code correct together with a correct fingerprint scan or; the user can use manual override key together with a correct override passcode.


To improve readability, the above example should be written as follows:




Operator AND has Precedence Against Operator OR

While we construct compound statement, please be aware that operator AND has a higher precedence level compared to operator OR.


Please check the example below:


// The following evaluate to true since AND has precedence over OR
true || false && false

// To produce the false result we must use () as shown below
(true || false) && false




More example:


let condition1 = true
let condition2 = false
let condition3 = true
let condition4 = false

condition1 || condition2 && condition3 && condition4
// Please note that && has precedence over || You need to evaluate && operation from left to right and then evaluate || from left to right




Example:


true || false && true && false
true && false || false || true
true && true || false && false
false || true && true || false




Operator Precedence



Operator precedence is the order of computing the operator. Consider the example below:


Example:
42 - 20 * 12 / 3 + 5 * 6 + 54
// The result is 46


For some programming language, all the arithmetic operator got the same precedence; this means that the system will evaluate the computation in the order from left to right. The result will be 612 if we evaluate from left to right.


Most programming language however, adopt the common precedence where multiplication and division have the same precedence but they are placed in a higher order than addition and subtraction.


In the example above, we should evaluate the multiplication and division first from left to right. After multiplication and division are evaluated, then we start evaluation addition and subtraction from left to right.


To change the order of precedence, such as we want to perform a subtraction first, we can add parenthesis to affect the order. Parenthesis has a higher precedence than the other arithmetic operator.


Example:


42 - 20 * 12 / 3 + 5 * 6 + 54
(42 - 20) * 12 / 3 + 5 * (6 + 54)




In the example above, the system will perform computation in the parenthesis first before resuming normal arithmetic operation. The result is different.


Similarly, we can also use parentheses to affect the order of evaluation when we use logical operator as shown in the previous section.


Listed below is a simplified table of the operator precedence. All operators under the same group have the same precedence. Left associative means the system will evaluate the expression from left to right. Right associative means that the system will evaluate the expression from right to left. Operator on the top of the list has higher precedence than the operator at the bottom of the list.
Precedence group
Operator
Description
Associativity
Primary Expression
( )
Parenthesis
Left associative
Prefix Operator
!
-
..<
...
Logical NOT
Unary Minus
Half-open range
Closed range
None
None
None
None
Postfix Operator
...
Closed range
None
Multiplication
*
Multiply
Left associative

/
Divide
Left associative

%
Remainder
Left associative
Addition
+
Add
Left associative

-
Subtract
Left associative
Range formation
..<
Half-open range
None

...
Closed range
None
Nil-Coalescing
??
Nil-Coalescing
Right associative
Comparison
<
Less than
None

<=
Less than or equal
None

>
Greater than
None

>=
Greater than or equal
None

==
Equal
None

!=
Not equal
None
Logical conjunction
&&
Logical AND
Left associative
Logical disjunction
||
Logical OR
Left associative
Ternary
?:
Ternary conditional
Right associative
Assignment
=
Assign
Right associative

*=
Multiply and assign
Right associative

/=
Divide and assign
Right associative

%=
Remainder and assign
Right associative

+=
Add and assign
Right associative

-=
Subtract and assign
Right associative
Function Arrow
->
Function Arrow
Right associative


Explicit Parentheses

For complex expression, it is better to use bracket or parentheses to organize the expression. It also improve code readability.


Example:


let condition5 = true
let condition6 = false
let condition7 = true
let condition8 = false

condition5 || condition6 && condition7 && condition8
// Evaluate to true as && take precedence before ||

// With parentheses the result may be different
(condition5 || condition6) && (condition7 && condition8)



***

No comments:

Post a Comment