subroutine

I have a module that contains a subroutine that contains another subroutine. The outer subroutine has a parallel OpenMP region in which I call the inner subroutine. The code compiles and runs without any error but the results are not correct. module my_module contains subroutine a(...) *...some variables* !$OMP PARALLEL DO DEFAULT(PRIVATE) SHARED(...) *...do some work* call b(...) !$OMP END PARALLEL DO contains subroutine b(...) *...some variables* *...do some work* end subroutine b end subroutine a end my module If I run the Intel Debugger idb , it will show me a SIGSEGV inside subroutine b .

I'm trying to use an allocatable array in a subroutine but the compiler complains that Error: Dummy argument 'locs' with INTENT(IN) in variable definition context (ALLOCATE object) at (1) The only thing I could find was that I am supposed to use an explicit interface, which I am doing. Here the relevant code for the subroutine: RECURSIVE SUBROUTINE together(locs, LL, RL) INTEGER, DIMENSION(:,:), ALLOCATABLE, INTENT(IN) :: locs INTEGER, INTENT(IN) :: LL, RL ALLOCATE(locs(LL,RL)) END SUBROUTINE together The compiler's error message is one descriptive of the problem. With INTENT(IN) you are

Ok so i was wondering how i would go about calling a perl subroutine from the command line. So if my program is Called test, and the subroutine is called fields i would like to call it from the command line like. test fields Use a dispatch table. #!/usr/bin/perl use strict; use warnings; use 5.010; sub fields { say 'this is fields'; } sub another { say 'this is another subroutine'; } my %functions = ( fields => \&fields, another => \&another, ); my $function = shift; if (exists $functions{$function}) { $functions{$function}->(); } else { die "There is no function called $function available\n";

I am having trouble passing and reading arguments inside subroutine which is expected to have two arrays. sub two_array_sum { # two_array_sum ( (1 2 3 4), (2, 4, 0, 1) ) -> (3, 6, 3, 5) # I would like to use parameters @a and @b as simply as possible } # I would like to call two_array_sum here and pass two arrays, @c and @d I have seen and tried several examples from the web, but none of them worked for me. There are two ways you can do this: by prototype by reference But before I discuss these--if what you show in your question is about the extent of what you want to do--let me suggest List:

I would like to call a sub from another sub inside in the same module. The first sub would be my main code and there I would call the second subroutine. Second subroutine receives multiple inputs as integer, double, double arrays and double matrices. The size of the arrays and matrices are known and stored in an integer variable. The sub also returns several outputs. So, I would like to do something like this. sub Main() Nc As integer Dim kij(1 To Nc, 1 To Nc), xi(1 to Nc), a1 As Double 'I assign values to my variables from the excelsheet e.g. Nc=Cells(1,1) etc. CalculateA(Nc,kij, xi, a1, a)

I have asked this question before or searched and seen others ask - why am I getting the warning " Subroutine mySub redefined at ../lib/Common.pm line x "? and you always get the answer you declared the sub twice in the same code . I created this test package: ENTIRE FILE --------------- package MyCommonPkg; use strict; sub thisSubroutineIsNotDefinedAnywhereElse{ } 1; ENTIRE FILE --------------- and I USE this package from a perl script, which uses other packages, that use this package also, and I get the warning: Subroutine ThisSubroutineIsNotDefinedAnywhereElse redefined at ../lib

Let us ignore for a moment Damian Conway's best practice of no more than three positional parameters for any given subroutine. Is there any difference between the two examples below in regards to performance or functionality? Using shift : sub do_something_fantastical { my $foo = shift; my $bar = shift; my $baz = shift; my $qux = shift; my $quux = shift; my $corge = shift; } Using @_ : sub do_something_fantastical { my ($foo, $bar, $baz, $qux, $quux, $corge) = @_; } Provided that both examples are the same in terms of performance and functionality, what do people think about one format over

What's the best way to programatically discover all of the subroutines a perl module has? This could be a module, a class (no @EXPORT), or anything in-between. Edit: All of the methods below look like they will work. I'd probably use the Class::Sniff or Class::Inspector in production. However, Leon's answer is marked as 'accepted' since it answers the question as posed, even though no strict 'refs' has to be used. :-) Class::Sniff may be a good choice as it progresses; it looks like a lot of thought has gone into it. sub list_module { my $module = shift; no strict 'refs'; return grep { defined