Services | Embedded Support | Reviews | Virtual Technologys: tutorial

Showing posts with label tutorial. Show all posts

Solving a Linear Systes of Equations Using python

Solving linear systems of equations is straightforward using the scipy command linalg.solve. This command expects an input matrix and a right-hand-side vector. The solution vector is then computed. An option for entering a symmetrix matrix is offered which can speed up the processing when applicable. As an example, suppose it is desired to solve the following simultaneous equations:

$\begin{eqnarray*} x+3y+5z & = & 10\\ 2x+5y+z & = & 8\\ 2x+3y+8z & = & 3\end{eqnarray*}$

We could find the solution vector using a matrix inverse:

$\left[\begin{array}{c} x\\ y\\ z\end{array}\right]=\left[\begin{array}{ccc} 1 & 3 & 5\\ 2 & 5 & 1\\ 2 & 3 & 8\end{array}\right]^{-1}\left[\begin{array}{c} 10\\ 8\\ 3\end{array}\right]=\frac{1}{25}\left[\begin{array}{c} -232\\ 129\\ 19\end{array}\right]=\left[\begin{array}{c} -9.28\\ 5.16\\ 0.76\end{array}\right].$

However, it is better to use the linalg.solve command which can be faster and more numerically stable. In this case it however gives the same answer as shown in the following example:

>>> import numpy as np
>>> from scipy import linalg
>>> A = np.array([[1,2],[3,4]])
>>> A
array([[1, 2],
      [3, 4]])
>>> b = np.array([[5],[6]])
>>> b
array([[5],
      [6]])
>>> linalg.inv(A).dot(b) #slow
array([[-4. ],
      [ 4.5]]
>>> A.dot(linalg.inv(A).dot(b))-b #check
array([[  8.88178420e-16],
      [  2.66453526e-15]])
>>> np.linalg.solve(A,b) #fast
array([[-4. ],
      [ 4.5]])
>>> A.dot(np.linalg.solve(A,b))-b #check
array([[ 0.],
      [ 0.]])

Tcl and OTcl Tutorial for NS2 - Program to find Factorial

Fractorial Computation: tcl script to obtain the value of 10! = 10 * 9 * ... * 1.

get factorial.tcl and run the script;
write a function to compute 2^x, test your answer.

Execute the script as:

$ tclsh lab1a.tcl

$ ns lab1a.tcl

################################################################################

#filename : factorial.tcl
# define function to compute Factorial X!
proc Factorial {x} {
# define variable
set result 1

# for loop
for {set i 1} {$i <= $x} {incr i} {
set result [expr $result * $i]
}

# return computation result
return $result
}

#############################################################################

# define function to compute 2^x
proc 2pow {x} {
# define variable
set result 1

# for loop
for {set i 1} {$i <= $x} {incr i} {
# fill in here
}

# return computation result
return $result
}
# make function call
set result [Factorial 10]

# output result
puts "$result"

# make function call
set result [2pow 10]

# output result
puts "$result"

Procedures

Procedures are an essential component of Tcl and can be used to make programming ns simpler. As in any functional programming language, procedures can be used for repetitive tasks, or simply to logically break down the tasks in the program.Procedures are defined in Tcl as follows:

proc proc1 {} {
puts "in procedure proc1"
}

This defines a procedure that takes no parameters and prints out "in procedure proc1". To call this procedure

proc1

can be used.A procedure with parameters can be defined as follows:

proc proc2 {parameter1} {
puts "the value of parameter1 is $parameter1"
}

This procedure can be invoked as follows:

proc2 10

A procedure that returns a value can be defined as follows:

proc proc3 {min max} {
set randomvar [rand $min $max]
return $randomvar
}

This procedure generates a random variable and returns it to the calling function. This can be invoked as follows

set randomvar [proc3 0 1]

to obtain a uniform random value between 0 and 1.Sometimes it is necessary within a procedure to reference a variable that has global scope. This is the purpose of the global keyword. So, for example, in an ns script, the simulator object typically is called ns, and typically has global scope. So, it could be referenced in a procedure as follows:

proc proc4 {} {
global ns
$ns at 10.0 "exit 0"
}

A logical way to break down an ns script can be as follows:

set ns [new Simulator]
create_topology
create_agents
create_sources
create_recorders
$ns run

where create_topology, create_agents, create_sources and create_recorders are all procedures.

For loops

For loops are very useful in ns and can be used in conjunction with arrays to easily create larger network topologies. To generate 100 nodes, the following code can be used:

for {set i 0}{$i < 100}{incr i} {
set n($i) [$ns node]
}

While loops

These are very similar to for loops. The syntax is

set i 0
while {$i < 10} {
set n($i) [new Node]
incr i
}

If statements

If statements are very simple

if {$i < 10} {
puts "i is less than 10"
}
if {$var2 == "Tcl Variable 2"} {
puts "var2 = Tcl Variable 2"
}

Variables and arrays

Defining a variable in Tcl is very simple:

set var1 1
set var2 "Tcl Variable 2"

The variables can be referenced by prefixing the variable name with a $. For example to print the above variables, we can use

puts "var1=$var1, var2=$var2"

Any situation in which you require that the value of the variable be used is one in which the $ prefix should be added to the variable name. In some situations, it is necessary to use the variable name directly. For example

incr var1

can be used to increment var1. I guess you can think of it as the difference between call-by-reference and call-by-value: in the former case you use the variable name on its own, while in the latter you prefix it with a '$'.An alternative is to assign the results of a function to a variable. This can be done as follows:

set var3 [expr 5*10]

This sets the variable var3 to the result of calling the expr function with the parameter 5*10. The expr function attempts to evaluate the supplied parameter to derive a value. Tcl interprets the square brackets as delimiters for a nested command: it attempts to execute the command inside the square brackets and assigns the result to var3 in this case. The returned value will be 50. Hence, the value 50 will be assigned to var3.In Tcl all variables are represented internally as strings. Whether that string can be viewed as an integer or a floating point number only matters when you use a function that requires numeric arguments.
Tcl also supports arrays. These are very useful in ns for storing, say, nodes. Tcl supports arrays that can be indexed by simple numeric arguments, as is standard in most languages, but Tcl also supports arrays that can be indexed by arbitrary strings. It is not necessary to declare the size of the array in advance. Here, two example of arrays are given

set n(0) [$ns node]
set n(1) [$ns node]set opts(bottlenecklinkrate) 1Mb
set opts(ECN) "on"

In the first example the array is called n and the index is numeric. In the second, the array is called opts and the index is non-numeric.

First Tcl script for beginners: "Hello World"

Hope you all have installed ns2 , now we can go for coding
As the ns2 simulations work on tcl scripts so we should know about tcl
Here some simple steps to write the "hello world" program in tcl

we can write tcl codes in two ways in interactive mode and in batch mode

first we can have look to interactive mode

1.open the terminal
type $ ns
2. a command prompt open
Create a new simulator object by using the command

set ns [ new Simulator ]