Julia exercises

Author: Lidia Popescu

JuliaProject/.buildpath

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<buildpath>
+	<buildpathentry kind="src" path=""/>
+	<buildpathentry kind="con" path="org.eclipse.dltk.launching.INTERPRETER_CONTAINER"/>
+</buildpath>

JuliaProject/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>JuliaProject</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.dltk.core.scriptbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.juliacomputing.jldt.eclipse.core.nature</nature>
+	</natures>
+</projectDescription>

JuliaProject/Julia.jl

@@ -0,0 +1,7 @@
+function helloworld(count::Int)  
+  for i in 1:count
+    println("Hello world ", i)
+    println( BigInt(typemax(Int64)) + 1)
+  end
+end
+helloworld(3)

JuliaProject/ch1/HelloWorld.jl

@@ -0,0 +1,25 @@
+# Finished version of HelloWorld for Learning Julia course
+
+# Define a function that prints out a message
+# This creates a function with a single "method"
+function helloworld()
+    println("Hello World!")
+end
+
+# By defining another version of the function with different
+# arguments, we create another "method" - Julia will choose
+# the right one based on the arguments. This is called 
+# "multiple dispatch"
+function helloworld(count::Int)
+    for i in 1:count
+        println("Hello World ", i)
+    end
+end
+
+# call the version with no arguments
+helloworld()
+# call the version that takes a number
+helloworld(3)
+# try calling the function with a string - this will error
+# because we have not defined a method that takes a string
+#helloworld("today")

JuliaProject/ch2/Numbers.jl

@@ -0,0 +1,35 @@
+# Finished example file for Julia number types
+
+# Julia defines a set of specific sub-types for numbers
+# Signed integers: Int, Int8, Int16, Int32, Int64, BigInt
+
+a = Int16(1)
+println(typeof(a))
+
+b = Int(2000)
+println(typeof(b))
+
+# Unsigned integers: UInt, UInt8, UInt16, UInt32, UInt64
+c = UInt16(1)
+println(typeof(c))
+
+# typemax() and typemin() will provide max and min values
+println(typemax(Int8))
+println(typemax(Int32))
+println(typemin(Int64))
+
+# Use the WORDSIZE property to see what type of system this is 
+println(Sys.WORD_SIZE)
+
+# trying to assign a number too large for the type
+# will fail and give an error
+# a = UInt8(300) # 300 is too large for an 8 bit value
+
+# special values represent Infinity and not-a-number
+println(1.0 / 0.0)
+println(1.0 / Inf)
+println(0.0 / 0.0)
+
+# zero() and one() functions produce values for a given type
+println(zero(Float64))
+println(one(UInt32))

JuliaProject/ch2/Strings.jl

@@ -0,0 +1,38 @@
+# Finished example file for working with chars and strings in Julia
+
+# Julia has a specific character type
+mychar = 'x'
+println(Int(mychar))
+println(Char(120))
+
+# Strings are defined using double quotes or triple quotes
+mystr = "This is a sample string in Julia"
+myotherstr = """
+    Hello There
+    This is a string
+    """
+
+# Get the length of a string
+println(length(mystr))
+
+# Access individual characters - note that they are 1-indexed
+println(mystr[1])
+println(mystr[end])
+println(mystr[2:end - 1])
+
+# Iterate over characters
+for c in mystr
+    print(c)
+end
+println()
+
+# String concatenation using *
+w1 = "Hello"
+w2 = "World"
+println(w1 * ", " * w2 * ".")
+
+# String interpolation
+a = 5
+b = 10
+println("The result of $a + $b is $(a + b)")
+

JuliaProject/ch2/Variables.jl

@@ -0,0 +1,44 @@
+# Declaring variables and using data types in Julia
+
+# 5 basic types of data:
+# Integers, Floating point numbers, booleans, strings, and characters
+
+# Variable names typically are lowercase. Use underscores if the name
+# is too long to be easily read.
+first = 1
+second = 2.0
+stringvar = "This is a string"
+initial = 'J'
+boolval = true
+
+println(first)
+println(second)
+println(stringvar)
+println(initial)
+println(boolval)
+
+# variables can be redefined and change type
+first = 1.0
+println(first)
+
+# Strings have to be in double quotes. This will error:
+# anotherstring = 'hello world'
+
+# Constant values are declared with const and are all uppercase
+# Note: this is only useful in the global scope
+const MEANING_OF_LIFE = 42
+# Constants of the same type *can* be reassigned, but with a warning
+#MEANING_OF_LIFE = 43
+#println(MEANING_OF_LIFE)
+
+# Constants of different types cannot be reassigned, this is an error
+# MEANING_OF_LIFE = 43.0
+
+# Type Annotation identifies a variable as a particular type
+function testfunc()
+    x::String = "some text"
+    # the next line causes an error, x is defined as an Int
+    x = 10
+end
+#testfunc()
+

JuliaProject/ch3/BuildIn.jl

@@ -0,0 +1,50 @@
+# Starting example for built in functions in Learning Julia
+
+# numeric functions
+# TODO: round, floor, ceil, abs
+x = round(30.5)
+#println(x)
+
+# text i/o
+# TODO: print, println
+x= round(30.5, RoundUp)
+#println(x)
+
+
+y = 29.95
+#println(floor(y))
+#println(ceil(y))
+    
+z= -15
+#println(abs(z))
+  
+#print("Hello")
+#print("there")
+#println("world!")
+
+# TODO: printstyled
+thestr = "This is some text"
+printstyled(thestr)
+println()
+printstyled(thestr, bold=true)
+println()
+printstyled(thestr, bold=true, color=:red)
+println()
+
+# read standard input
+# TODO: readline
+print("What is your name: ")
+str =  readline()
+println(str)
+
+# TODO: "is" functions
+println(isascii("abc"))
+println(isascii("αβγ"))
+
+println(isdigit('9'))
+println(isdigit('a'))
+
+println(isspace(' '))
+println(isspace('\r'))
+println(isspace('\n'))
+println(isspace('A'))

JuliaProject/ch3/Convert.jl

@@ -0,0 +1,34 @@
+# Starting point example for converting data types in Learning Julia
+
+# declare some basic data types
+x = 10
+y = 20.0
+z = "40"
+f = "30.0"
+
+# TODO: Convert an integer to a character and vice versa
+c = Char(74)
+println(c)
+
+i = Int('J')
+println(i)
+
+# TODO: convert between types
+flt1 = Float32(x)
+int1 = Int16(y)
+println(flt1, ", ", int1)
+
+# TODO: parse values from a string
+a= parse(Int, z)
+b= parse(Float64, f)
+c= string(y)
+println(a)
+println(b)
+println(c)
+
+# TODO: attempting to convert a data type that won't fit is an error
+x= Char(281)
+println(x)
+
+a= UInt8(x)
+# println(a)  ERROR: LoadError: InexactError: trunc(UInt8, 281)

JuliaProject/ch3/Vector.jl

@@ -0,0 +1,17 @@
+# Starting point for dot operator sample for Learning Julia
+
+# TODO: The dot operator applies an operation to a collection
+arr1 = [2,4,6,8,10]
+println(arr1)
+
+result = arr1 .*2
+println(result)
+
+# TODO: functions can also be applied to collections this way
+result = sqrt.(arr1)
+println(result)
+
+# TODO: custom functions can also be used this way
+f(x) = 3x
+result = f.(arr1)
+println(result)

JuliaProject/ch4/Conditionals.jl

@@ -0,0 +1,23 @@
+# Starting point for conditional example for Learning Julia
+
+# TODO: Create an if-else conditional
+x = 5
+
+if x < 10
+  println("x is small")
+else
+  println("x is big")
+end
+
+# TODO: multiple conditions can be specified with if-elseif-else
+if x < 17
+  println("x is small")
+elseif x >= 10 && x < 25
+  println("x is medium")
+else 
+  println("x is big")
+end
+
+
+# TODO: The ternary operator can condense a comparison
+println(x < 10 ? "x is less than 10" : "x is 10 or greater")

JuliaProject/ch4/Exceptions.jl

@@ -0,0 +1,18 @@
+# Starting example file demonstrating exceptions for Learning Julia
+
+# Exceptions provide a way for a program to handle one or more 
+# unexpected conditions
+
+arg = -9
+
+# TODO: the try / catch / finally construct is used to work with exceptions
+try
+	x = sqrt(arg)
+	println(x)
+catch ex
+  println(ex)
+finally
+  println("This section of code always works")
+end
+
+

JuliaProject/ch4/Functions.jl

@@ -0,0 +1,44 @@
+# Starting functions example for Learning Julia
+
+# TODO: Functions are defined with the function keyword and are usually
+# lowercase names, optionally with underscores if they are hard to read
+function myfunc(a,b)
+  println("This is function")
+  a+b
+end
+
+result = myfunc(10,15)
+println(result)
+
+# TODO: function arguments can have default values
+function foo(a, b, z =10)
+  return (a+b) * z
+end
+println(foo(2,3))
+println(foo(2,3,5))
+
+# TODO: you can also use keyword arguments - define them after a semicolon
+function bar(a, b ; multiplier =10)
+  return (a+b) * multiplier
+end
+println(bar(4,5))
+println(bar(multiplier = 5, 4, 5))
+
+
+# TODO: The Julia shorthand way of defining a function 
+myfunc2(x,y) = (a = x-1 ; 2a+y)
+result =  myfunc2(3,4)
+println(result)
+
+# TODO: use the ... notation for variable arguments
+function summit(args...)
+    sum = 0
+    # TODO: process each argument
+    for a in args
+      sum += a
+    end
+    return sum
+end
+println(summit(1, 5, 10))
+println(summit(2, 4, 6, 8))
+