the code is in ada with Ada.Numerics.Generic_Elementary_Functions; package body Number_Theory is -- Instantiate the library for floating point math using Floating_Type. package Floating_Functions is new Ada.Numerics.Generic_Elementary_Functions(Floating_Type); use Floating_Functions; function Factorial(N : in Factorial_Argument_Type) return Positive is begin -- TODO: Finish me! -- -- 0! is 1 -- N! is N * (N-1) * (N-2) * ... * 1 return 1; end Factorial; function Is_Prime(N : in Prime_Argument_Type) return Boolean is Upper_Bound : Prime_Argument_Type; Current_Divisor : Prime_Argument_Type; begin -- Handle 2 as a special case. if N = 2 then return True; end if; Upper_Bound := N - 1; Current_Divisor := 2; while Current_Divisor < Upper_Bound loop if N rem Current_Divisor = 0 then return False; end if; Upper_Bound := N / Current_Divisor; end loop; return True; end Is_Prime; function Prime_Counting(N : in Prime_Argument_Type) return Natural is begin -- TODO: Finish me! -- -- See the page for more information. return 0; end Prime_Counting; function Logarithmic_Integral(N : in Prime_Argument_Type) return Floating_Type is begin -- TODO: Finish me! -- -- See the page for more information. return 1.0; end Logarithmic_Integral; end Number_Theory;

Computer Networking: A Top-Down Approach (7th Edition)
7th Edition
ISBN:9780133594140
Author:James Kurose, Keith Ross
Publisher:James Kurose, Keith Ross
Chapter1: Computer Networks And The Internet
Section: Chapter Questions
Problem R1RQ: What is the difference between a host and an end system? List several different types of end...
icon
Related questions
Question

the code is in ada

 

with Ada.Numerics.Generic_Elementary_Functions;

package body Number_Theory is

   -- Instantiate the library for floating point math using Floating_Type.
   package Floating_Functions is new Ada.Numerics.Generic_Elementary_Functions(Floating_Type);
   use Floating_Functions;


   function Factorial(N : in Factorial_Argument_Type) return Positive is
   begin
      -- TODO: Finish me!
      --
      -- 0! is 1
      -- N! is N * (N-1) * (N-2) * ... * 1
      return 1;
   end Factorial;


   function Is_Prime(N : in Prime_Argument_Type) return Boolean is
      Upper_Bound     : Prime_Argument_Type;
      Current_Divisor : Prime_Argument_Type;
   begin
      -- Handle 2 as a special case.
      if N = 2 then
         return True;
      end if;

      Upper_Bound := N - 1;
      Current_Divisor := 2;
      while Current_Divisor < Upper_Bound loop
         if N rem Current_Divisor = 0 then
            return False;
         end if;
         Upper_Bound := N / Current_Divisor;
      end loop;
      return True;
   end Is_Prime;


   function Prime_Counting(N : in Prime_Argument_Type) return Natural is
   begin
      -- TODO: Finish me!
      --
      -- See the page for more information.
      return 0;
   end Prime_Counting;


   function Logarithmic_Integral(N : in Prime_Argument_Type) return Floating_Type is
   begin
      -- TODO: Finish me!
      --
      -- See the page for more information.
      return 1.0;
   end Logarithmic_Integral;

end Number_Theory;

