দ্রুত ট্রিগ গণনা

Question

দ্রুত ত্রিকোণমিতি গণনা

আপনার কাজটি এমন একটি প্রোগ্রাম তৈরি করা যা ডিগ্রিগুলিতে একটি কোণের সাইন, কোসাইন এবং স্পর্শকটি গণনা করতে পারে।

বিধি

• কোনও অন্তর্নির্মিত ত্রিকোণমিতি ফাংশন নেই (এমনকি সেকেন্ড, কোসেক্যান্ট এবং কোটজেন্টও যদি আপনার ভাষা না থাকে)।
• আপনি সন্ধানের টেবিলগুলি ব্যবহার করতে পারেন, তবে তাদের মোট আকার অবশ্যই 3000 সদস্যের বেশি হবে না (তিনটি ক্রিয়াকলাপের জন্য একসাথে রাখা)। দয়া করে এটিকে কোনও ফাইল (যেমন trig.lookup) থেকে টেবিলগুলি পড়তে বাধ্য করুন যাতে তারা কোডটি বিভ্রান্ত না করে।
• কোনও নেটওয়ার্ক অ্যাক্সেস নেই।
• নীচে বর্ণিত হিসাবে আপনার আউটপুটটি সঠিকভাবে গোল করতে হবে। মেঝে বা সিলিং ব্যবহার করবেন না।
• আপনি মানগুলি গণনা করতে যে কোনও পদ্ধতি ব্যবহার করতে পারেন, উদাহরণস্বরূপ অবিরত ভগ্নাংশ , যতক্ষণ না এটি 7 টি গুরুত্বপূর্ণ ব্যক্তির সাথে সঠিক হয়।
• আপনার কোডটি নিজেই সময় দিতে সক্ষম হবে। আপনার সময় থেকে ফাইল আই / ও ক্রিয়াকলাপগুলি বাদ দিন - তাই কেবলমাত্র ফাংশন (গুলি) যা ট্রিগার এবং যে কোনও রাউন্ডিংয়ের কাজ করে time
• আমি অবশ্যই আপনার কোড চালাতে সক্ষম হব। দয়া করে অবাধে উপলভ্য সংকলক / দোভাষীর একটি লিঙ্ক পোস্ট করুন এবং কোডটি সংকলন / চালানোর জন্য প্রয়োজনীয় নির্দেশাবলী দিন (যেমন জিসিসিতে কী কী বিকল্পগুলি পাস করতে হবে)।
• স্ট্যান্ডার্ড লুফোলস প্রযোজ্য।

ছক পূরণ করা

• trig.inআপনার ভাষা আই / ও ফাইল সমর্থন না করে বলা হয় এমন কোনও ফাইল থেকে পড়ুন ।
• কোণগুলি 0 থেকে 360 এর মধ্যে রয়েছে।
• ইনপুটটি দশমিক অঙ্কগুলিতে দশটি উল্লেখযোগ্য পরিসংখ্যানগুলিতে কোণগুলি সমন্বয়ে নতুন লাইনের দ্বারা পৃথক হবে। উদাহরণ স্বরূপ:

90.00000000
74.54390000
175.5000000

আউটপুট ফরমেট

• সরবরাহকৃত প্রতিটি কোণের জন্য আপনাকে অবশ্যই তার সাইন, কোসাইন এবং স্পর্শকাতৃত্বকে 7 টি উল্লেখযোগ্য পরিসংখ্যানগুলিতে আউটপুট করতে হবে, স্পেস দ্বারা পৃথক করে একটি লাইনে। "বৈজ্ঞানিক স্বরলিপি", যেমন ব্যবহার করুন 1.745329E-5জন্য tan 0.001অথবা 1.000000E+0জন্য sin 90।
• অসীম বা NaN দ্বারা চিহ্নিত করুন n, উদাহরণস্বরূপ আউটপুট 90.00000000হওয়া উচিত 1.000000 0.000000 n।
• যদি ইনপুটটি নতুন লাইনের দ্বারা পৃথক তিনটি কোণ থাকে তবে আপনার আউটপুটে তিনটি লাইন থাকা উচিত, যার প্রতিটিটিতে সাইন, কোসাইন এবং স্পর্শক থাকে।
• আপনি অন্য কিছু আউটপুট নাও পেতে পারেন।
• trig.outযদি আপনার ভাষা I / O ফাইল সমর্থন না করে তবে ডাকা একটি ফাইলের আউটপুট ।

স্কোরিং

• দ্রুততম-কোড । চ্যালেঞ্জটি হ'ল এমন একটি প্রোগ্রাম লিখুন যা এই তিনটি মানকে যত তাড়াতাড়ি সম্ভব গণনা করে। দ্রুততম সময় জয়।
• প্রত্যেকেই বহু কোণে একই পরীক্ষার ইনপুট গ্রহণ করবে।
• টাইমস আমার মেশিনে লিপিবদ্ধ করা হবে।
• আপনার স্কোর একই ইনপুটটিতে তিন রান গড়ে (আপনি অবশ্যই রানগুলির মধ্যে কোনও কিছুই সংরক্ষণ করতে পারবেন না)।
• সংকলনের সময় অন্তর্ভুক্ত নয়। এই চ্যালেঞ্জটি ভাষার চেয়ে ব্যবহৃত পদ্ধতি সম্পর্কে বেশি। (যদি কেউ আমাকে জাভা হিসাবে ভাষার জন্য সংকলনের সময়টিকে কীভাবে বাদ দেবেন তা আমাকে নির্দেশ করতে পারে তবে আমি খুব কৃতজ্ঞ হব)
• আমার মেশিনটি একটি উবুন্টু 14.04 ইনস্টল। প্রসেসরের পরিসংখ্যানগুলি প্যাস্টবিনে রয়েছে (দৌড়ের মাধ্যমে প্রাপ্ত cat /proc/cpuinfo)।
• আমি যখন এটি পরীক্ষা করেছি তখন আমি আপনার উত্তরে আপনার সময়টি সম্পাদনা করব।

Comments

আউটপুট দেয় আছে একটি একক লাইন হবেন? এটি এন্টার কী দিয়ে গঠন করা হলে এটি দেখতে বেশ সুন্দর দেখাচ্ছে ... এছাড়াও, কোনও বিজয়ী বাছাই করার কোনও নির্দিষ্ট তারিখ রয়েছে কি?

— ইফ্রয়িম

