การใช้งาน sending function as variable ในภาษา fortran แบบง่ายๆ พร้อมตัวอย่าง CODE 3 ตัวอย่าง และอธิบายการทำงาน และยกตัวอย่าง usecase ในโลกจริง

# การใช้งานฟังก์ชั่นในภาษา Fortran ผ่านการส่งฟังก์ชั่นเป็นตัวแปร

สวัสดีครับผู้อ่านทุกท่านที่สนใจในเรื่องของการเขียนโปรแกรม วันนี้เราจะมาพูดถึงหัวข้อที่น่าสนใจในภาษา Fortran นั่นก็คือการส่งฟังก์ชั่นเป็นตัวแปร ซึ่งอาจฟังดูซับซ้อน แต่ถ้าเข้าใจหลักการแล้วจะสามารถนำไปใช้ในการพัฒนาโปรแกรมได้เป็นอย่างดี พร้อมกันนี้ หลังจากที่เราได้ศึกษาไปแล้ว หากท่านใดสนใจอยากขยายไปถึงวิชาการโปรแกรมมิ่งอย่างจริงจัง วิทยาลัยโปรแกรมมิ่ง EPT พร้อมเปิดประตูสู่โลกของการเขียนโค้ดที่มีความหมาย

หลักการในการส่งฟังก์ชั่นเป็นตัวแปรใน Fortran

การส่งฟังก์ชั่นเป็นตัวแปรใน Fortran จะต้องกระทำผ่านการใช้ `interface` เพื่อกำหนดโปรโตคอลสำหรับฟังก์ชั่นที่จะส่งผ่านไปยังฟังก์ชั่นอื่น ดังนั้น เราจะได้ความยืดหยุ่นในการที่สามารถเปลี่ยนแปลงการทำงานของโปรแกรมให้เหมาะสมกับความต้องการในแต่ละสถานการณ์

Usecase ในโลกจริง

ในแวดวงวิทยาศาสตร์และวิศวกรรม, Fortran มักถูกนำมาใช้ในการจำลองสถานการณ์ทางฟิสิกส์หรือวิศวกรรม การส่งฟังก์ชั่นเป็นตัวแปรมีประเทศยิ่งมาก เช่น การคำนวณค่าต่างๆ ด้วยสมการที่มีฟังก์ชั่นมากมาย อาทิเช่น การคำนวณสมการแข็งเหล็ก (solid mechanics) ที่ต้องการใช้ฟังก์ชันหลายๆ ตัวเพื่อแสดงถึงคุณสมบัติของวัสดุในสถานการณ์ที่ต่างกัน

ตัวอย่างโค้ดที่ 1: การสร้าง Interface และการส่ง Function เป็น Argument

module math_operations
  implicit none
  interface
     real function operation(a, b)
       real, intent(in) :: a, b
     end function operation
  end interface
end module math_operations

module utils
  use math_operations
  implicit none
contains
  real function execute_operation(a, b, op)
    real, intent(in) :: a, b
    procedure(operation) :: op
    execute_operation = op(a, b)
  end function execute_operation
end module utils

program test
  use utils
  implicit none

  print *, "Adding: ", execute_operation(5.0, 3.0, add)
  print *, "Multiplying: ", execute_operation(5.0, 3.0, multiply)

contains

  real function add(x, y)
    real, intent(in) :: x, y
    add = x + y
  end function add

  real function multiply(x, y)
    real, intent(in) :: x, y
    multiply = x * y
  end function multiply

end program test

ในโค้ดนี้ เราได้กำหนด `math_operations` module ที่มี `interface operation` สำหรับฟังก์ชั่นที่มีสองตัวแปร `a` และ `b` ฟังก์ชัน `execute_operation` จะรับ `op` เป็นการชี้ไปยัง function ที่เป็น interface ของ `operation` และสามารถเป็น `add` หรือ `multiply` ที่จะโดนเรียกใช้ใน `program test`

ตัวอย่างโค้ดที่ 2: การใช้งาน Procedure Pointer

module operations_mod
  implicit none
contains
  real function add(x, y)
    real, intent(in) :: x, y
    add = x + y
  end function add

  real function multiply(x, y)
    real, intent(in) :: x, y
    multiply = x * y
  end function multiply
end module operations_mod

program demo_procedure_pointer
  use operations_mod
  implicit none
  external :: add, multiply
  real :: result
  procedure(add), pointer :: fptr

  fptr => add    ! Point to the 'add' function
  result = fptr(10.0, 5.0)
  print *, "10 + 5 = ", result

  fptr => multiply  ! Point to the 'multiply' function
  result = fptr(10.0, 5.0)
  print *, "10 * 5 = ", result

end program demo_procedure_pointer

ในตัวอย่างนี้, เราได้ใช้ `procedure` pointer ที่ชื่อ `fptr` เพื่อชี้ไปยังฟังก์ชั่น `add` และ `multiply` ผ่านการ assign pointer โดยใช้ `=>` operator เพื่อเปลี่ยนการชี้ถึงฟังก์ชันที่ต้องการใช้งานในเวลาที่แตกต่างกัน

ตัวอย่างโค้ดที่ 3: การใช้งานใน Context ของ Integration

module integration_mod
  implicit none
  interface
     real function integrand(x)
       real, intent(in) :: x
     end function integrand
  end interface
end module integration_mod

module numerical_integration
  use integration_mod
  implicit none
contains
  real function integrate(a, b, f)
    real, intent(in) :: a, b
    procedure(integrand) :: f
    real :: x, dx, sum
    integer :: i, N
    N = 1000  ! Number of steps
    dx = (b - a) / N
    sum = 0.0

    do i = 0, N-1
      x = a + i*dx
      sum = sum + f(x)*dx
    end do

    integrate = sum
  end function integrate
end module numerical_integration

program test_integration
  use numerical_integration
  implicit none
  real :: result

  result = integrate(0.0, 1.0, my_function)
  print *, "The integral result is: ", result

contains

  real function my_function(x)
    real, intent(in) :: x
    my_function = x**2  ! A simple quadratic function
  end function my_function

end program test_integration

ในตัวอย่างนี้ เราได้สร้างฟังก์ชัน `integrate` ที่สามารถรับฟังก์ชัน `integrand` ซึ่งเป็นฟังก์ชันที่จะถูกนำไปใช้ในการคำนวณค่าอินทิเกรต ทั้งนี้ `my_function` ได้ถูกส่งเข้าไปใน `integrate` และทำการคำนวณค่าอินทิเกรตของฟังก์ชันกำลังสอง

จากตัวอย่างโค้ดทั้งสามและการอธิบายการทำงาน หวังว่าท่านผู้อ่านจะเห็นถึงความสามารถที่ยืดหยุ่นและประโยชน์ของการใช้งานฟังก์ชันผ่านการส่งตัวแปรในภาษา Fortran และหากท่านใดที่เกิดความสนใจต่อการเรียนรู้การเขียนโค้ดลึกซึ้งยิ่งขึ้น EPT พร้อมเป็นที่ปรึกษาและพัฒนาศักยภาพให้ท่านได้สัมผัสความเป็นมืออาชีพในโลกของการเขียนโปรแกรมไปด้วยกันครับ!

หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง