DOCSLIB.ORG

Subroutines – Get Efficient

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

Subroutines – get efficient So far: The code we have looked at so far has been sequential: Subroutines – getting efficient with Perl do this; do that; now do something; finish; Problem Bela Tiwari You need something to be done over and over, perhaps slightly [email protected] differently depending on the context Solution Environmental Genomics Thematic Programme Put the code in a subroutine and call the subroutine whenever needed. Data Centre http://envgen.nox.ac.uk Syntax: There are a number of correct ways you can define and use Subroutines – get efficient subroutines. One is: A subroutine is a named block of code that can be executed as many times #!/usr/bin/perl as you wish. some code here; some more here; An artificial example: lalala(); #declare and call the subroutine Instead of: a bit more code here; print “Hello everyone!”; exit(); #explicitly exit the program ############ You could use: sub lalala { #define the subroutine sub hello_sub { print "Hello everyone!\n“; } #subroutine definition code to define what lalala does; #code defining the functionality of lalala more defining lalala; &hello_sub; #call the subroutine return(); #end of subroutine – return to the program } Syntax: Outline review of previous slide: Subroutines – get efficient Syntax: #!/usr/bin/perl Permutations on the theme: lalala(); #call the subroutine Defining the whole subroutine within the script when it is first needed: sub hello_sub {print “Hello everyone\n”;} ########### sub lalala { #define the subroutine The use of an ampersand to call the subroutine: &hello_sub; return(); #end of subroutine – return to the program } Note: There are subtle differences in the syntax allowed and required by Perl depending on how you declare/define/call your subroutines. 1 #!/usr/bin/perl Subroutines – get efficient my $thing1 = “something”; my $thing2 = “anotherthing”; Parameters and Return Values some code here; some more here; Parameters giving the subroutine values/information to work with my $whatIwant = lalala($thing1, $thing2); #call the subroutine here given by putting the required information in between the #and put whatever is returned into subroutine brackets when the subroutine is called () #the variable $whatIwant a bit more code here; e.g. lalala($firsthing, $secondthing) exit(); #explicitly exit the program Return values getting information out of the subroutine ######### subroutines always return a value sub lalala { #define the subroutine if you provide a return statement with no explicit value to code to get the values of $thing1 and $thing2 into subroutine variables send back, it will return true (1) if it succeeded code to define what lalala does; #code defining lalala code to give a value to a variable called $output ; if you provide no return statement, the subroutine will return the value of the last statement it evaluated return($output); #end of subroutine – return the value $output you can program subroutines to return values of } your choice $whatIwant = lalala($thing1, $thing2); $thing1 and $thing2 are now in an array called @_ $thing1 is now $_[0] #the first element of @_ $thing2 is now $_[1] #the second element of @ ######### my $whatIwant = lalala($thing1, $thing2); sub lalala { #need to retrieve the values from @_ array and put them into variables #within our subroutine ######### my $funcvar1 = shift (@_); #take the first element of the array (has the same value as $thing1) sub lalala { code to get the values of $thing1 and $thing2 into subroutine variables my $funcvar2 = shift (@_); #take the second element of the array (the same value as $thing2) return(); return(); } } $whatIwant = lalala($thing1, $thing2); ######### $whatIwant = lalala($thing1, $thing2); sub lalala { my $funcvar1 = shift; #where is @_ Hey, wait! Does that look familiar? #$funcvar1 has the value of $thing1 my $funcvar2 = shift; #where is @_ $seq_length = length($seq); #$funcvar2 has the value of $thing2 $last_thing = pop(@array1); return(); } Functions are really built-in subroutines!! ######################################################## Subroutines are just you writing your own functions! Even easier: (or using someone else’s functions) my ($funcvar1, $funcvar2) = @_; 2 More on getting values out of a subroutine Subroutines so far: Recall: Return values getting information out of the subroutine •What a subroutine is subroutines always return a value •How to call a subroutine if you provide a return statement with no explicit value to •How to pass parameters into a subroutine send back, it will return true (1) if it succeeded if you provide no return statement, the subroutine will return the value of the last statement it evaluated you can program subroutines to return values of Now: your choice ############## More on getting values out of a subroutine sub lalala { code to define what lalala does; more defining lalala; return(); # if lalala executes successfully, this would return the value 1 to your main program . } More on getting values out of a subroutine More on getting values out of a subroutine You can return a single value from a subroutine: If you do not specify a return statement, the subroutine will return the result of the final statement evaluated: sub lalala { code to give a value to a variable called $output ; sub lalala { return($output); #end of subroutine – return the value of $output bunchacode; } morecode; $total = $thing1 + $thing2; # $total will be returned in this case } Even more on getting values out of a subroutine More on “my”, variables and subroutines You can return a single value from a subroutine. You can return multiple values from a subroutine using a list. E.g. return (@array_of_values); So far we have declared our variables using “my” return ($val1, $val2); So far we have written “use strict” at the top of our scripts An Aside: When you are returning something very large, you can just give its address, So far we have glossed over why we do this…. rather than pass the whole thing in or out of the subroutine. That is, you can specify the location of values instead of their names. In other words, if you return the location of an array, you can use this location to access all the elements of that array 3 More on “my”, variables and subroutines #!/usr/bin/perl #simplesubfunc.pl use strict; use warnings; Variables declared using my are visible only to the block my ($number1, $number2); #declare scalar variables of code { } they are in. print "Enter a number: "; #main chomp ($number1 = (<STDIN>)); #body print "Enter another number :"; #of So, if you declare them at the top of a script, the whole chomp ($number2 = (<STDIN>)); #code script can see them. my $total = addition_sub ($number1, $number2); #go to subroutine #$total collects return value print "$number1 plus $number2 equals $total\n"; If you declare them inside a subroutine, only the exit(); subroutine can see them. ########## sub addition_sub { The term “lexical scoping” essentially refers to coding such that variables are “seen” my $number3 = $number1 + $number2; #declare a variable and add the numbers only where they should be, so that changing the values of variables in certain parts of return ($number3); #$number3 is only “seen” by the subroutine your program doesn’t inadvertently affect what happens to those variables in other #return value of $number3 from subroutine parts of your program. } #!/usr/bin/perl #simplesubfunc.pl #!/usr/bin/perl #simplesubfunc2.pl use strict; use strict; use warnings; use warnings; my ($number1, $number2); #declare scalar variables my ($number1, $number2, $number3 ); #now $number3 seen by #whole program print "Enter a number: "; #main chomp ($number1 = (<STDIN>)); #body print "Enter a number: "; print "Enter another number :"; #of chomp ($number1 = (<STDIN>)); chomp ($number2 = (<STDIN>)); #code print "Enter another number :"; chomp ($number2 = (<STDIN>)); my $total = addition_sub ($number1, $number2); #go to subroutine #$total collects return value addition_sub (); #nothing catches the return value print "$number1 plus $number2 equals $total\n"; #don’t need $number1 or $number2 b/c sub knows about them exit(); print "$number1 plus $number2 equals $number3\n"; ########## exit(); sub addition_sub { ########## my $number3 = $number1 + $number2; #declare a var and add the numbers #$number3 is only “seen” by the subroutine sub addition_sub { #no explicit return statement $number3 = $number1 + $number2; #don’t declare $number3 with my } #no explicit return statement } More on “my”, variables and subroutines – catinhat2.pl More on “my”, variables and subroutines – catinhat.pl #!/usr/bin/perl Recall: use strict; Variables declared using my are visible only to the block of code they are in. use warnings; my $catinhat = 5; # declare $catinhat in main program Thus – true for subroutines, but also foreach loops , while loops , if/else statements – anything where a block of code { } is defined. print “\nThe catinhat in my main program is $catinhat\n”; #!/usr/bin/perl subrout($catinhat); #pass value of main prog $catinhat to subrout use strict; use warnings; print “\nThe catinhat in my main program is still equal to $catinhat\n”; my $catinhat = 5; #declare and give value 5 to main prog’s $catinhat exit(); my @numarray = (1,2,3,4,5); ########### print “\nThe catinhat in my main program is $catinhat\n”; sub subrout { my $catinhat = shift; #declare $catinhat in subroutine foreach my $catinhat (@numarray) { #declare foreach block’s $catinhat print “\nThe catinhat in my subroutine is $catinhat\n”; $catinhat +=5; #play with foreach block’s $catinhat
Recommended publications
  • Writing Fast Fortran Routines for Python

    Writing Fast Fortran Routines for Python

    Writing fast Fortran routines for Python Table of contents Table of contents ............................................................................................................................ 1 Overview ......................................................................................................................................... 2 Installation ...................................................................................................................................... 2 Basic Fortran programming ............................................................................................................ 3 A Fortran case study ....................................................................................................................... 8 Maximizing computational efficiency in Fortran code ................................................................. 12 Multiple functions in each Fortran file ......................................................................................... 14 Compiling and debugging ............................................................................................................ 15 Preparing code for f2py ................................................................................................................ 16 Running f2py ................................................................................................................................. 17 Help with f2py ..............................................................................................................................
  • Chapter 4 Programming in Perl

    Chapter 4 Programming in Perl

    Chapter 4 Programming in Perl 4.1 More on built-in functions in Perl There are many built-in functions in Perl, and even more are available as modules (see section 4.4) that can be downloaded from various Internet places. Some built-in functions have already been used in chapter 3.1 and some of these and some others will be described in more detail here. 4.1.1 split and join (+ qw, x operator, \here docs", .=) 1 #!/usr/bin/perl 2 3 $sequence = ">|SP:Q62671|RATTUS NORVEGICUS|"; 4 5 @parts = split '\|', $sequence; 6 for ( $i = 0; $i < @parts; $i++ ) { 7 print "Substring $i: $parts[$i]\n"; 8 } • split is used to split a string into an array of substrings. The program above will write out Substring 0: > Substring 1: SP:Q62671 Substring 2: RATTUS NORVEGICUS • The first argument of split specifies a regular expression, while the second is the string to be split. • The string is scanned for occurrences of the regexp which are taken to be the boundaries between the sub-strings. 57 58 CHAPTER 4. PROGRAMMING IN PERL • The parts of the string which are matched with the regexp are not included in the substrings. • Also empty substrings are extracted. Note, however that trailing empty strings are removed by default. • Note that the | character needs to be escaped in the example above, since it is a special character in a regexp. • split returns an array and since an array can be assigned to a list we can write: splitfasta.ply 1 #!/usr/bin/perl 2 3 $sequence=">|SP:Q62671|RATTUS NORVEGICUS|"; 4 5 ($marker, $code, $species) = split '\|', $sequence; 6 ($dummy, $acc) = split ':', $code; 7 print "This FastA sequence comes from the species $species\n"; 8 print "and has accession number $acc.\n"; splitfasta.ply • It is not uncommon that we want to write out long pieces of text using many print statements.
  • 1. Introduction to Structured Programming 2. Functions

    1. Introduction to Structured Programming 2. Functions

    UNIT -3Syllabus: Introduction to structured programming, Functions – basics, user defined functions, inter functions communication, Standard functions, Storage classes- auto, register, static, extern,scope rules, arrays to functions, recursive functions, example C programs. String – Basic concepts, String Input / Output functions, arrays of strings, string handling functions, strings to functions, C programming examples. 1. Introduction to structured programming Software engineering is a discipline that is concerned with the construction of robust and reliable computer programs. Just as civil engineers use tried and tested methods for the construction of buildings, software engineers use accepted methods for analyzing a problem to be solved, a blueprint or plan for the design of the solution and a construction method that minimizes the risk of error. The structured programming approach to program design was based on the following method. i. To solve a large problem, break the problem into several pieces and work on each piece separately. ii. To solve each piece, treat it as a new problem that can itself be broken down into smaller problems; iii. Repeat the process with each new piece until each can be solved directly, without further decomposition. 2. Functions - Basics In programming, a function is a segment that groups code to perform a specific task. A C program has at least one function main().Without main() function, there is technically no C program. Types of C functions There are two types of functions in C programming: 1. Library functions 2. User defined functions 1 Library functions Library functions are the in-built function in C programming system. For example: main() - The execution of every C program starts form this main() function.
  • Eloquent Javascript © 2011 by Marijn Haverbeke Here, Square Is the Name of the Function

    Eloquent Javascript © 2011 by Marijn Haverbeke Here, Square Is the Name of the Function

    2 FUNCTIONS We have already used several functions in the previous chapter—things such as alert and print—to order the machine to perform a specific operation. In this chap- ter, we will start creating our own functions, making it possible to extend the vocabulary that we have avail- able. In a way, this resembles defining our own words inside a story we are writing to increase our expressive- ness. Although such a thing is considered rather bad style in prose, in programming it is indispensable. The Anatomy of a Function Definition In its most basic form, a function definition looks like this: function square(x) { return x * x; } square(12); ! 144 Eloquent JavaScript © 2011 by Marijn Haverbeke Here, square is the name of the function. x is the name of its (first and only) argument. return x * x; is the body of the function. The keyword function is always used when creating a new function. When it is followed by a variable name, the new function will be stored under this name. After the name comes a list of argument names and finally the body of the function. Unlike those around the body of while loops or if state- ments, the braces around a function body are obligatory. The keyword return, followed by an expression, is used to determine the value the function returns. When control comes across a return statement, it immediately jumps out of the current function and gives the returned value to the code that called the function. A return statement without an expres- sion after it will cause the function to return undefined.
  • Control Flow, Functions

    Control Flow, Functions

    UNIT III CONTROL FLOW, FUNCTIONS 9 Conditionals: Boolean values and operators, conditional (if), alternative (if-else), chained conditional (if-elif-else); Iteration: state, while, for, break, continue, pass; Fruitful functions: return values, parameters, local and global scope, function composition, recursion; Strings: string slices, immutability, string functions and methods, string module; Lists as arrays. Illustrative programs: square root, gcd, exponentiation, sum an array of numbers, linear search, binary search. UNIT 3 Conditionals: Boolean values: Boolean values are the two constant objects False and True. They are used to represent truth values (although other values can also be considered false or true). In numeric contexts (for example when used as the argument to an arithmetic operator), they behave like the integers 0 and 1, respectively. A string in Python can be tested for truth value. The return type will be in Boolean value (True or False) To see what the return value (True or False) will be, simply print it out. str="Hello World" print str.isalnum() #False #check if all char are numbers print str.isalpha() #False #check if all char in the string are alphabetic print str.isdigit() #False #test if string contains digits print str.istitle() #True #test if string contains title words print str.isupper() #False #test if string contains upper case print str.islower() #False #test if string contains lower case print str.isspace() #False #test if string contains spaces print str.endswith('d') #True #test if string endswith a d print str.startswith('H') #True #test if string startswith H The if statement Conditional statements give us this ability to check the conditions.
  • The Return Statement a More Complex Example

    The Return Statement a More Complex Example

    We Write Programs to Do Things Anatomy of a Function Definition • Functions are the key doers name parameters Function Call Function Definition def plus(n): Function Header """Returns the number n+1 Docstring • Command to do the function • Defines what function does Specification >>> plus(23) Function def plus(n): Parameter n: number to add to 24 Header return n+1 Function Precondition: n is a number""" Body >>> (indented) x = n+1 Statements to execute when called return x • Parameter: variable that is listed within the parentheses of a method header. The vertical line Use vertical lines when you write Python indicates indentation on exams so we can see indentation • Argument: a value to assign to the method parameter when it is called The return Statement A More Complex Example • Format: return <expression> Function Definition Function Call § Used to evaluate function call (as an expression) def foo(a,b): >>> x = 2 § Also stops executing the function! x ? """Return something >>> foo(3,4) § Any statements after a return are ignored Param a: number • Example: temperature converter function What is in the box? Param b: number""" def to_centigrade(x): x = a A: 2 """Returns: x converted to centigrade""" B: 3 y = b C: 16 return 5*(x-32)/9.0 return x*y+y D: Nothing! E: I do not know Understanding How Functions Work Text (Section 3.10) vs. Class • Function Frame: Representation of function call Textbook This Class • A conceptual model of Python to_centigrade 1 Draw parameters • Number of statement in the as variables function body to execute next to_centigrade x –> 50.0 (named boxes) • Starts with 1 x 50.0 function name instruction counter parameters Definition: Call: to_centigrade(50.0) local variables (later in lecture) def to_centigrade(x): return 5*(x-32)/9.0 1 Example: to_centigrade(50.0) Example: to_centigrade(50.0) 1.
  • Scope in Fortran 90

    Scope in Fortran 90

    Scope in Fortran 90 The scope of objects (variables, named constants, subprograms) within a program is the portion of the program in which the object is visible (can be use and, if it is a variable, modified). It is important to understand the scope of objects not only so that we know where to define an object we wish to use, but also what portion of a program unit is effected when, for example, a variable is changed, and, what errors might occur when using identifiers declared in other program sections. Objects declared in a program unit (a main program section, module, or external subprogram) are visible throughout that program unit, including any internal subprograms it hosts. Such objects are said to be global. Objects are not visible between program units. This is illustrated in Figure 1. Figure 1: The figure shows three program units. Main program unit Main is a host to the internal function F1. The module program unit Mod is a host to internal function F2. The external subroutine Sub hosts internal function F3. Objects declared inside a program unit are global; they are visible anywhere in the program unit including in any internal subprograms that it hosts. Objects in one program unit are not visible in another program unit, for example variable X and function F3 are not visible to the module program unit Mod. Objects in the module Mod can be imported to the main program section via the USE statement, see later in this section. Data declared in an internal subprogram is only visible to that subprogram; i.e.
  • COBOL-Skills, Where Art Thou?

    COBOL-Skills, Where Art Thou?

    DEGREE PROJECT IN COMPUTER ENGINEERING 180 CREDITS, BASIC LEVEL STOCKHOLM, SWEDEN 2016 COBOL-skills, Where art Thou? An assessment of future COBOL needs at Handelsbanken Samy Khatib KTH ROYAL INSTITUTE OF TECHNOLOGY i INFORMATION AND COMMUNICATION TECHNOLOGY Abstract The impending mass retirement of baby-boomer COBOL developers, has companies that wish to maintain their COBOL systems fearing a skill shortage. Due to the dominance of COBOL within the financial sector, COBOL will be continually developed over at least the coming decade. This thesis consists of two parts. The first part consists of a literature study of COBOL; both as a programming language and the skills required as a COBOL developer. Interviews were conducted with key Handelsbanken staff, regarding the current state of COBOL and the future of COBOL in Handelsbanken. The second part consists of a quantitative forecast of future COBOL workforce state in Handelsbanken. The forecast uses data that was gathered by sending out a questionnaire to all COBOL staff. The continued lack of COBOL developers entering the labor market may create a skill-shortage. It is crucial to gather the knowledge of the skilled developers before they retire, as changes in old COBOL systems may have gone undocumented, making it very hard for new developers to understand how the systems work without guidance. To mitigate the skill shortage and enable modernization, an extraction of the business knowledge from the systems should be done. Doing this before the current COBOL workforce retires will ease the understanding of the extracted data. The forecasts of Handelsbanken’s COBOL workforce are based on developer experience and hiring, averaged over the last five years.
  • Subroutines and Control Abstraction

    Subroutines and Control Abstraction

    Subroutines and Control Abstraction CSE 307 – Principles of Programming Languages Stony Brook University http://www.cs.stonybrook.edu/~cse307 1 Subroutines Why use subroutines? Give a name to a task. We no longer care how the task is done. The subroutine call is an expression Subroutines take arguments (in the formal parameters) Values are placed into variables (actual parameters/arguments), and A value is (usually) returned 2 (c) Paul Fodor (CS Stony Brook) and Elsevier Review Of Memory Layout Allocation strategies: Static Code Globals Explicit constants (including strings, sets, other aggregates) Small scalars may be stored in the instructions themselves Stack parameters local variables temporaries bookkeeping information Heap 3 dynamic allocation(c) Paul Fodor (CS Stony Brook) and Elsevier Review Of Stack Layout 4 (c) Paul Fodor (CS Stony Brook) and Elsevier Review Of Stack Layout Contents of a stack frame: bookkeeping return Program Counter saved registers line number static link arguments and returns local variables temporaries 5 (c) Paul Fodor (CS Stony Brook) and Elsevier Calling Sequences Maintenance of stack is responsibility of calling sequence and subroutines prolog and epilog Tasks that must be accomplished on the way into a subroutine include passing parameters, saving the return address, changing the program counter, changing the stack pointer to allocate space, saving registers (including the frame pointer) that contain important values and that may be overwritten by the callee, changing the frame pointer to refer to the new frame, and executing initialization code for any objects in the new frame that require it. Tasks that must be accomplished on the way out include passing return parameters or function values, executing finalization code for any local objects that require it, deallocating the stack frame (restoring the stack pointer), restoring other saved registers (including the frame pointer), and restoring the program counter.
  • PHP: Constructs and Variables Introduction This Document Describes: 1

    PHP: Constructs and Variables Introduction This Document Describes: 1

    PHP: Constructs and Variables Introduction This document describes: 1. the syntax and types of variables, 2. PHP control structures (i.e., conditionals and loops), 3. mixed-mode processing, 4. how to use one script from within another, 5. how to define and use functions, 6. global variables in PHP, 7. special cases for variable types, 8. variable variables, 9. global variables unique to PHP, 10. constants in PHP, 11. arrays (indexed and associative), Brief overview of variables The syntax for PHP variables is similar to C and most other programming languages. There are three primary differences: 1. Variable names must be preceded by a dollar sign ($). 2. Variables do not need to be declared before being used. 3. Variables are dynamically typed, so you do not need to specify the type (e.g., int, float, etc.). Here are the fundamental variable types, which will be covered in more detail later in this document: • Numeric 31 o integer. Integers (±2 ); values outside this range are converted to floating-point. o float. Floating-point numbers. o boolean. true or false; PHP internally resolves these to 1 (one) and 0 (zero) respectively. Also as in C, 0 (zero) is false and anything else is true. • string. String of characters. • array. An array of values, possibly other arrays. Arrays can be indexed or associative (i.e., a hash map). • object. Similar to a class in C++ or Java. (NOTE: Object-oriented PHP programming will not be covered in this course.) • resource. A handle to something that is not PHP data (e.g., image data, database query result).
  • A Subroutine's Stack Frames Differently • May Require That the Steps Involved in Calling a Subroutine Be Performed in Different Orders

    A Subroutine's Stack Frames Differently • May Require That the Steps Involved in Calling a Subroutine Be Performed in Different Orders

    Chapter 04: Instruction Sets and the Processor organizations Lesson 14 Use of the Stack Frames Schaum’s Outline of Theory and Problems of Computer Architecture 1 Copyright © The McGraw-Hill Companies Inc. Indian Special Edition 2009 Objective • To understand call and return, nested calls and use of stack frames Schaum’s Outline of Theory and Problems of Computer Architecture 2 Copyright © The McGraw-Hill Companies Inc. Indian Special Edition 2009 Calling a subroutine Schaum’s Outline of Theory and Problems of Computer Architecture 3 Copyright © The McGraw-Hill Companies Inc. Indian Special Edition 2009 Calls to the subroutines • Allow commonly used functions to be written once and used whenever they are needed, and provide abstraction, making it easier for multiple programmers to collaborate on a program • Important part of virtually all computer languages • Function calls in a C language program • Also included additional functions from library by including the header files Schaum’s Outline of Theory and Problems of Computer Architecture 4 Copyright © The McGraw-Hill Companies Inc. Indian Special Edition 2009 Difficulties when Calling a subroutine Schaum’s Outline of Theory and Problems of Computer Architecture 5 Copyright © The McGraw-Hill Companies Inc. Indian Special Edition 2009 Difficulties involved in implementing subroutine calls 1. Programs need a way to pass inputs to subroutines that they call and to receive outputs back from them Schaum’s Outline of Theory and Problems of Computer Architecture 6 Copyright © The McGraw-Hill Companies Inc. Indian Special Edition 2009 Difficulties involved in implementing subroutine calls 2. Subroutines need to be able to allocate space in memory for local variables without overwriting any data used by the subroutine-calling program Schaum’s Outline of Theory and Problems of Computer Architecture 7 Copyright © The McGraw-Hill Companies Inc.
  • Chapter 9: Functions and Subroutines – Reusing Code. Page 125 Chapter 9: Functions and Subroutines – Reusing Code

    Chapter 9: Functions and Subroutines – Reusing Code. Page 125 Chapter 9: Functions and Subroutines – Reusing Code

    Chapter 9: Functions and Subroutines – Reusing Code. Page 125 Chapter 9: Functions and Subroutines – Reusing Code. This chapter introduces the use of Functions and Subroutines. Programmers create subroutines and functions to test small parts of a program, reuse these parts where they are needed, extend the programming language, and simplify programs. Functions: A function is a small program within your larger program that does something for you. You may send zero or more values to a function and the function will return one value. You are already familiar with several built in functions like: rand and rgb. Now we will create our own. Illustration 22: Block Diagram of a Function © 2014 James M. Reneau (CC BY-NC-SA 3.0 US) Chapter 9: Functions and Subroutines – Reusing Code. Page 126 Function functionname( argument(s) ) statements End Function Function functionname$( argument(s) ) statements End Function The Function statement creates a new named block of programming statements and assigns a unique name to that block of code. It is recommended that you do not name your function the same name as a variable in your program, as it may cause confusion later. In the required parenthesis you may also define a list of variables that will receive values from the “calling” part of the program. These variables belong to the function and are not available to the part of the program that calls the function. A function definition must be closed or finished with an End Function. This tells the computer that we are done defining the function. The value being returned by the function may be set in one of two ways: 1) by using the return statement with a value following it or 2) by setting the function name to a value within the function.