@ এফ্রাইম একটি এন্টার কী দিয়ে ফর্ম্যাট করে আপনার অর্থ কী? না, নির্দিষ্ট তারিখ নেই। আমার এই সমস্ত সমাধানগুলির সত্যই পরীক্ষা করতে হবে, তবে আমি এখনও পরীক্ষার ইনপুটটি তৈরি করিনি ((

@ প্রফেসরফিশ - আমার উত্তরে ফলাফল দেখুন। প্রতিটি sin, cosএবং tanএকটি নতুন লাইনে আছে। উত্তরগুলি একটি এক লাইনে আউটপুট দেওয়ার জন্য কি আমাকে এটি পরিবর্তন করতে হবে?

— ইফ্রয়িম

@ ইফ্রাইম আউটপুট ফর্ম্যাটটি আসলে কোনও ব্যাপার নয় (যতক্ষণ না এটি কোড-গল্ফ নয়) যতক্ষণ না এটি প্রতিটি কোণে পাপ

আমাদের কি কেবল ট্রিগের গণনাগুলি সময় নেওয়ার কথা রয়েছে, বা সময়টিতে আইও অন্তর্ভুক্ত করা উচিত?

— gggg

Answer 1

ফরট্রান 90

আমি 60 টি আর্টিকান মানের প্রাক-ট্যাবুলেটেড অ্যারের সাথে কর্ডিক পদ্ধতিটি নিয়োগ করি (কেন এটি প্রয়োজনীয় তা সম্পর্কে বিশদ সম্পর্কিত উইকি নিবন্ধটি দেখুন)।

এই কোডটির জন্য একটি ফাইল দরকার trig.in, নিউলাইনগুলিতে সমস্ত মান সহ ফোর্টরান এক্সিকিউটেবলের মতো একই ফোল্ডারে সংরক্ষণ করতে। এটি সংকলন করা হয়,

gfortran -O3 -o file file.f90

fileআপনি যে ফাইল ফাইলটিই দেন তা কোথায় (সম্ভবত SinCosTan.f90প্রোগ্রামের নাম এবং ফাইলের নামের সাথে মিলের প্রয়োজন না হলেও এটি সবচেয়ে সহজ)। আপনার যদি ইন্টেল সংকলক থাকে তবে আমি ব্যবহার করার পরামর্শ দেব

ifort -O3 -xHost -o file file.f90

যেহেতু -xHost(যা গফর্ট্রানের জন্য বিদ্যমান নেই) আপনার প্রসেসরের জন্য উচ্চ স্তরের অনুকূলিতকরণ সরবরাহ করে।

আমার পরীক্ষার রানগুলি আমাকে গফট্রান ৪.৪ (৪.7 বা 4.8 উবুন্টু রেপোতে উপলব্ধ) এবং ইফোর্ট 12.1 ব্যবহার করে প্রায় 9.5 মাইক্রোসেকেন্ড ব্যবহার করে 1000 টি এলোমেলো কোণ পরীক্ষা করার সময় গণনা প্রতি 10 মাইক্রোসেকেন্ড দিচ্ছিল। ফোরট্রান রুটিন ব্যবহার করে শুধুমাত্র 10 টি এলোমেলো কোণ পরীক্ষা করার ফলে অনিশ্চিত সময় আসতে পারে, কারণ সময়কর্মটি নিয়মিতভাবে মিলি সেকেন্ডে এবং সহজ গণিত অনুসারে 10 টি সংখ্যা চালাতে 0.100 মিলিসেকেন্ড লাগবে।

---

সম্পাদনা স্পষ্টতই আমি টাইমিং করছিলাম IO যা (ক) সময়ের চেয়ে প্রয়োজনীয় সময়কে আরও দীর্ঘায়িত করেছিল এবং (খ) বুলেট # 6 এর বিপরীতে। আমি এটি প্রতিফলিত করার জন্য কোড আপডেট করেছি। আমি আরও আবিষ্কার করেছি যে kind=8অভ্যন্তরীণ সাববুটিনের সাথে একটি পূর্ণসংখ্যা ব্যবহার করা system_clockমাইক্রোসেকেন্ডের সঠিকতা দেয়।

এই আপডেট করা কোডটির সাথে আমি এখন প্রায় 0.3 মাইক্রোসেকেন্ডে ত্রিকোণমিতিক ফাংশনগুলির প্রতিটি সংখ্যার গণনা করছি (শেষের দিকে উল্লেখযোগ্য সংখ্যাগুলি রান টু-রানে পরিবর্তিত হয়, তবে এটি ধারাবাহিকভাবে 0.31 মার্কিন কাছাকাছি ঘোরাঘুরি করে), আগের থেকে উল্লেখযোগ্য হ্রাস পুনরাবৃত্তি যে সময় শেষ IO।

---

program SinCosTan
   implicit none
   integer, parameter :: real64 = selected_real_kind(15,307)
   real(real64), parameter :: PI  = 3.1415926535897932384626433832795028842
   real(real64), parameter :: TAU = 6.2831853071795864769252867665590057684
   real(real64), parameter :: half = 0.500000000000000000000_real64
   real(real64), allocatable :: trigs(:,:), angles(:)
   real(real64) :: time(2), times, b
   character(len=12) :: tout
   integer :: i,j,ierr,amax
   integer(kind=8) :: cnt(2)

   open(unit=10,file='trig.out',status='replace')
   open(unit=12,file='CodeGolf/trig.in',status='old')
! check to see how many angles there are
   i=0
   do
      read(12,*,iostat=ierr) b
      if(ierr/=0) exit
      i=i+1
   enddo !- 
   print '(a,i0,a)',"There are ",i," angles"
   amax = i

! allocate array
   allocate(trigs(3,amax),angles(amax))

! rewind the file then read the angles into the array
   rewind(12)
   do i=1,amax
      read(12,*) angles(i)
   enddo !- i

! compute trig functions & time it
   times = 0.0_real64
   call system_clock(cnt(1)) ! <-- system_clock with an 8-bit INT can time to us
   do i=1,amax
      call CORDIC(angles(i), trigs(:,i), 40)
   enddo !- i
   call system_clock(cnt(2))
   times = times + (cnt(2) - cnt(1))

! write the angles to the file
   do i=1,amax
      do j=1,3
         if(trigs(j,i) > 1d100) then
            write(tout,'(a1)') 'n'
         elseif(abs(trigs(j,i)) > 1.0) then
            write(tout,'(f10.6)') trigs(j,i)
         elseif(abs(trigs(j,i)) < 0.1) then
            write(tout,'(f10.8)') trigs(j,i)
         else
            write(tout,'(f9.7)') trigs(j,i)
         endif
         write(10,'(a)',advance='no') tout
      enddo !- j
      write(10,*)" "
   enddo !- i

   print *,"computation took",times/real(i,real64),"us per angle"
   close(10); close(12)
 contains
   !> @brief compute sine/cosine/tangent
   subroutine CORDIC(a,t,n)
     real(real64), intent(in) :: a
     real(real64), intent(inout) :: t(3)
     integer, intent(in) :: n
! local variables
     real(real64), parameter :: deg2rad = 1.745329252e-2
     real(real64), parameter :: angles(60) = &
       [ 7.8539816339744830962e-01_real64, 4.6364760900080611621e-01_real64, &
         2.4497866312686415417e-01_real64, 1.2435499454676143503e-01_real64, &
         6.2418809995957348474e-02_real64, 3.1239833430268276254e-02_real64, &
         1.5623728620476830803e-02_real64, 7.8123410601011112965e-03_real64, &
         3.9062301319669718276e-03_real64, 1.9531225164788186851e-03_real64, &
         9.7656218955931943040e-04_real64, 4.8828121119489827547e-04_real64, &
         2.4414062014936176402e-04_real64, 1.2207031189367020424e-04_real64, &
         6.1035156174208775022e-05_real64, 3.0517578115526096862e-05_real64, &
         1.5258789061315762107e-05_real64, 7.6293945311019702634e-06_real64, &
         3.8146972656064962829e-06_real64, 1.9073486328101870354e-06_real64, &
         9.5367431640596087942e-07_real64, 4.7683715820308885993e-07_real64, &
         2.3841857910155798249e-07_real64, 1.1920928955078068531e-07_real64, &
         5.9604644775390554414e-08_real64, 2.9802322387695303677e-08_real64, &
         1.4901161193847655147e-08_real64, 7.4505805969238279871e-09_real64, &
         3.7252902984619140453e-09_real64, 1.8626451492309570291e-09_real64, &
         9.3132257461547851536e-10_real64, 4.6566128730773925778e-10_real64, &
         2.3283064365386962890e-10_real64, 1.1641532182693481445e-10_real64, &
         5.8207660913467407226e-11_real64, 2.9103830456733703613e-11_real64, &
         1.4551915228366851807e-11_real64, 7.2759576141834259033e-12_real64, &
         3.6379788070917129517e-12_real64, 1.8189894035458564758e-12_real64, &
         9.0949470177292823792e-13_real64, 4.5474735088646411896e-13_real64, &
         2.2737367544323205948e-13_real64, 1.1368683772161602974e-13_real64, &
         5.6843418860808014870e-14_real64, 2.8421709430404007435e-14_real64, &
         1.4210854715202003717e-14_real64, 7.1054273576010018587e-15_real64, &
         3.5527136788005009294e-15_real64, 1.7763568394002504647e-15_real64, &
         8.8817841970012523234e-16_real64, 4.4408920985006261617e-16_real64, &
         2.2204460492503130808e-16_real64, 1.1102230246251565404e-16_real64, &
         5.5511151231257827021e-17_real64, 2.7755575615628913511e-17_real64, &
         1.3877787807814456755e-17_real64, 6.9388939039072283776e-18_real64, &
         3.4694469519536141888e-18_real64, 1.7347234759768070944e-18_real64]
     real(real64), parameter :: kvalues(33) = &
       [ 0.70710678118654752440e+00_real64, 0.63245553203367586640e+00_real64, &
         0.61357199107789634961e+00_real64, 0.60883391251775242102e+00_real64, &
         0.60764825625616820093e+00_real64, 0.60735177014129595905e+00_real64, &
         0.60727764409352599905e+00_real64, 0.60725911229889273006e+00_real64, &
         0.60725447933256232972e+00_real64, 0.60725332108987516334e+00_real64, &
         0.60725303152913433540e+00_real64, 0.60725295913894481363e+00_real64, &
         0.60725294104139716351e+00_real64, 0.60725293651701023413e+00_real64, &
         0.60725293538591350073e+00_real64, 0.60725293510313931731e+00_real64, &
         0.60725293503244577146e+00_real64, 0.60725293501477238499e+00_real64, &
         0.60725293501035403837e+00_real64, 0.60725293500924945172e+00_real64, &
         0.60725293500897330506e+00_real64, 0.60725293500890426839e+00_real64, &
         0.60725293500888700922e+00_real64, 0.60725293500888269443e+00_real64, &
         0.60725293500888161574e+00_real64, 0.60725293500888134606e+00_real64, &
         0.60725293500888127864e+00_real64, 0.60725293500888126179e+00_real64, &
         0.60725293500888125757e+00_real64, 0.60725293500888125652e+00_real64, &
         0.60725293500888125626e+00_real64, 0.60725293500888125619e+00_real64, &
         0.60725293500888125617e+00_real64 ]
    real(real64) :: beta, c, c2, factor, poweroftwo, s
    real(real64) :: s2, sigma, sign_factor, theta, angle
    integer :: j

! scale to radians
    beta = a*deg2rad
! ensure angle is shifted to appropriate range
    call angleShift(beta, -PI, theta)
! check for signs
    if( theta < -half*PI) then
       theta = theta + PI
       sign_factor = -1.0_real64
    else if( half*PI < theta) then
       theta = theta - PI
       sign_factor = -1.0_real64
    else
       sign_factor = +1.0_real64
    endif

! set up some initializations...    
    c = 1.0_real64
    s = 0.0_real64
    poweroftwo = 1.0_real64
    angle = angles(1)

! run for 30 iterations (should be good enough, need testing)
    do j=1,n
       sigma = merge(-1.0_real64, +1.0_real64, theta <  0.0_real64)
       factor = sigma*poweroftwo

       c2 = c - factor*s
       s2 = factor*c + s
       c = c2
       s = s2
! update remaining angle
       theta = theta - sigma*angle

       poweroftwo = poweroftwo*0.5_real64
       if(j+1 > 60) then
          angle = angle * 0.5_real64
       else
          angle = angles(j+1)
       endif
    enddo !- j

    if(n > 0) then
       c = c*Kvalues(min(n,33))
       s = s*Kvalues(min(n,33))
    endif
    c = c*sign_factor
    s = s*sign_factor

    t = [s, c, s/c]
   end subroutine CORDIC

   subroutine angleShift(alpha, beta, gamma)
     real(real64), intent(in) :: alpha, beta
     real(real64), intent(out) :: gamma
     if(alpha < beta) then
        gamma = beta - mod(beta - alpha, TAU) + TAU
     else
        gamma = beta + mod(alpha - beta, TAU) 
     endif
   end subroutine angleShift

end program SinCosTan

Comments

শেষ অবধি, কেউ কর্ডিক ব্যবহার করেছেন: ডি

— কিউআর

আমি মনে করি যে "-মার্চ = নেটিভ" হ'ল আইফোর্ট "-xহোস্ট" এর সাথে সম্পর্কিত গফর্ট্রান পতাকা। এছাড়াও, আমি বিশ্বাস করি যে ইন্টেল -O3 গফর্ট্রানের তুলনায় আরও আক্রমণাত্মক মোডে সেট করেছে, সুতরাং আপনি "-O3 -fno- সুরক্ষা-পেরেনস -ফস্ট্যাক-অ্যারে" সাহায্য করে কিনা তা দেখতে গফর্ট্রান চেষ্টা করতে পারেন।

— আধা-বহিরাগত

লুপের ভিতরে আপনি যেহেতু পড়েন না, আপনি পাশাপাশি আইও অংশটিরও সময় নির্ধারণ করছেন। নিয়মগুলি স্পষ্টতই বলেছে আপনার আইও সময় দেওয়া উচিত নয়। এটি স্থির করে দেওয়া আমার কম্পিউটারে বেশ গতিবেগ দিয়েছে: মূল্য প্রতি 0.37 মাইক্রোসেকেন্ড, আপনার পোস্ট কোডের জন্য 6.94 বনাম। এছাড়াও, পোস্ট কোডটি সংকলন করে না, 100 লাইনে একটি পিছনে কমা রয়েছে line 23 লাইনে একটি ত্রুটিও রয়েছে: ট্রিগস (i) কেবল ট্রিজ হওয়া উচিত। এটি পোস্ট কোড segfault তোলে।

— আধা-বহিরাগত

উন্নত সংস্করণটি এখানে: পেস্টবিন.ফ্রেইএইচটিএফএক্স

— আধা-বহিরাগত

আপডেট পুনরায়: সংকলক বিকল্পগুলি: -মার্চ এবং -ফনো-সুরক্ষা-পেরেনগুলি কিছুই করেনি, তবে -ফস্ট্যাক-অ্যারেগুলি মূল্য অনুসারে আরও 0.1 টি মাইক্রোসেকেন্ড মুণ্ডিত করে। "ifort -O3 -xHost" উল্লেখযোগ্যভাবে "গফর্ট্রন -O3 -ফস্ট্যাক-অ্যারে" থেকে প্রায় 2x ধীর: 0.55 বনাম 0.27

— আধা-বহিরাগত

Answer 2

পাইথন ২.7.x বা জাভা (আপনার বাছাই করুন)

ফ্রি পাইথন দোভাষী এখান থেকে ডাউনলোড করা যায় ।
একটি বিনামূল্যে জাভা দোভাষী এখান থেকে ডাউনলোড করা যেতে পারে ।

প্রোগ্রামটি ফাইলের trig.inএকই ডিরেক্টরিতে অবস্থিত একটি ফাইল থেকে প্রোগ্রাম ফাইল হিসাবে ইনপুট নিতে পারে । ইনপুট নিউলাইনগুলি দ্বারা পৃথক করা হয়।

আমি মূলত পাইথনে এটি করেছি কারণ - ভাল, আমি পাইথনকে ভালবাসি। তবে, যেহেতু আমিও জয়ের চেষ্টা করতে চাই, তাই এটি পরে জাভাতে আবার লিখলাম ...

পাইথন সংস্করণ: আমি আমার কম্পিউটারে প্রায় 21 run রান পেয়েছি। আমি যখন এটা চলমান 32μs সম্পর্কে পেয়েছিলাম IDEone উপর ।

জাভা সংস্করণ: আমি আমার কম্পিউটারে প্রায় 0.4µs ​​এবং আইডিয়নে 1.8µ পেয়েছি ।

কম্পিউটার স্পেস:

• উইন্ডোজ 8.1 আপডেট ইন্টেল কোর i7-3632QM - 2.2GHz সহ 1 64-বিট

টেস্ট:

• রান প্রতি সময় "ক্রমসঞ্চিত সময় গণনা করতে এটি লাগে sin, cosএবং tanইনপুট কোণ সব।

• উভয়ের জন্য ব্যবহৃত পরীক্ষার ইনপুটটি নিম্নরূপ:

  90.00000000  
  74.54390000  
  175.5000000  
  3600000.000  
  

কোড সম্পর্কে:
এই কর্মসূচির ভিত্তিটি ছিল 14 টার্মগুলির সাথে তাদের টেলর বহুবচনগুলি অনুমান করা sinএবং cosব্যবহার করা, যা আমি গণনা করেছি এটি 1e-8 এর চেয়ে কম ত্রুটির অনুমান করার জন্য প্রয়োজনীয়। তবে আমি দেখতে পেলাম যে এটির sinচেয়ে বেশি দ্রুত গণনা করা উচিত cos, তাই এটি cosব্যবহার করে গণনা করার সিদ্ধান্ত নিয়েছেcos=sqrt(1-sin^2)

---

পাইথন সংস্করণ:

import math
import timeit
import sys
import os
from functools import partial

#Global Variabls
pi2 = 6.28318530718
piover2 = 1.57079632679

#Global Lists
factorialList = [1.0,
                 -6.0,
                 120.0,
                 -5040.0,
                 362880.0,
                 -39916800.0,
                 6227020800.0,
                 -1307674368000.0,
                 355687428096000.0,
                 -121645100408832000.0,
                 51090942171709440000.0,
                 -25852016738884976640000.0,
                 15511210043330985984000000.0,
                 -10888869450418352160768000000.0,
                 8841761993739701954543616000000.0]

#simplifies angles and converts them to radians
def torad(x):  
    rev = float(x)/360.0
    if (rev>1) or (rev<0):
        return (rev - math.floor(rev))*pi2
    return rev*pi2

def sinyield(x):
    squared = x*x
    for n in factorialList:
        yield x/n
        x*=squared

def tanfastdivide(sin, cos):
    if (cos == 0):
        return "infinity"  
    return sin/cos

#start calculating sin cos and tan
def calcyield(outList):
    for angle in outList[0]:
        angle = torad(angle)
        sin = round(math.fsum(sinyield(angle)), 7)
        cos=math.copysign(math.sqrt(1-(sin*sin)),(piover2-angle))
        yield sin
        yield cos
        yield tanfastdivide(sin, cos) #tan

def calculations(IOList):
    calcyieldgen = calcyield(IOList)
    for angle in IOList[0]:
        IOList[1].append(next(calcyieldgen))
        IOList[2].append(next(calcyieldgen))
        IOList[3].append(next(calcyieldgen))
    return IOList

#Begin input from file
def ImportFile():
    try:
        infile = open("trig.in", "r")
    except:
        infile = sys.stdin
    inList = [[], [], [], []]

    #take input from file
    for line in infile:
        inList[0].extend([float(line)])
    return inList

#Begin output to file
def OutputResults(outList):
    try:
        outfile = open("trig.out", "w")
        PrintOutput(outList, outfile)    
    except:
        print 'Failed to write to file. Printing to stdout instead...'
    finally:
        PrintOutput(outList, sys.stdout)

def PrintOutput(outList, outfile):
    #outList[0][i] holds original angles
    #outList[1][i] holds sin values
    #outList[2][i] holds cos values
    #outList[3][i] holds tan values
    outfile.write('-----------------------------------------------------\n')
    outfile.write('                    TRIG RESULTS                     \n')
    outfile.write('-----------------------------------------------------\n')
    for i in range(len(outList[0])):
        if (i):
            outfile.write('\n')
        outfile.write("For angle: ")
        outfile.write(str(outList[0][i]))
        outfile.write('\n    ')
        outfile.write("Sin: ")
        outfile.write(str('%.7E' % float(outList[1][i])))
        outfile.write('\n    ')
        outfile.write("Cos: ")
        outfile.write(str('%.7E' % float(outList[2][i])))
        outfile.write('\n    ')
        outfile.write("Tan: ")
        outfile.write(str('%.7E' % float(outList[3][i])))


#Run the Program first
inList = ImportFile()
OutputResults(calculations(inList))

#Begin Runtime estimation
def timeTest(IOList):
    for output in calcyield(IOList):
        pass
def baselined(inList):
    for x in inList:
        pass

totime = timeit.Timer(partial(timeTest, inList))
baseline = timeit.Timer(partial(baselined, inList))
print '\n-----------------------------------------------------'
print '                    TIME RESULTS:                    '
print '-----------------------------------------------------'
OverheadwithCalcTime =  min(totime.repeat(repeat=10, number=10000))
Overhead = min(baseline.repeat(repeat=1, number=10000))
estimatedCalcTime = (OverheadwithCalcTime - Overhead)
estimatedTimePerAngle = estimatedCalcTime/len(inList)
estimatedTimePerCalc = estimatedTimePerAngle/3
print ' Estimated CalcTime+Overhead:.....', '%.10f' % (OverheadwithCalcTime*100), 'µsec'
print ' Estimated Overhead Time:..........', '%.10f' % (Overhead*100), 'µsec'
print ''
print ' Estimated CalcTime/Run:..........', '%.10f' % (estimatedCalcTime*100), 'µsec'
print ' Estimated CalcTime/Angle:.........', '%.10f' % (estimatedTimePerAngle*100), 'µsec'
print ' Estimated CalcTime/Cacluation:....', '%.10f' % (estimatedTimePerCalc*100), 'µsec'
print '-----------------------------------------------------'
print "                   COOL, IT WORKED!                  "
print '-----------------------------------------------------'

জাভা সংস্করণ:

import java.io.FileNotFoundException;
import java.io.File;
import java.io.PrintStream;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Scanner;
import java.lang.Math;

class Trig {
   /**
    *Global Variables
    **/
    static final double pi2 = 6.28318530718;
    public long totalTime = 0L;
    static final double piover2 = 1.57079632679;
    static final double plusinfty = Double.POSITIVE_INFINITY;
    static final double minusinfty = Double.NEGATIVE_INFINITY;
    static final double factoriallist[] =
                             new double[]{
                         -6.0,120.0,-5040.0,362880.0,-39916800.0,
                         6227020800.0,-1307674368000.0,355687428096000.0,
                        -121645100408832000.0,51090942171709440000.0,
                        -25852016738884976640000.0,
                         15511210043330985984000000.0,
                        -10888869450418352160768000000.0,
                         8841761993739701954543616000000.0
                         };
//Begin Program
    public static void main(String[] args) {
        Trig mytrig = new Trig();
        double[] input = mytrig.getInput();
        double[][] output = mytrig.calculate(input);
        mytrig.OutputResults(output);
        Trig testIt = new Trig();
        testIt.timeIt(input);
    }

//Begin Timing
    public void timeIt(double[] input) {
        double overhead = 0L;
        totalTime = 0L;

        for (int i = 0; i < 1000001; i++) {
            calculate(input);
            if (i == 0) {
                overhead = totalTime;
                totalTime = 0L;
            }
        }
        double averageTime = ((Double.valueOf(totalTime-overhead))/1000000.0);
        double perAngleTime = averageTime/input.length;
        double perOpperationTime = perAngleTime/3;
        NumberFormat formatter = new DecimalFormat("0000.0000");
        System.out.println("\n-----------------------------------------------------");
        System.out.println("                    TIME RESULTS:                    ");
        System.out.println("-----------------------------------------------------");
        System.out.println("Average Total  Runtime:.......... " + formatter.format(averageTime) + " nsec");
        System.out.println("                                = " + formatter.format(averageTime/1000) + " usec\n");
        System.out.println("Average Runtime Per Angle:....... " + formatter.format(perAngleTime) + " nsec");
        System.out.println("                                = " + formatter.format(perAngleTime/1000) + " usec\n");
        System.out.println("Average Runtime Per Opperation:.. " + formatter.format(perOpperationTime) + " nsec");
        System.out.println("                                = " + formatter.format(perOpperationTime/1000) + " usec");
    }

//Begin Input
    double[] getInput() {
        Scanner in;
        ArrayList<Double> input = new ArrayList<Double>();
        try {
            in = new Scanner(new File("trig.in"));
        } catch (FileNotFoundException e) {
            new FileNotFoundException("Failed to read from file. Reading from stdin instead...").printStackTrace();
            in= new Scanner(System.in);
        }
        while (in.hasNextLine()) {
            Double toadd = Double.parseDouble(in.nextLine());
            input.add(toadd);   
        }
        in.close();
        double[] returnable = new double[input.size()];
        for(int i = 0; i < input.size(); i++) {returnable[i] = input.get(i);}
        return returnable;
    }

//Begin OutputStream Choice
    void OutputResults(double[][] outList) {
        PrintStream out;
        try {
            out = new PrintStream("trig.out");
            PrintOutput(outList, out);
            PrintOutput(outList, System.out);
        } catch (FileNotFoundException e) {
            new FileNotFoundException("Failed to write to file. Printing to stdout instead...").printStackTrace();
            PrintOutput(outList, System.out);
        }
    }

//Begin Output
    static void PrintOutput(double[][] outList, PrintStream out) {
        /**
         *outList[0][i] holds original angles
         *outList[1][i] holds sin values
         *outList[2][i] holds cos values
         *outList[3][i] holds tan values
         */
        NumberFormat formatter = new DecimalFormat("0.0000000E0");
        out.println("-----------------------------------------------------");
        out.println("                    TRIG RESULTS                     ");
        out.println("-----------------------------------------------------");
        for (int i=0; i<outList[0].length; i++) {
            out.println("For Angle: " + outList[0][i]);

            out.println("      sin: " + formatter.format(outList[1][i]));
            out.println("      cos: " + formatter.format(outList[2][i]));
            if (Double.valueOf(outList[3][i]).isInfinite() || Double.valueOf(outList[3][i]).isNaN()) {
                out.println("      tan: " + outList[3][i]);
            }
            else out.println("      tan: " + formatter.format(outList[3][i]));
        }
        if (out != System.out) out.close();
    }

//Begin Calculations
    double[][] calculate(double[] IOList) {
        double[][] outList = new double[4][IOList.length];
        double sin;
        double cos;
        double tan;
        double rads;
        int i = 0;
        long calctime = 0L;
        long startTime;
        long endTime;
        for (double input : IOList) {
            startTime = System.nanoTime();
            rads = toRad(input);
            sin=sin(rads);
            cos = ((piover2-rads)>=0) ? Math.sqrt((1.0-(sin*sin))) : -Math.sqrt((1.0-(sin*sin)));
            tan = (cos!=0.0d) ? sin/cos : ((sin>0) ? plusinfty : minusinfty);
            endTime = System.nanoTime();
            calctime = calctime + endTime - startTime;
            outList[0][i] = input;
            outList[1][i] = sin;
            outList[2][i] = cos;
            outList[3][i] = tan;
            i++;
        }
        totalTime = totalTime + calctime;
        return outList;
    }

//Convert Degrees to Radians
    double toRad(double deg) {
        double rev = deg/360.0;
        return (rev>1 || rev<0) ? Math.abs(rev - ((int)rev))*pi2 : rev*pi2;
    }

//Get sin
    double sin(double angle) {
        double sqr = angle*angle;
        double value = angle;
        for (double fct : factoriallist) {
            value += ((angle*=sqr)/fct);
        }
        return ((long)((value + Math.copySign(0.0000000005d, value))*10000000.0))/10000000.0;
    }   
}

Comments

আপনার কোসাইনগুলি 180 <x <360 এর জন্য ভুল, এবং প্রোগ্রামটি 270

— Οurous

@ অররাস - আমি এটিকে পরিবর্তন করেছি, সুতরাং এটি এখন উভয় ভাষায়ই কাজ করা উচিত।

— ইফ্রয়িম

আপনার cosগণনা ওভারকিল, আমি কেবলই করবsin(x+90degrees)

— স্কিজ

@ স্কিজ - আমার প্রোগ্রামে আমি শব্দটি sinএকটি ফাংশন এবং একটি পরিবর্তনশীল উভয় হিসাবে ব্যবহার করি use আমি ভেবেছিলাম sin()দ্বিতীয়বারের মতো কিছু না দেওয়ার জন্য আরও দ্রুত হবে , তবে আমি সত্যিই কেস কিনা তা দেখতে এই দুজনের সাথে তুলনা করব। আপনার copySign()ফাংশনটি কি এই ফাংশনটি ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে আমার sin()ফাংশন হিসাবে জিনিস যুক্ত করেছে ?

— ইফ্রয়িম

আহা, আমি দেখতে পাচ্ছি আপনি একই সাথে পাপ এবং মহাজোট করছেন। আমার মন্তব্যটি কেবল সত্যই কার্যকর হবে যদি আপনি পাপ বা কোস করছেন।

— স্কিজেড

Answer 3

অক্টাভা (বা মতলব) এবং সি

কিছুটা জটিল নির্মাণ প্রক্রিয়া, তবে একধরনের অভিনব পদ্ধতির এবং ফলাফলটি উত্সাহজনক ছিল were

পদ্ধতির প্রতিটি ডিগ্রির জন্য প্রায় চতুর্ভুজ বহুপদী তৈরি করা হয়। সুতরাং ডিগ্রি = [0, 1), ডিগ্রি = [1, 2), ..., ডিগ্রি = [359, 360) প্রত্যেকের আলাদা আলাদা বহুভুজ থাকবে।

অক্টাভা - বিল্ডিং অংশ

অষ্টাভে সর্বজনীনভাবে উপলব্ধ - গুগল download octave।

এটি প্রতিটি ডিগ্রির জন্য সেরা ফিট চতুষ্কোণ বহুপদী নির্ধারণ করে।

হিসাবে সংরক্ষণ করুন build-fast-trig.m:

format long;
for d = 0:359
    x = (d-1):0.1:(d+1);
    y = sin(x / 360 * 2 * pi);
    polyfit(x, y, 2)
endfor

সি - বিল্ডিং অংশ

এটি আপনার সিস্টেমে পাঠ্য বিন্যাসে দ্বৈত রূপান্তরিত করে দেশীয় বাইনারি বিন্যাসে।

হিসাবে সংরক্ষণ করুন build-fast-trig.c:

#include <stdio.h>

int main()
{
    double d[3];

    while (scanf("%lf %lf %lf", d, d + 1, d + 2) == 3)
        fwrite(d, sizeof(double), 3, stdout);

    return 0;
}

কম্পাইল:

gcc -o build-fast-trig build-fast-trig.c

সহগের ফাইলটি তৈরি করা হচ্ছে

চালান:

octave build-fast-trig.m | grep '^ ' | ./build-fast-trig > qcoeffs.dat

এখন আমাদের কাছে qcoeffs.datআসল প্রোগ্রামটির জন্য ডেটা ফাইল হিসাবে ব্যবহার করতে হবে।

সি - দ্রুত ট্রিগার অংশ

হিসাবে সংরক্ষণ করুন fast-trig.c:

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>

#define INPUT    "qcoeffs.dat"

#define DEGREES    360

typedef struct {double a, b, c;} QCOEFFS;

double normalize(double d)
{
    if (d < 0.0)
        d += ceil(d / -(double)DEGREES) * (double)DEGREES;

    if (d >= (double)DEGREES)
        d -= floor(d / (double)DEGREES) * (double)DEGREES;

    return d;
}

int main()
{
    FILE *f;
    time_t tm;
    double d;
    QCOEFFS qc[DEGREES];

    if (!(f = fopen(INPUT, "rb")) || fread(qc, sizeof(QCOEFFS), DEGREES, f) < DEGREES)
    {
        fprintf(stderr, "Problem with %s - aborting.", INPUT);
        return EXIT_FAILURE;
    }
    fclose(f);

    tm = -clock();

    while (scanf("%lf", &d) > 0)
    {
        int i;
        double e, f;

        /* sin */
        d = normalize(d);
        i = (int)d;
        e = (qc[i].a * d + qc[i].b) * d + qc[i].c;

        /* cos */
        d = normalize((double)DEGREES / 4.0 - d);
        i = (int)d;
        f = (qc[i].a * d + qc[i].b) * d + qc[i].c;

        /* tan = sin / cos */

        /* output - format closest to specs, AFAICT */
        if (d != 0.0 && d != 180.0)
            printf("%.6e %.6e %.6e\n", e, f, e / f);
        else
            printf("%.6e %.6e n\n", e, f);
    }

    tm += clock();

    fprintf(stderr, "time: %.3fs\n", (double)tm/(double)CLOCKS_PER_SEC);    

    return EXIT_SUCCESS;
}

কম্পাইল:

gcc -o fast-trig fast-trig.c -lm

চালান:

./fast-trig < trig.in > trig.out

এটি মিলিসেকেন্ড যথাযথতার সাথে বিচ্ছিন্ন সময়টি সান্ত্বনা দেওয়ার জন্য trig.inসংরক্ষণ করবে trig.outএবং মুদ্রণ করবে।

ব্যবহৃত পরীক্ষামূলক পদ্ধতিগুলির উপর নির্ভর করে এটি নির্দিষ্ট ইনপুটটিতে ব্যর্থ হতে পারে, যেমন:

$ ./fast-trig 
0
-6.194924e-19 1.000000e+00 -6.194924e-19

সঠিক আউটপুট হওয়া উচিত 0.000000e+00 1.000000e+00 0.000000e+00। ফলাফলগুলি যদি স্ট্রিংগুলি ব্যবহার করে যাচাই করা হয়, তবে ইনপুটটি ব্যর্থ হবে, যদি তারা নিখুঁত ত্রুটি ব্যবহার করে যাচাই করা হয়, উদাহরণস্বরূপ fabs(actual - result) < 1e-06, ইনপুটটি পাস হয়ে যাবে।

জন্য সর্বোচ্চ পরম ত্রুটি sinএবং cosছিল ≤ 3E-07। কারণ tan, ফলাফলটি ± 1 এর মধ্যে সীমাবদ্ধ নয় এবং আপনি তুলনামূলকভাবে কম সংখ্যার দ্বারা তুলনামূলকভাবে বড় সংখ্যাকে ভাগ করতে পারেন, পরম ত্রুটি আরও বড় হতে পারে। -1 ≤ ট্যান (এক্স) ≤ +1 থেকে সর্বাধিক পরম ত্রুটি ছিল ≤ 4e-07। ট্যান (x)> 1 এবং ট্যান (এক্স) <-1 এর ক্ষেত্রে সর্বাধিক আপেক্ষিক ত্রুটি, যেমন fabs((actual - result) / actual)আপনি (90 ± 5) বা (270 ± 5) ডিগ্রি পর্যন্ত না পৌঁছানো পর্যন্ত সাধারণত <1e-06 ছিল, তারপরে ত্রুটি আরও খারাপ হয়।

পরীক্ষার মধ্যে, একক ইনপুট প্রতি গড় সময় (1.053 ± 0.007) μs, যা আমার মেশিনে 0,070 μs সম্পর্কে দ্রুত নেটিভ চেয়ে ছিল sinএবং cos, tanএকই ভাবে সংজ্ঞায়িত হচ্ছে।

Answer 4

গোক্ষুরা

class Trig
    const mod as float = 0.0174532925199433f #0.0174532925199432957692369076848861271344287188854172f
    var time as System.Diagnostics.Stopwatch = System.Diagnostics.Stopwatch()
    var file as String[] = File.readAllLines('trig.in')
    var sin_out as float[] = float[](1)
    var cos_out as float[] = float[](1)
    var tan_out as float[] = float[](1)
    def main
        .compute(@[1f])
        .time.reset
        input = float[](.file.length)
        for num, line in .file.numbered, input[num] = float.parse(line)
        .compute(input)
        for num in .file.length, .file[num] = (.sin_out[num].toString('0.000000E+0') + ' ' + .cos_out[num].toString('0.000000E+0') + ' ' + .tan_out[num].toString('0.000000E+0'))
        File.writeAllLines('trig.out', .file)
        print .time.elapsed
    def compute(list as float[])
        .sin_out = float[](list.length)
        .cos_out = float[](list.length)
        .tan_out = float[](list.length)
        .time.start
        for index in list.length
            degrees as float = list[index]
            #add `degrees %= 360` for numbers greater than 360
            rad as float = sin as float = degrees * .mod
            two as float = rad * rad
            sin -= (rad *= two) / 6
            sin += (rad *= two) / 120
            sin -= (rad *= two) / 5040
            sin += (rad *= two) / 362880
            sin -= (rad *= two) / 39916800
            sin += (rad *= two) / 6227020800
            sin -= (rad *= two) / 1307674368000
            sin += (rad *= two) / 355687428096000
            sin -= (rad *= two) / 121645100408832000
            sin += (rad *= two) / 51090942171709440000f
            sin -= (rad *= two) / 25852016738884976640000f
            sin += (rad *= two) / 15511210043330985984000000f
            sin -= (rad *= two) / 10888869450418352160768000000f
            sin += (rad *= two) / 8841761993739701954543616000000f
            cos as float = (1 - (sin * sin)).sqrt * ((degrees - 180).abs - 90).sign
            if cos.isNaN, cos = 0
            .tan_out[index] = Math.round((sin / cos) * 10000000) / 10000000
            .sin_out[index] = Math.round(sin * 10000000) / 10000000
            .cos_out[index] = Math.round(cos * 10000000) / 10000000
        .time.stop

এটি দিয়ে সংকলন cobra filename -turbo

পরীক্ষাগুলি: এএমডি এফএক্স 6300 @ 5.1GHz

• সি উত্তর দ্বারা ব্যবহৃত 360 * 10000 পরীক্ষা 365 মিমি (বনাম 190 মিমি) এ চলে

• পাইথন এবং জাভা উত্তর দ্বারা ব্যবহৃত 4-প্রবেশ পরীক্ষা 0.32 tests (বনাম 30µs, 3µs) মধ্যে সঞ্চালিত

• ফরট্রান উত্তর দ্বারা ব্যবহৃত 1000 এলোমেলো কোণ পরীক্ষা 100 কোণে প্রতি চলমান (বনাম 10µs)

Comments

সুতরাং ভুল উত্তর দেওয়া এবং খুব ধীর হওয়া ছাড়াও, ঠিক আছে? :)

@ ল্যাম্বিক এটি এখন ঠিক।

— ousurous

আপনি কি বুঝতে পারছেন যে আপনি মূলত একই প্রোগ্রামটি অন্য একটি সাপে লিখেছেন?

— ইফ্রয়িম

Answer 5

সি

আমার চেষ্টা এখানে। এটি এর মতো কাজ করে:

0 থেকে 450 ডিগ্রি পর্যন্ত সমস্ত মানের পাপের (x) সারণী তৈরি করুন। সমানভাবে এটি কোক্সের সমস্ত মান (x) থেকে 90 ডিগ্রি থেকে 360 ডিগ্রি। 2926 উপাদানগুলির সাথে প্রতি 1 / 6.5 ডিগ্রি মানের জন্য পর্যাপ্ত জায়গা রয়েছে। প্রোগ্রাম ইউনিট তাই 1 / 6.5 ডিগ্রি, এবং একটি চতুর্থাংশ ঘুরে 585 ইউনিট আছে।

ইনপুট ডিগ্রিগুলিকে প্রোগ্রাম ইউনিটে রূপান্তর করুন (এর দ্বারা গুণিত করুন 6.5==110.1 binary.) সারণী থেকে পাপ এবং কোসের নিকটতম মানগুলি সন্ধান করুন। তারপরে ইনপুট (dx) এর অবশিষ্ট অংশটিকে রেডিয়ানে রূপান্তর করুন।

সূত্র sin(x+dx) == sin x +(d(sin x)/dx)*dx.নোটটি প্রয়োগ করুন (d(sin x)/dx)==cos x,তবে কেবলমাত্র আমরা রেডিয়ান ব্যবহার করি।

দুর্ভাগ্যক্রমে এটি নিজের মতো করে যথাযথভাবে সঠিক নয়, সুতরাং পরবর্তী ডেরাইভেটিভের উপর ভিত্তি করে অন্য একটি পদ প্রয়োজন, এটি 2 দিয়ে d2(sin x)/dx2 == -sin x.গুণিত করা দরকার dx*dx/2(2 এর গুণকটি কোথা থেকে এসেছে তা নিশ্চিত নয়, তবে এটি কার্যকর হয়))

