# 79 Languages speed competition: Can we make Fortran win?

**URL:** <https://fortran-lang.discourse.group/t/79-languages-speed-competition-can-we-make-fortran-win/3038>\
**Category:** Uncategorized\
**Created:** [March 24, 2022, 7:40am UTC](https://fortran-lang.discourse.group/t/79-languages-speed-competition-can-we-make-fortran-win/3038 "2022-03-24T07:40:01Z")\
**Posts on this page:** 1\
**Showing post:** 24

<div class="post-metadata">

**Author:** ![Beliavsky](https://avatars.discourse-cdn.com/v4/letter/b/ba8739/32.png) [@Beliavsky](https://fortran-lang.discourse.group/u/Beliavsky)\
**Post date:** [April 1, 2022, 12:40am UTC](https://fortran-lang.discourse.group/t/79-languages-speed-competition-can-we-make-fortran-win/3038/24 "2022-04-01T00:40:07Z")

</div>

Here is a code [inspired by APL](https://computerhistory.org/blog/the-apl-programming-language-source-code/) that I am sure is slow, but the main program is concise.

```auto
module apl_mod
implicit none
interface operator(.i.)
   module procedure irange
end interface
!
interface operator(.d.)
   module procedure drop
end interface
!
interface operator(.o.)
   module procedure outer_product
end interface
!
interface operator (.ni.)
   module procedure not_in
end interface
!
contains
pure function irange(i) result(v)
! return integers from 1 to i
integer, intent(in) :: i
integer :: v(i)
integer :: j
do j=1,i
   v(j) = j
end do
end function irange
!
pure function drop(v) result(dv)
! return v(:) without the first element
integer, intent(in) :: v(:)
integer :: dv(size(v)-1)
if (size(v) > 1) dv = v(2:)
end function drop
!
pure function outer_product(v) result(m)
! multiplication outer product
integer, intent(in) :: v(:)
integer :: m(size(v),size(v))
integer :: i,j
do i=1,size(v)
   do j=1,size(v)
      m(i,j) = v(i)*v(j)
   end do
end do
end function outer_product
!
pure function not_in(a,b) result(c)
! return in c the elements of a(:) not in b(:)
integer, intent(in) :: a(:),b(:)
integer, allocatable :: c(:)
logical :: amask(size(a))
integer :: i
do i=1,size(a)
   amask(i) = .not. any(b == a(i)) 
end do
c = pack(a,amask)
end function not_in
end module apl_mod
!
program main
use apl_mod
implicit none
associate (t => .d. (.i. 1000) )
   print "(20(1x,i0))",t .ni. [.o. t]
end associate
end program main

```

> **output:**
>
> 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71  
> 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173  
> 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281  
> 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409  
> 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541  
> 547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659  
> 661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809  
> 811 821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941  
> 947 953 967 971 977 983 991 997

---

_[View the full topic](https://fortran-lang.discourse.group/t/79-languages-speed-competition-can-we-make-fortran-win/3038)._