2. Number theory is a branch of mathematics that concerns itself with the properties of the integers. One function of considerable interest in number theory is the prime counting
function. It is traditionally given the name n (but it has nothing to do with circles). For example T(6) = 3 because there are three prime numbers less than or equal to 6 (namely, 2, 3,
and 5).
Start by adding a function to package Number_Theory that computes n(n) for positive values n greater than or equal to 2. Note that the package already has a function Is_Prime that
you will no doubt find useful. You might also want to make use of the defined subtype Prime_Argument_Type. Ada allows you to use Greek letters in variable names, but I suggest using
the name Prime_Counting for n instead.
3. Modify the main file main.adb to exercise your function (ask the user to input a value n and then output (n)). Here are some values of n(n) you can check.
T(n)
10
4
100
25
1_000
168
10_000
1_229
100_000
9_592
1_000_000
78_498
10_000_000
664_579
100_000_000 5_761_455
1_000_000_000 50_847_534
Transcribed Image Text:2. Number theory is a branch of mathematics that concerns itself with the properties of the integers. One function of considerable interest in number theory is the prime counting function. It is traditionally given the name n (but it has nothing to do with circles). For example T(6) = 3 because there are three prime numbers less than or equal to 6 (namely, 2, 3, and 5). Start by adding a function to package Number_Theory that computes n(n) for positive values n greater than or equal to 2. Note that the package already has a function Is_Prime that you will no doubt find useful. You might also want to make use of the defined subtype Prime_Argument_Type. Ada allows you to use Greek letters in variable names, but I suggest using the name Prime_Counting for n instead. 3. Modify the main file main.adb to exercise your function (ask the user to input a value n and then output (n)). Here are some values of n(n) you can check. T(n) 10 4 100 25 1_000 168 10_000 1_229 100_000 9_592 1_000_000 78_498 10_000_000 664_579 100_000_000 5_761_455 1_000_000_000 50_847_534
4. Computing n(n) exactly can be time-consuming, especially for large values of n (note: you should be able to double the speed of your implementation by skipping even numbers...
don't forget to handle 2 as a special case). It turns out there is an approximation formula for computing n(n) that is much faster to calculate. It entails evaluating an infinite series that
uses the natural logarithm function. Here is the series:
v + 1n(1n(n)) + In'(n)/(1*1!) + In?(n)/(2*2!) + 1n (n)/(3*3!) + ...
Here y (gamma) is Euler's constant and has the value (approximately):
y = 0.57721_56649_01532_86060_65120_90082_40243_10421_59335_93992
Although the series has infinitely many terms you don't need to add them all because the terms get smaller and smaller. This series is called the "logarithmic integral function" and
goes by the name li(n). It is an amazing fact that n(n) is roughly equal to li(n).
Add a function to your package Number_Theory that computes li(n). Call your function Logarithmic_Integral.
The package Ada.Numerics.Generic_Elementary_Functions contains a function Log which computes the natural logarithm (shown as 'In' in the formula above). Note that the
logarithmic integral is computed using floating point numbers, so you'll need some type conversions to go back and forth between integers and floating point values. For example if N
is an integer of some kind, you can convert its value to the floating point type declared in Number_Theory by doing Floating_Type (N).
Transcribed Image Text:4. Computing n(n) exactly can be time-consuming, especially for large values of n (note: you should be able to double the speed of your implementation by skipping even numbers... don't forget to handle 2 as a special case). It turns out there is an approximation formula for computing n(n) that is much faster to calculate. It entails evaluating an infinite series that uses the natural logarithm function. Here is the series: v + 1n(1n(n)) + In'(n)/(1*1!) + In?(n)/(2*2!) + 1n (n)/(3*3!) + ... Here y (gamma) is Euler's constant and has the value (approximately): y = 0.57721_56649_01532_86060_65120_90082_40243_10421_59335_93992 Although the series has infinitely many terms you don't need to add them all because the terms get smaller and smaller. This series is called the "logarithmic integral function" and goes by the name li(n). It is an amazing fact that n(n) is roughly equal to li(n). Add a function to your package Number_Theory that computes li(n). Call your function Logarithmic_Integral. The package Ada.Numerics.Generic_Elementary_Functions contains a function Log which computes the natural logarithm (shown as 'In' in the formula above). Note that the logarithmic integral is computed using floating point numbers, so you'll need some type conversions to go back and forth between integers and floating point values. For example if N is an integer of some kind, you can convert its value to the floating point type declared in Number_Theory by doing Floating_Type (N).
Expert Solution
steps

Step by step

Solved in 2 steps with 2 images

Blurred answer
Similar questions
Recommended textbooks for you
Computer Networking: A Top-Down Approach (7th Edi…
Computer Networking: A Top-Down Approach (7th Edi…
Computer Engineering
ISBN:
9780133594140
Author:
James Kurose, Keith Ross
Publisher:
PEARSON
Computer Organization and Design MIPS Edition, Fi…
Computer Organization and Design MIPS Edition, Fi…
Computer Engineering
ISBN:
9780124077263
Author:
David A. Patterson, John L. Hennessy
Publisher:
Elsevier Science
Network+ Guide to Networks (MindTap Course List)
Network+ Guide to Networks (MindTap Course List)
Computer Engineering
ISBN:
9781337569330
Author:
Jill West, Tamara Dean, Jean Andrews
Publisher:
Cengage Learning
Concepts of Database Management
Concepts of Database Management
Computer Engineering
ISBN:
9781337093422
Author:
Joy L. Starks, Philip J. Pratt, Mary Z. Last
Publisher:
Cengage Learning
Prelude to Programming
Prelude to Programming
Computer Engineering
ISBN:
9780133750423
Author:
VENIT, Stewart
Publisher:
Pearson Education
Sc Business Data Communications and Networking, T…
Sc Business Data Communications and Networking, T…
Computer Engineering
ISBN:
9781119368830
Author:
FITZGERALD
Publisher:
WILEY