জন্য অনুরূপ পদ্ধতি অনুসরণ করুন cos x , তারপরে গণনা করুন tan x == sin x / cos x।

কোড

এখানে প্রায় 17 টি ফ্লোটিং পয়েন্ট অপারেশন রয়েছে। তাতে কিছুটা উন্নতি হতে পারে। প্রোগ্রামে দেশীয় ট্রিগার ফাংশনগুলি ব্যবহার করে টেবিল-বিল্ডিং এবং পরীক্ষার আউটপুট রয়েছে তবে অ্যালগরিদম এটি করে না। আমি সময় যুক্ত করব এবং পরে I / O প্রয়োজনীয়তা মেনে চলতে সম্পাদনা করব (আশা করি এই সপ্তাহান্তে।) এটি পাপ এক্স এবং কোস এক্স এর খুব ছোট মান বাদে নেটিভ ফাংশন আউটপুটটির সাথে মিলে যায়, যা দেশীয় ফাংশন আউটপুটটির চেয়ে আরও উন্নত হওয়া উচিত কিছু টুইট।

<#include <math.h>                                                 //only for table building and testing
int a;
double t[2926],                                                    //a table for sin x from 0 to 360+90=450deg every 1/6.5 degrees
x,                                                                 //input
s,c,                                                               //first guess sin and cos (from table)
sn,cs,                                                             //output sin and cos
pi1170=3.1415926535897932384626433832795/1170,                     // there are 1170 units of 1/6.5 degrees in a half circle 
pi180=3.1415926535897932384626433832795/180;                       // pi/180 only used for testing

main(){
  for (a=0;a<=2925;a++)t[a]=sin(a*pi1170);                         //build table. 

  scanf("%lf",&x);                                                 //input 
  printf("%le %le %le\n",sin(x*pi180),cos(x*pi180),tan(x*pi180));  //native output for testing purposes

  x*=6.5;                                                          //convert from deg to program units. 6.5=110.1 in binary, a fairly round number. 
  a=x+0.5;                                                         //a=round(x) add 0.5 to round, not truncate. Assigning to int, this is probably faster than the round function.
  x=(x-a)*pi1170;                                                  //(x-a)=dx in program units. Divide to get radians. 

  s=t[a];                                                          //get sin(a) from table
  c=t[a+585];                                                      //cos(a)=sin(a+90degrees)=sin(a+585units)
  sn=s+c*x-s*x*x/2;                                                //sin(x+dx)=sin(x)+cos(dx)-sin(dx^2/2)
  cs=c-s*x-c*x*x/2;                                                //cos(x+dx)=cos(x)-sin(dx)-cos(dx^2/2)
  printf("%le %le %le\n",sn,cs,sn/cs);                             //print sin,cos and tan=sin/cos
}