পাইথন আসলে কত ধীর? (বা আপনার ভাষা কত দ্রুত?)

Question

পাইথন / নম্পপিতে আমি এই কোডটি লিখেছি

from __future__ import division
import numpy as np
import itertools

n = 6
iters = 1000
firstzero = 0
bothzero = 0
""" The next line iterates over arrays of length n+1 which contain only -1s and 1s """
for S in itertools.product([-1, 1], repeat=n+1):
    """For i from 0 to iters -1 """
    for i in xrange(iters):
        """ Choose a random array of length n.
            Prob 1/4 of being -1, prob 1/4 of being 1 and prob 1/2 of being 0. """
        F = np.random.choice(np.array([-1, 0, 0, 1], dtype=np.int8), size=n)
        """The next loop just makes sure that F is not all zeros."""
        while np.all(F == 0):
            F = np.random.choice(np.array([-1, 0, 0, 1], dtype=np.int8), size=n)
        """np.convolve(F, S, 'valid') computes two inner products between
        F and the two successive windows of S of length n."""
        FS = np.convolve(F, S, 'valid')
        if FS[0] == 0:
            firstzero += 1
        if np.all(FS == 0):
            bothzero += 1

print("firstzero: %i" % firstzero)
print("bothzero: %i" % bothzero)

এটি দুটি এলোমেলো অ্যারেগুলির সংশ্লেষণের সংখ্যা গণনা করছে, একটি যা একটি নির্দিষ্ট সম্ভাবনার বন্টন সহ অন্যটির তুলনায় একটি দীর্ঘ, এটি প্রথম অবস্থানে একটি 0 বা উভয় পদে 0 রয়েছে।

আমার এক বন্ধুর সাথে বাজি ছিল যা বলে যে পাইথন কোড লেখার জন্য একটি ভয়ঙ্কর ভাষা যার দ্রুত হওয়া দরকার। এটি আমার কম্পিউটারে 9s লাগে। তিনি বলেছেন যে "যথাযথ ভাষায়" লিখিত হলে এটি 100 গুণ দ্রুত করা যায়।

চ্যালেঞ্জটি হ'ল এই কোডটি আপনার পছন্দের যে কোনও ভাষায় 100 গুণ দ্রুত তৈরি করতে পারে কিনা তা দেখার বিষয়। আমি আপনার কোডটি পরীক্ষা করব এবং এখন থেকে এক সপ্তাহের মধ্যে দ্রুততম বিজয়ী হব। যদি কেউ 0.09 এর নীচে থেকে যায় তবে তারা স্বয়ংক্রিয়ভাবে জিতে যায় এবং আমি হেরে যাই।

অবস্থা

• পাইথন । অ্যালিস্টায়ার বাক্সন 30 গতি বাড়িয়েছেন! দ্রুততম সমাধান না হলেও এটি আসলে আমার প্রিয়।
• অষ্টাভ । @ থোথস দ্বারা 100 গুণ গতি বাড়ান।
• মরচে । @ Dbaupp দ্বারা 500 বার গতি বাড়ান।
• সি ++ । গাই স্যারটন দ্বারা 570 বার গতি বাড়ানো।
• গ । @ গতিবেগ দ্বারা 727 গুণ গতিবেগ।
• সি ++ । অবিশ্বাস্যরূপে @ স্টেফান দ্বারা দ্রুত।

দ্রুততম সমাধানগুলি এখন সংবেদনশীল সময়ের চেয়ে খুব দ্রুত। আমি অতএব n টি 10 ​​এ বৃদ্ধি করেছি এবং সেরাগুলির সাথে তুলনা করতে এটির = 100000 সেট করেছি। এই পরিমাপের অধীনে দ্রুততম হয়।

• গ । 7.5s @ace দ্বারা
• সি ++ । @ স্টেফান দ্বারা 1 এস।

আমার মেশিনের সময়গুলি আমার মেশিনে চালিত হবে। এটি একটি এএমডি এফএক্স-8350 এইট-কোর প্রসেসরে একটি স্ট্যান্ডার্ড উবুন্টু ইনস্টল। এর অর্থ হল আপনার কোডটি চালাতে আমার সক্ষম হওয়া দরকার।

আপ পোস্ট অনুসরণ হিসাবে এই প্রতিযোগিতার বরং খুব x100 speedup পেতে সহজ ছিল, আমি যারা তাদের গতি গুরু দক্ষতার ব্যায়াম করতে চান তাদের জন্য একটি ফলোআপ পোস্ট করেছেন। দেখুন কিভাবে ধীর পাইথন সত্যিই (পার্ট II)?

Answer 1

সি ++ বিট যাদু

সাধারণ আরএনজি সহ 0.84ms, সি ++ 11 স্ট্যান্ড :: নথের সাথে 1.67ms

হালকা অ্যালগোরিদমিক পরিবর্তন সহ 0.16ms (নীচে সম্পাদনা দেখুন)

অজগর বাস্তবায়নটি আমার রগটিতে 9.৯7 সেকেন্ডে চলে। সুতরাং আপনি কী নির্বাচন করছেন আরএনজি তার উপর নির্ভর করে এটি 9488 থেকে 4772 গুণ দ্রুত।

#include <iostream>
#include <bitset>
#include <random>
#include <chrono>
#include <stdint.h>
#include <cassert>
#include <tuple>

#if 0
// C++11 random
std::random_device rd;
std::knuth_b gen(rd());

uint32_t genRandom()
{
    return gen();
}
#else
// bad, fast, random.

uint32_t genRandom()
{
    static uint32_t seed = std::random_device()();
    auto oldSeed = seed;
    seed = seed*1664525UL + 1013904223UL; // numerical recipes, 32 bit
    return oldSeed;
}
#endif

#ifdef _MSC_VER
uint32_t popcnt( uint32_t x ){ return _mm_popcnt_u32(x); }
#else
uint32_t popcnt( uint32_t x ){ return __builtin_popcount(x); }
#endif



std::pair<unsigned, unsigned> convolve()
{
    const uint32_t n = 6;
    const uint32_t iters = 1000;
    unsigned firstZero = 0;
    unsigned bothZero = 0;

    uint32_t S = (1 << (n+1));
    // generate all possible N+1 bit strings
    // 1 = +1
    // 0 = -1
    while ( S-- )
    {
        uint32_t s1 = S % ( 1 << n );
        uint32_t s2 = (S >> 1) % ( 1 << n );
        uint32_t fmask = (1 << n) -1; fmask |= fmask << 16;
        static_assert( n < 16, "packing of F fails when n > 16.");


        for( unsigned i = 0; i < iters; i++ )
        {
            // generate random bit mess
            uint32_t F;
            do {
                F = genRandom() & fmask;
            } while ( 0 == ((F % (1 << n)) ^ (F >> 16 )) );

            // Assume F is an array with interleaved elements such that F[0] || F[16] is one element
            // here MSB(F) & ~LSB(F) returns 1 for all elements that are positive
            // and  ~MSB(F) & LSB(F) returns 1 for all elements that are negative
            // this results in the distribution ( -1, 0, 0, 1 )
            // to ease calculations we generate r = LSB(F) and l = MSB(F)

            uint32_t r = F % ( 1 << n );
            // modulo is required because the behaviour of the leftmost bit is implementation defined
            uint32_t l = ( F >> 16 ) % ( 1 << n );

            uint32_t posBits = l & ~r;
            uint32_t negBits = ~l & r;
            assert( (posBits & negBits) == 0 );

            // calculate which bits in the expression S * F evaluate to +1
            unsigned firstPosBits = ((s1 & posBits) | (~s1 & negBits));
            // idem for -1
            unsigned firstNegBits = ((~s1 & posBits) | (s1 & negBits));

            if ( popcnt( firstPosBits ) == popcnt( firstNegBits ) )
            {
                firstZero++;

                unsigned secondPosBits = ((s2 & posBits) | (~s2 & negBits));
                unsigned secondNegBits = ((~s2 & posBits) | (s2 & negBits));

                if ( popcnt( secondPosBits ) == popcnt( secondNegBits ) )
                {
                    bothZero++;
                }
            }
        }
    }

    return std::make_pair(firstZero, bothZero);
}

int main()
{
    typedef std::chrono::high_resolution_clock clock;
    int rounds = 1000;
    std::vector< std::pair<unsigned, unsigned> > out(rounds);

    // do 100 rounds to get the cpu up to speed..
    for( int i = 0; i < 10000; i++ )
    {
        convolve();
    }


    auto start = clock::now();

    for( int i = 0; i < rounds; i++ )
    {
        out[i] = convolve();
    }

    auto end = clock::now();
    double seconds = std::chrono::duration_cast< std::chrono::microseconds >( end - start ).count() / 1000000.0;

#if 0
    for( auto pair : out )
        std::cout << pair.first << ", " << pair.second << std::endl;
#endif

    std::cout << seconds/rounds*1000 << " msec/round" << std::endl;

    return 0;
}

অতিরিক্ত রেজিস্টারগুলির জন্য -৪-বিটে সংকলন করুন। সাধারণ র্যান্ডম জেনারেটরটি কোনও মেমরি অ্যাক্সেস ছাড়াই কনভলভ () চালানো লুপগুলি ব্যবহার করার সময়, সমস্ত ভেরিয়েবলগুলি রেজিস্টারে সংরক্ষণ করা হয়।

এটি কীভাবে কাজ করে: মেমোরি অ্যারেগুলিকে সংরক্ষণ Sএবং সংরক্ষণের পরিবর্তে Fএটি uint32_t এ বিট হিসাবে সংরক্ষণ করা হয়।
জন্য S, nসর্বনিম্ন উল্লেখযোগ্য বিটগুলি ব্যবহৃত হয় যেখানে সেট বিট একটি +1 চিহ্নিত করে এবং একটি আনসেট বিট একটি -1 নির্দেশ করে।
F[-1, 0, 0, 1] এর বিতরণ তৈরি করতে কমপক্ষে 2 টি বিট লাগবে। এটি এলোমেলো বিট জেনারেট করে এবং 16 টি সর্বনিম্ন তাৎপর্যপূর্ণ (ডাকা r) এবং 16 টি সবচেয়ে উল্লেখযোগ্য বিট (ডাকা l) পরীক্ষা করে is l & ~rআমরা যদি ধরে নিই যে এফটি +1, ~l & rআমরা যদি ধরে নিই যে F-1। অন্যথায় F0 হয় এটি আমাদের বিতরণটি বিতরণ করে।

এখন আমাদের রয়েছে S, posBitsপ্রতিটি অবস্থানে একটি সেট বিট যেখানে এফ == 1 এবং negBitsপ্রতিটি অবস্থান যেখানে একটি সেট বিট যেখানে এফ == -1 রয়েছে।

আমরা প্রমাণ করতে পারেন F * S(যেখানে * গুণ উল্লেখ করে) অবস্থার অধীনে +1 করতে মূল্যায়ণ (S & posBits) | (~S & negBits)। আমরা সমস্ত ক্ষেত্রে যেখানে F * S-1 মূল্যায়ন করে একই রকম যুক্তি তৈরি করতে পারি । এবং পরিশেষে, আমরা জানি যে sum(F * S)0 এবং যদি ফলাফলের সমান পরিমাণ -1 এবং +1 এর সমান পরিমাণ থাকে কেবল তখনই মূল্যায়ন করে। এটি +1 বিট এবং -1 বিটের সংখ্যা কেবল তুলনা করে গণনা করা খুব সহজ।

এই বাস্তবায়নে 32 বিট ইনট ব্যবহার করা হয় এবং সর্বাধিক nস্বীকৃত 16 হয় rand

সম্পাদন করা

ফোলিং কনভলভ ফাংশন:

std::pair<unsigned, unsigned> convolve()
{
    const uint32_t n = 6;
    const uint32_t iters = 1000;
    unsigned firstZero = 0;
    unsigned bothZero = 0;
    uint32_t fmask = (1 << n) -1; fmask |= fmask << 16;
    static_assert( n < 16, "packing of F fails when n > 16.");


    for( unsigned i = 0; i < iters; i++ )
    {
        // generate random bit mess
        uint32_t F;
        do {
            F = genRandom() & fmask;
        } while ( 0 == ((F % (1 << n)) ^ (F >> 16 )) );

        // Assume F is an array with interleaved elements such that F[0] || F[16] is one element
        // here MSB(F) & ~LSB(F) returns 1 for all elements that are positive
        // and  ~MSB(F) & LSB(F) returns 1 for all elements that are negative
        // this results in the distribution ( -1, 0, 0, 1 )
        // to ease calculations we generate r = LSB(F) and l = MSB(F)

        uint32_t r = F % ( 1 << n );
        // modulo is required because the behaviour of the leftmost bit is implementation defined
        uint32_t l = ( F >> 16 ) % ( 1 << n );

        uint32_t posBits = l & ~r;
        uint32_t negBits = ~l & r;
        assert( (posBits & negBits) == 0 );

        uint32_t mask = posBits | negBits;
        uint32_t totalBits = popcnt( mask );
        // if the amount of -1 and +1's is uneven, sum(S*F) cannot possibly evaluate to 0
        if ( totalBits & 1 )
            continue;

        uint32_t adjF = posBits & ~negBits;
        uint32_t desiredBits = totalBits / 2;

        uint32_t S = (1 << (n+1));
        // generate all possible N+1 bit strings
        // 1 = +1
        // 0 = -1
        while ( S-- )
        {
            // calculate which bits in the expression S * F evaluate to +1
            auto firstBits = (S & mask) ^ adjF;
            auto secondBits = (S & ( mask << 1 ) ) ^ ( adjF << 1 );

            bool a = desiredBits == popcnt( firstBits );
            bool b = desiredBits == popcnt( secondBits );
            firstZero += a;
            bothZero += a & b;
        }
    }

    return std::make_pair(firstZero, bothZero);
}

রানটাইমটি 0.160-0.161ms এ কেটে দেয়। ম্যানুয়াল লুপ আনরোল (উপরে চিত্র নয়) যে 0.150 করে তোলে। তুচ্ছ কম এন = 10, এটি = 100000 কেস 250 মিমি এর অধীনে চলে। আমি নিশ্চিত যে আমি অতিরিক্ত কোর ব্যবস্থার মাধ্যমে এটি 50 মিটারের নীচে পেতে পারি তবে এটি খুব সহজ।

এটি অভ্যন্তরীণ লুপের শাখাটি বিনামূল্যে তৈরি করে এবং এফ এবং এস লুপটি অদলবদলের মাধ্যমে করা হয়।
যদি bothZeroপ্রয়োজন না হয় তবে আমি সম্ভব সমস্ত এস অ্যারেগুলিতে খুব কম লুপিং করে রান সময়টি 0.02 মিমি থেকে কমিয়ে ফেলতে পারি।

Comments

আপনি কি একটি জিসিসি বান্ধব সংস্করণ প্রদান করতে পারেন এবং আপনার কমান্ড লাইনটি কী হবে দয়া করে? আমি নিশ্চিত না যে আমি এটি বর্তমানে পরীক্ষা করতে পারি।

আমি এই সম্পর্কে কিছুই জানি না তবে গুগল আমাকে বলে যে __ বিল্টিন_পপকাউন্ট _ মিমি_পপ্যাক্ট_উ 32 () এর প্রতিস্থাপন হতে পারে।

কোড আপডেট হয়েছে, সঠিক পপকন্ট কমান্ড নির্বাচন করতে #ifdef সুইচ ব্যবহার করে। এটি -std=c++0x -mpopcnt -O2321 বিট মোডে চলতে 1.01 মিমি সহ কম্পাইল করে এবং লাগে (আমার হাতে একটি 64-বিট জিসিসি সংস্করণ নেই)।

— স্টিফান

আপনি কি এটি আউটপুট মুদ্রণ করতে পারেন? আমি বর্তমানে নিশ্চিত যে এটি বর্তমানে কিছু করছে কিনা তা নিশ্চিত নই :)

আপনি স্পষ্টতই একটি উইজার্ড। + 1

— বার্টপিজা

Answer 2

পাইথন 2.7 + নম্পি 1.8.1: 10.242 এস

ফরট্রান 90+: 0.029 এস 0.003 এস 0.022 এস 0.010 এস

অভিঘাত সোজা আপনি আপনার বাজি হারিয়েছেন! এখানেও সমান্তরালনের একটি ফোঁটা নয়, কেবল সোজা ফোর্টরান 90+।

এডিট করুন অ্যারে অনুমতি দেওয়ার জন্য আমি গাই স্যার্টনের অ্যালগরিদম নিয়েছি S(ভাল খুঁজুন: ডি)। আমার স্পষ্টতই -g -tracebackসংকলক পতাকাগুলি সক্রিয় ছিল যা এই কোডটি প্রায় 0.017 এর দিকে ধীর করে চলেছিল। বর্তমানে, আমি এটি হিসাবে সংকলন করছি

ifort -fast -o convolve convolve_random_arrays.f90

যাদের নেই তাদের জন্য ifort, আপনি ব্যবহার করতে পারেন

gfortran -O3 -ffast-math -o convolve convolve_random_arrays.f90

সম্পাদনা 2 : রান-টাইমে হ্রাস হ'ল কারণ আমি আগে কিছু ভুল করছিলাম এবং একটি ভুল উত্তর পেয়েছি। এটি সঠিকভাবে করা আপাতদৃষ্টিতে ধীর। আমি এখনও বিশ্বাস করতে পারি না যে সি ++ আমার চেয়ে দ্রুত, সুতরাং আমি সম্ভবত এই সপ্তাহে কিছুটা সময় ব্যয় করতে যাচ্ছি এটির গতি বাড়ানোর জন্য এটিকে ফাঁকা করার জন্য চেষ্টা করতে।

সম্পাদনা 3 : কেবল বিএসডি এর আরএনজি ভিত্তিক একটি ব্যবহার করে আরএনজি বিভাগ পরিবর্তন করে (সাম্পো স্মোল্যান্ডারের পরামর্শ অনুসারে) এবং ধ্রুবক বিভাজনটি দূর করে m1আমি গাই সির্টনের সি ++ উত্তর হিসাবে রান- টাইমটি কেটেছি । স্ট্যাটিক অ্যারেগুলি (শার্পির পরামর্শ অনুসারে) রান-টাইমকে সি ++ রান-টাইমের আওতায় ফেলে! ইয়ে ফোর্টরান! : ডি

সম্পাদনা 4 স্পষ্টতই এটি সংকলন করে না (গফর্ট্রান সহ) এবং সঠিকভাবে চালিত হয় (ভুল মান) কারণ পূর্ণসংখ্যাগুলি তাদের সীমা ছাড়িয়ে চলেছে। এটি কাজ করে তা নিশ্চিত করার জন্য আমি সংশোধন করেছি, তবে এর জন্য হয় আইফোর্ট ১১+ বা গফর্ট্রান ৪.7++ (অথবা অন্য সংকলক যা মঞ্জুরি দেয় iso_fortran_envএবং F2008 int64ধরনের)।

কোডটি এখানে:

program convolve_random_arrays
   use iso_fortran_env
   implicit none
   integer(int64), parameter :: a1 = 1103515245
   integer(int64), parameter :: c1 = 12345
   integer(int64), parameter :: m1 = 2147483648
   real, parameter ::    mi = 4.656612873e-10 ! 1/m1
   integer, parameter :: n = 6
   integer :: p, pmax, iters, i, nil(0:1), seed
   !integer, allocatable ::  F(:), S(:), FS(:)
   integer :: F(n), S(n+1), FS(2)

   !n = 6
   !allocate(F(n), S(n+1), FS(2))
   iters = 1000
   nil = 0

   !call init_random_seed()

   S = -1
   pmax = 2**(n+1)
   do p=1,pmax
      do i=1,iters
         F = rand_int_array(n)
         if(all(F==0)) then
            do while(all(F==0))
               F = rand_int_array(n)
            enddo
         endif

         FS = convolve(F,S)

         if(FS(1) == 0) then
            nil(0) = nil(0) + 1
            if(FS(2) == 0) nil(1) = nil(1) + 1
         endif

      enddo
      call permute(S)
   enddo

   print *,"first zero:",nil(0)
   print *," both zero:",nil(1)

 contains
   pure function convolve(x, h) result(y)
!x is the signal array
!h is the noise/impulse array
      integer, dimension(:), intent(in) :: x, h
      integer, dimension(abs(size(x)-size(h))+1) :: y
      integer:: i, j, r
      y(1) = dot_product(x,h(1:n-1))
      y(2) = dot_product(x,h(2:n  ))
   end function convolve

   pure subroutine permute(x)
      integer, intent(inout) :: x(:)
      integer :: i

      do i=1,size(x)
         if(x(i)==-1) then
            x(i) = 1
            return
         endif
         x(i) = -1
      enddo
   end subroutine permute

   function rand_int_array(i) result(x)
     integer, intent(in) :: i
     integer :: x(i), j
     real :: y
     do j=1,i
        y = bsd_rng()
        if(y <= 0.25) then
           x(j) = -1
        else if (y >= 0.75) then
           x(j) = +1
        else
           x(j) = 0
        endif
     enddo
   end function rand_int_array

   function bsd_rng() result(x)
      real :: x
      integer(int64) :: b=3141592653
      b = mod(a1*b + c1, m1)
      x = real(b)*mi
   end function bsd_rng
end program convolve_random_arrays

আমি মনে করি এখন প্রশ্নটি হ'ল আপনি কি আস্তে-তে-গুড় পাইথন ব্যবহার বন্ধ করবেন এবং দ্রুত-ইলেক্ট্রন-চালিত ফোর্টরান ব্যবহার করতে পারবেন;)।

Comments

কেস স্টেটমেন্ট যাইহোক কোনও জেনারেটরের ফাংশনের চেয়ে দ্রুত হবে না? আপনি যদি কোনও ধরণের শাখা-পূর্বাভাস / ক্যাশে-লাইন / ইত্যাদি স্পিডআপের আশা না করেন তবে?

— অরেঞ্জডগ

একই মেশিনের সাথে গতির তুলনা করা উচিত। ওপির কোডটির জন্য আপনি কোন রানটাইম পেয়েছেন?

— nbubis

সি ++ উত্তরটি নিজস্ব, খুব লাইটওয়েট এলোমেলো সংখ্যা জেনারেটর প্রয়োগ করে। আপনার উত্তরটি সংকলকটির সাথে উপস্থিত ডিফল্ট ব্যবহার করেছে, যা ধীর হতে পারে?

— সাম্পো স্মোল্যান্ডার

এছাড়াও, সি ++ উদাহরণটি স্থিরভাবে বরাদ্দ করা অ্যারেগুলি ব্যবহার করে বলে মনে হচ্ছে। সংকলনের সময় নির্ধারিত স্থির দৈর্ঘ্যের অ্যারেগুলি ব্যবহার করে দেখুন এবং এটি কোনও সময় শেভ করে কিনা তা দেখুন।

— শার্পি

@ কাইলকানোস @ ললেবিকের সমস্যাটি হ'ল ফোর্টরানে পূর্ণসংখ্যার কাজটি স্পষ্টভাবে ইন্টু specific64 স্পেসিফিকেশন ব্যবহার করছে না, সুতরাং কোনও রূপান্তর হওয়ার আগে সংখ্যাগুলি 32 হয় are কোডটি হওয়া উচিত: integer(int64) :: b = 3141592653_int64সমস্ত অন্তর্ভুক্তের জন্য। এটি ফোর্টরান স্ট্যান্ডার্ডের অংশ এবং প্রোগ্রামার দ্বারা প্রকারভেদযুক্ত প্রোগ্রামিং ভাষায় প্রত্যাশা করা হয়। (লক্ষ্য করুন যে অবশ্যই ডিফল্ট সেটিংস এটিকে ওভাররাইড করতে পারে)

— জেরোথ

Answer 3

পাইথন 2.7 - 0.882 এস 0.283 এস

(ওপির মূল: 6.404 সে)

সম্পাদনা: স্টিভেন রাম্বালস্কির অপ্টিমাইজেশন এফ মানগুলি পূর্বাভাস দিয়ে। এই অপ্টিমাইজেশনের সাহায্যে পাইপথন পিপির 0.365s মারধর করে।

import itertools
import operator
import random

n=6
iters = 1000
firstzero = 0
bothzero = 0

choicesF = filter(any, itertools.product([-1, 0, 0, 1], repeat=n))

for S in itertools.product([-1,1], repeat = n+1):
    for i in xrange(iters):
        F = random.choice(choicesF)
        if not sum(map(operator.mul, F, S[:-1])):
            firstzero += 1
            if not sum(map(operator.mul, F, S[1:])):
                bothzero += 1

print "firstzero", firstzero
print "bothzero", bothzero

এই খাঁটি অজগর বাস্তবায়ন যেমন দেখায়, ওপির আসল কোড এ জাতীয় ক্ষুদ্র অ্যারেগুলি ব্যবহার করে নিম্পি ব্যবহার করার কোনও লাভ নেই। তবে এই নাম্বার বাস্তবায়নটিও দেখুন যা আমার কোডের চেয়ে তিনগুণ দ্রুত।

প্রথম ফলাফলটি শূন্য না হলে বাকী প্রত্যয়টি এড়িয়ে গিয়ে আমিও অনুকূলিতকরণ করি।

Comments

পাইপির সাহায্যে এটি প্রায় 0.5 সেকেন্ডে চলে।

— অ্যালিস্টার Buxton,

আপনি যদি এন = 10 সেট করেন তবে আপনি অনেক বেশি দৃ speed়প্রবণ গতিসম্পন্ন পাবেন I

আর একটি অপ্টিমাইজেশন হ'ল সম্ভাব্যতাগুলির পূর্ববর্তী করা Fকারণ সেগুলির মধ্যে কেবল 4032 রয়েছে। choicesF = filter(any, itertools.product([-1, 0, 0, 1], repeat=n))লুপগুলির বাইরে সংজ্ঞা দিন । তারপরে ইনারলুপে সংজ্ঞা দিন F = random.choice(choicesF)। আমি এই জাতীয় পদ্ধতির সাথে একটি 3x স্পিডআপ পাই।

— স্টিভেন রাম্বালস্কি

সিথনে এটি সংকলন সম্পর্কে কীভাবে? তারপরে কয়েকটি কৌশলগত স্ট্যাটিক প্রকার যুক্ত করছেন?

— থান ব্রিমহল

সবকিছু একটি ফাংশনে রাখুন এবং শেষে এটি কল করুন। এটি নামগুলি স্থানীয়করণ করে, যা @ রিফ্রাফ কাজের প্রস্তাবিত অপ্টিমাইজেশনও করে। এছাড়াও, তৈরিটি range(iters)লুপের বাইরে নিয়ে যান। সামগ্রিকভাবে, আমি আপনার খুব সুন্দর উত্তরের চেয়ে প্রায় 7% গতি পেয়েছি।

— ওল্ফ্রামএহ

Answer 4

মরিচা: 0.011s

মূল পাইথন: 8.3

মূল পাইথনের একটি সোজা অনুবাদ।

extern crate rand;

use rand::Rng;

static N: uint = 6;
static ITERS: uint = 1000;

fn convolve<T: Num>(into: &mut [T], a: &[T], b: &[T]) {
    // we want `a` to be the longest array
    if a.len() < b.len() {
        convolve(into, b, a);
        return
    }

    assert_eq!(into.len(), a.len() - b.len() + 1);

    for (n,place) in into.mut_iter().enumerate() {
        for (x, y) in a.slice_from(n).iter().zip(b.iter()) {
            *place = *place + *x * *y
        }
    }
}

fn main() {
    let mut first_zero = 0;
    let mut both_zero = 0;
    let mut rng = rand::XorShiftRng::new().unwrap();

    for s in PlusMinus::new() {
        for _ in range(0, ITERS) {
            let mut f = [0, .. N];
            while f.iter().all(|x| *x == 0) {
                for p in f.mut_iter() {
                    match rng.gen::<u32>() % 4 {
                        0 => *p = -1,
                        1 | 2 => *p = 0,
                        _ => *p = 1
                    }
                }
            }

            let mut fs = [0, .. 2];
            convolve(fs, s, f);

            if fs[0] == 0 { first_zero += 1 }
            if fs.iter().all(|&x| x == 0) { both_zero += 1 }
        }
    }

    println!("{}\n{}", first_zero, both_zero);
}



/// An iterator over [+-]1 arrays of the appropriate length
struct PlusMinus {
    done: bool,
    current: [i32, .. N + 1]
}
impl PlusMinus {
    fn new() -> PlusMinus {
        PlusMinus { done: false, current: [-1, .. N + 1] }
    }
}

impl Iterator<[i32, .. N + 1]> for PlusMinus {
    fn next(&mut self) -> Option<[i32, .. N+1]> {
        if self.done {
            return None
        }

        let ret = self.current;

        // a binary "adder", that just adds one to a bit vector (where
        // -1 is the zero, and 1 is the one).
        for (i, place) in self.current.mut_iter().enumerate() {
            *place = -*place;
            if *place == 1 {
                break
            } else if i == N {
                // we've wrapped, so we want to stop after this one
                self.done = true
            }
        }

        Some(ret)
    }
}

• সংকলিত --opt-level=3
• আমার মরিচা কম্পাইলার একটি সাম্প্রতিক হয় রাত্রিকালীন : ( rustc 0.11-pre-nightly (eea4909 2014-04-24 23:41:15 -0700)ভালো হবে)

Comments

আমি এটা জং এর রাতের সংস্করণ ব্যবহার করে সংকলন করতে পেয়েছি। তবে আমি মনে করি কোডটি ভুল। আউটপুটটি ফার্স্টেরো 27215 উভয়জারো 12086 এর কাছাকাছি কিছু হওয়া উচিত Instead পরিবর্তে এটি 27367 6481 দেয়

@ লিম্বিক, ওফস, আমার aএস এবং bএস মিশ্রিত করল; স্থির (রানটাইমটি লক্ষণীয়ভাবে পরিবর্তন করে না)।

— Huon

এটি মরিচা গতির একটি খুব সুন্দর প্রদর্শন।

Answer 5

সি ++ (ভিএস 2012) - 0.026 এস 0.015 এস

পাইথন 2.7.6 / নম্পি 1.8.1 - 12 সে

স্পিডআপ ~ x800।

সমাধান হওয়া অ্যারেগুলি যদি খুব বড় হয় তবে ব্যবধানটি আরও অনেক ছোট হবে ...

#include <vector>
#include <iostream>
#include <ctime>

using namespace std;

static unsigned int seed = 35;

int my_random()
{
   seed = seed*1664525UL + 1013904223UL; // numerical recipes, 32 bit

   switch((seed>>30) & 3)
   {
   case 0: return 0;
   case 1: return -1;
   case 2: return 1;
   case 3: return 0;
   }
   return 0;
}

bool allzero(const vector<int>& T)
{
   for(auto x : T)
   {
      if(x!=0)
      {
         return false;
      }
   }
   return true;
}

void convolve(vector<int>& out, const vector<int>& v1, const vector<int>& v2)
{
   for(size_t i = 0; i<out.size(); ++i)
   {
      int result = 0;
      for(size_t j = 0; j<v2.size(); ++j)
      {
         result += v1[i+j]*v2[j];
      }
      out[i] = result;
   }
}

void advance(vector<int>& v)
{
   for(auto &x : v)
   {
      if(x==-1)
      {
         x = 1;
         return;
      }
      x = -1;
   }
}

void convolve_random_arrays(void)
{
   const size_t n = 6;
   const int two_to_n_plus_one = 128;
   const int iters = 1000;
   int bothzero = 0;
   int firstzero = 0;

   vector<int> S(n+1);
   vector<int> F(n);
   vector<int> FS(2);

   time_t current_time;
   time(&current_time);
   seed = current_time;

   for(auto &x : S)
   {
      x = -1;
   }
   for(int i=0; i<two_to_n_plus_one; ++i)
   {
      for(int j=0; j<iters; ++j)
      {
         do
         {
            for(auto &x : F)
            {
               x = my_random();
            }
         } while(allzero(F));
         convolve(FS, S, F);
         if(FS[0] == 0)
         {
            firstzero++;
            if(FS[1] == 0)
            {
               bothzero++;
            }
         }
      }
      advance(S);
   }
   cout << firstzero << endl; // This output can slow things down
   cout << bothzero << endl; // comment out for timing the algorithm
}

কয়েকটি নোট:

• এলোমেলো ফাংশনটি লুপে ডাকা হচ্ছে তাই আমি খুব হালকা ওজনের লিনিয়ার কংগ্রেসনাল জেনারেটরের জন্য গিয়েছিলাম (তবে উদারতার সাথে এমএসবিগুলির দিকে নজর রেখেছি)।
• এটি সত্যিই একটি অনুকূলিত সমাধানের জন্য কেবলমাত্র প্রারম্ভিক বিন্দু।
• লিখতে এত দিন নি নি ...
• আমি এস এর সমস্ত মানকে S[0]"সর্বনিম্ন উল্লেখযোগ্য" অঙ্ক হিসাবে গ্রহণ করি rate

একটি স্ব অন্তর্ভুক্ত উদাহরণের জন্য এই প্রধান কার্যটি যুক্ত করুন:

int main(int argc, char** argv)
{
  for(int i=0; i<1000; ++i) // run 1000 times for stop-watch
  {
      convolve_random_arrays();
  }
}

Comments

প্রকৃতপক্ষে. ওপির কোডগুলিতে অ্যারের ক্ষুদ্র আকারের অর্থ হল নম্পী ব্যবহার করা আসলে সরল অজগর থেকে ধীর গতির পরিমাণ order

— অ্যালিস্টায়ার

এখন x800 আমি যা সম্পর্কে কথা বলছি!

খুব সুন্দর! আপনার advanceফাংশনের কারণে আমি আমার

— কোডটিতে

@ লেলবিক হ্যাঁ যেমন ম্যাট বলেছেন। আপনার সি ++ 11 সাপোর্ট এবং একটি মূল ফাংশন দরকার need এটি চালানোর জন্য আপনার আরও সহায়তার দরকার হলে আমাকে

— জানাবেন

আমি কেবল এটি পরীক্ষা করেছি এবং

— স্ট্যান্ড

Answer 6

সি

আমার মেশিনে 0.015 সেকেন্ড নেয়, ওপির মূল কোডটি ~ 7.7 নেয় s এলোমেলো অ্যারে জেনারেট করে এবং একই লুপে কনভোলভ করে অনুকূলিত করার চেষ্টা করেছি, তবে এটি খুব বেশি পার্থক্য বলে মনে হচ্ছে না।

প্রথম অ্যারেটি পূর্ণসংখ্যার দ্বারা উত্পাদিত হয়, এটি বাইনারি লিখুন এবং সমস্ত 1 থেকে -1 এবং সমস্ত 0 থেকে 1 পরিবর্তন করুন rest বাকীটি খুব সোজা হওয়া উচিত।

সম্পাদনা: পরিবর্তে থাকার nএকটি হিসাবে int, এখন আমরা আছে nহিসাবে একটি ম্যাক্রো-সংজ্ঞায়িত ধ্রুবক, তাই আমরা ব্যবহার করতে পারেন int arr[n];পরিবর্তে malloc।

সম্পাদনা 2: অন্তর্নির্মিত rand()ফাংশনের পরিবর্তে , এটি এখন একটি xorshift PRNG প্রয়োগ করে। এছাড়াও, এলোমেলো অ্যারে তৈরি করার সময় প্রচুর শর্তযুক্ত বিবৃতি সরানো হয়।

সংকলন নির্দেশাবলী:

gcc -O3 -march=native -fwhole-program -fstrict-aliasing -ftree-vectorize -Wall ./test.c -o ./test

কোড:

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

#define n (6)
#define iters (1000)
unsigned int x,y=34353,z=57768,w=1564; //PRNG seeds

/* xorshift PRNG
 * Taken from https://en.wikipedia.org/wiki/Xorshift#Example_implementation
 * Used under CC-By-SA */
int myRand() {
    unsigned int t;
    t = x ^ (x << 11);
    x = y; y = z; z = w;
    return w = w ^ (w >> 19) ^ t ^ (t >> 8);
}

int main() {
    int firstzero=0, bothzero=0;
    int arr[n+1];
    unsigned int i, j;
    x=(int)time(NULL);

    for(i=0; i< 1<<(n+1) ; i++) {
        unsigned int tmp=i;
        for(j=0; j<n+1; j++) {
            arr[j]=(tmp&1)*(-2)+1;
            tmp>>=1;
        }
        for(j=0; j<iters; j++) {
            int randArr[n];
            unsigned int k, flag=0;
            int first=0, second=0;
            do {
                for(k=0; k<n; k++) {
                    randArr[k]=(1-(myRand()&3))%2;
                    flag+=(randArr[k]&1);
                    first+=arr[k]*randArr[k];
                    second+=arr[k+1]*randArr[k];
                }
            } while(!flag);
            firstzero+=(!first);
            bothzero+=(!first&&!second);
        }
    }
    printf("firstzero %d\nbothzero %d\n", firstzero, bothzero);
    return 0;
}

Comments

আমি এটি পরীক্ষা করেছি। এটি খুব দ্রুত (চেষ্টা করুন এন = 10) এবং সঠিক চেহারা আউটপুট দেয়। ধন্যবাদ.

এই বাস্তবায়নটি মূলটিকে অনুসরণ করে না কারণ এলোমেলো ভেক্টরটি যদি সমস্ত শূন্য হয় তবে কেবলমাত্র শেষ উপাদানটি পুনরায় উত্পন্ন হবে। মূলতে পুরো ভেক্টর হবে। আপনাকে সেই লুপটি আবদ্ধ do{}while(!flag)করতে হবে বা সেই প্রভাবটিকে কিছু করতে হবে। আমি আশা করি না যে এটি রান-টাইমে অনেক পরিবর্তন করবে (এটি আরও দ্রুত করে তুলতে পারে)।

— গাই স্যার্টন

@Guy Sirton লক্ষ করুন যে, সামনে continue;বিবৃতি আমি নির্ধারিত -1করতে k, তাই k0 থেকে লুপ হবে আবার।

— #HongKongInd dependence

@ace আহ! তুমি ঠিক বলছো. আমি খুব তাড়াতাড়ি স্ক্যান করছিলাম এবং এটি দেখে মনে হচ্ছিল :-) এর -=চেয়ে বেশি ছিল =-আর লুপটি আরও বেশি পঠনযোগ্য হবে।

— গাই স্যারটন

Answer 7

জে

আমি কোনও সংকলিত ভাষা মারতে আশা করি না, এবং কোনও কিছু আমাকে বলে যে এটি একটি 0.09 s এর চেয়ে কম পেতে একটি অলৌকিক মেশিন নিতে চাই, তবে আমি যাইহোক এই জে জমা দিতে চাই, কারণ এটি দুর্দান্ত s

NB. constants
num =: 6
iters =: 1000

NB. convolve
NB. take the multiplication table                */
NB. then sum along the NE-SW diagonals           +//.
NB. and keep the longest ones                    #~ [: (= >./) #/.
NB. operate on rows of higher dimensional lists  " 1
conv =: (+//. #~ [: (= >./) #/.) @: (*/) " 1

NB. main program
S  =: > , { (num+1) # < _1 1                NB. all {-1,1}^(num+1)
F  =: (3&= - 0&=) (iters , num) ?@$ 4       NB. iters random arrays of length num
FS =: ,/ S conv/ F                          NB. make a convolution table
FB =: +/ ({. , *./)"1 ] 0 = FS              NB. first and both zero
('first zero ',:'both zero ') ,. ":"0 FB    NB. output results

এটি আগের দশক থেকে একটি ল্যাপটপে প্রায় 0.5 এস সময় নেয়, উত্তরের পাইথনের চেয়ে প্রায় 20x দ্রুত। বেশিরভাগ সময় ব্যয় করা হয় convকারণ আমরা এটিকে অলসভাবে লিখি (আমরা সম্পূর্ণ সমীকরণটি গণনা করি) এবং সম্পূর্ণ সাধারণভাবে।

যেহেতু আমরা সম্পর্কে জিনিস জানি Sএবং তাই আমরা Fএই প্রোগ্রামটির জন্য নির্দিষ্ট অপ্টিমাইজেশন করে জিনিসগুলিকে গতি বাড়িয়ে তুলতে পারি। আমি যে conv =: ((num, num+1) { +//.)@:(*/)"1সেরাটির সাথে আসতে পেরেছি তা হ'ল - বিশেষত দুটি সংখ্যা নির্বাচন করুন যা দ্বিখণ্ডার যোগফলের সাথে মিলনের দীর্ঘতম উপাদানগুলির সাথে মিল রাখে - যা সময়কে প্রায় অর্ধেক করে দেয়।

Comments

জে সর্বদা জমা দেওয়ার মতো, মানুষ :)

— ভিটালি ডায়াটলভ

Answer 8

পার্ল - 9.3X দ্রুত ... 830% উন্নতি

আমার প্রাচীন নেটবুকে, ওপির কোডটি চালাতে 53 সেকেন্ড সময় নেয়; অ্যালিস্টার বৈক্সনের সংস্করণটি প্রায় 6.5 সেকেন্ড সময় নেয় এবং নিম্নলিখিত পার্ল সংস্করণটি প্রায় 5.7 সেকেন্ড সময় নেয়।

use v5.10;
use strict;
use warnings;

use Algorithm::Combinatorics qw( variations_with_repetition );
use List::Util qw( any sum );
use List::MoreUtils qw( pairwise );

my $n         = 6;
my $iters     = 1000;
my $firstzero = 0;
my $bothzero  = 0;

my $variations = variations_with_repetition([-1, 1], $n+1);
while (my $S = $variations->next)
{
  for my $i (1 .. $iters)
  {
    my @F;
    until (@F and any { $_ } @F)
    {
      @F = map +((-1,0,0,1)[rand 4]), 1..$n;
    }

    # The pairwise function doesn't accept array slices,
    # so need to copy into a temp array @S0
    my @S0 = @$S[0..$n-1];

    unless (sum pairwise { $a * $b } @F, @S0)
    {
      $firstzero++;
      my @S1 = @$S[1..$n];  # copy again :-(
      $bothzero++ unless sum pairwise { $a * $b } @F, @S1;
    }
  }
}

say "firstzero ", $firstzero;
say "bothzero ", $bothzero;

Answer 9

পাইথন ২. - - এমপিএল বাইন্ডিং সহ অদ্ভুত 1.8.1 - 0.086 গুলি

(ও.পি. এর মূল: 6.404s) (বুকস্টনের খাঁটি অজগর: 0.270s)

import numpy as np
import itertools

n=6
iters = 1000

#Pack all of the Ses into a single array
S = np.array( list(itertools.product([-1,1], repeat=n+1)) )

# Create a whole array of test arrays, oversample a bit to ensure we 
# have at least (iters) of them
F = np.random.rand(int(iters*1.1),n)
F = ( F < 0.25 )*-1 + ( F > 0.75 )*1
goodrows = (np.abs(F).sum(1)!=0)
assert goodrows.sum() > iters, "Got very unlucky"
# get 1000 cases that aren't all zero
F = F[goodrows][:iters]

# Do the convolution explicitly for the two 
# slots, but on all of the Ses and Fes at the 
# same time
firstzeros = (F[:,None,:]*S[None,:,:-1]).sum(-1)==0
secondzeros = (F[:,None,:]*S[None,:,1:]).sum(-1)==0

firstzero_count = firstzeros.sum()
bothzero_count = (firstzeros * secondzeros).sum()
print "firstzero", firstzero_count
print "bothzero", bothzero_count

বুকস্টন যেমন উল্লেখ করেছেন, ওপির মূল কোডটি এ জাতীয় ক্ষুদ্র অ্যারেগুলি ব্যবহার করে তবে নম্পি ব্যবহারের কোনও সুবিধা নেই। এই প্রয়োগটি এফ এবং এস এর সমস্ত কেস একবারে অ্যারে ওরিয়েন্টেড উপায়ে করার মাধ্যমে অদ্ভুত উপার্জন করে। পাইথনের জন্য এমকেএল বাইন্ডিংয়ের সাথে এটি খুব দ্রুত বাস্তবায়নের দিকে পরিচালিত করে।

এছাড়াও নোট করুন যে কেবল গ্রন্থাগারগুলি লোড করা এবং দোভাষী শুরু করতে 0.076s লাগে তাই আসল গণনাটি সি ++ সমাধানের মতো ~ 0.01 সেকেন্ড গ্রহণ করে।

Comments

এমকেএল বাইন্ডিংগুলি কী কী এবং আমি কীভাবে উবুন্টুতে পাব?

রানিং python -c "import numpy; numpy.show_config()"যদি numpy সংস্করণটি বিরুদ্ধে Blas / মানচিত্রাবলী / mkl কম্পাইল করা হয়, ইত্যাদি আপনাকে দেখাবে এটলাস একটি বিনামূল্যে ত্বরিত গণিত প্যাকেজ যে numpy হয় বিরুদ্ধে লিঙ্ক করা যেতে পারে , ইন্টেল MKL আপনি সাধারণত জন্য টাকা দিতে হবে (যদি না আপনি একটি একাডেমিক দর্শিত থাকবে) এবং নাম্পি / স্কিপি লিঙ্ক করা যেতে পারে ।

— আলেমি

একটি সহজ উপায়ে, অ্যানাকোন্ডা পাইথন বিতরণ ব্যবহার করুন এবং ত্বরণ প্যাকেজটি ব্যবহার করুন । অথবা এনটহিট বিতরণ ব্যবহার করুন ।

— আলেমি

আপনি যদি উইন্ডোতে থাকেন তবে এখান থেকে কেবল নিম্পি ডাউনলোড করুন । প্রাক-সংকলিত নমপি ইনস্টলারগুলি এমকেএল-এর বিপরীতে লিঙ্ক হয়েছে।

— ভুয়া নাম

Answer 10

ম্যাটল্যাব 0.024 এস

কম্পিউটার ঘ

• আসল কোড: 3 3.3 s
• অ্যালিস্টার বুক্সটনের কোড: ~ 0.51 এস
• অ্যালিসার বুক্সটনের নতুন কোড: ~ 0.25
• মতলব কোড: 24 0.024 গুলি (মতলব ইতিমধ্যে চলছে)

কম্পিউটার 2

• আসল কোড: .6 6.66 এস
• অ্যালিস্টার বুক্সটনের কোড: .6 0.64 এস
• অ্যালিস্টার বুক্সটনের নতুন কোড:?
• মতলব: ~ 0.07 s (মতলব ইতিমধ্যে চলছে)
• অক্টোটাভ: ~ 0.07 s

আমি ওহ এত ধীরে মতলবকে চেষ্টা করার সিদ্ধান্ত নিয়েছি। যদি আপনি কীভাবে জানেন তবে আপনি বেশিরভাগ লুপগুলি (মতলবতে) থেকে মুক্তি পেতে পারেন যা এটি বেশ দ্রুত করে তোলে। তবে লুপযুক্ত সমাধানগুলির চেয়ে মেমোরির প্রয়োজনীয়তাগুলি বেশি তবে আপনার যদি খুব বড় অ্যারে না থাকে তবে এটি কোনও সমস্যা হবে না ...

function call_convolve_random_arrays
tic
convolve_random_arrays
toc
end

function convolve_random_arrays

n = 6;
iters = 1000;
firstzero = 0;
bothzero = 0;

rnd = [-1, 0, 0, 1];

S = -1 *ones(1, n + 1);

IDX1 = 1:n;
IDX2 = IDX1 + 1;

for i = 1:2^(n + 1)
    F = rnd(randi(4, [iters, n]));
    sel = ~any(F,2);
    while any(sel)
        F(sel, :) = rnd(randi(4, [sum(sel), n]));
        sel = ~any(F,2);
    end

    sum1 = F * S(IDX1)';
    sel = sum1 == 0;
    firstzero = firstzero + sum(sel);

    sum2 = F(sel, :) * S(IDX2)';
    sel = sum2 == 0;
    bothzero = bothzero + sum(sel);

    S = permute(S); 
end

fprintf('firstzero %i \nbothzero %i \n', firstzero, bothzero);

end

function x = permute(x)

for i=1:length(x)
    if(x(i)==-1)
        x(i) = 1;
            return
    end
        x(i) = -1;
end

end

আমি যা করি তা এখানে:

• এস এর মাধ্যমে অনুমতি দেওয়ার জন্য কাইল কানোজ ফাংশনটি ব্যবহার করুন
• সমস্ত এন * ইটারকে একবারে এলোমেলো সংখ্যা গণনা করুন
• 1 থেকে 4 ম্যাপ [-1 0 0 1]
• ম্যাট্রিক্স গুণন (এলিমেন্টওয়্যার যোগফল (এফ * এস (1: 5)) এফ * এস (1: 5) 'এর ম্যাট্রিক্স গুণনের সমান
• উভয়জারোর জন্য: কেবলমাত্র শর্তাদি পূর্ণ শর্ত পূরণ করে এমন সদস্যদের গণনা করুন

আমি ধরে নিলাম আপনার মতলব নেই, যা খুব খারাপ কারণ আমি এটির তুলনা করে দেখতে সত্যিই পছন্দ করতাম ...

(আপনি প্রথমবার এটি চালানোর সময় ফাংশনটি ধীর হতে পারে))

Comments

আচ্ছা আমার অষ্টাভ আছে যদি আপনি এটির জন্য এটি তৈরি করতে পারেন ...?

আমি এটি দিয়ে চেষ্টা করতে পারি - যদিও আমি অষ্টক দিয়ে কখনও কাজ করি নি।

— ম্যাথিউজ

ঠিক আছে, আমি অষ্টাভের মতো এটি চালাতে পারি যদি আমি কল_কনভলভ_আরেন্ডম_আরাইস.এম নামের একটি ফাইলটিতে কোডটি রাখি এবং তারপরে অষ্টাভ থেকে কল করি।

— ম্যাথিউজ

আসলে কিছু করার জন্য এটির কি আরও কিছু কোড দরকার? আমি যখন "অষ্টাভ কল_ক্যানভলভ_আরন্দম_আররেস.এম" করি তখন কোনও কিছুই আউটপুট হয় না। দেখুন bpaste.net/show/JPtLOCeI3aP3wc3F3aGf

দুঃখিত, অক্টাভ খোলার চেষ্টা করুন এবং এটি তখন চালান। এটি ফার্স্টেরো, উভয়ইজারো এবং সম্পাদনের সময় প্রদর্শন করা উচিত।

— ম্যাথিউজ

Answer 11

জুলিয়া: 0.30 এস

অপের পাইথন: 21.36 গুলি (কোর 2 জুটি)

71x স্পিডআপ

function countconv()                                                                                                                                                           
    n = 6                                                                                                                                                                      
    iters = 1000                                                                                                                                                               
    firstzero = 0                                                                                                                                                              
    bothzero = 0                                                                                                                                                               
    cprod= Iterators.product(fill([-1,1], n+1)...)                                                                                                                             
    F=Array(Float64,n);                                                                                                                                                        
    P=[-1. 0. 0. 1.]                                                                                                                                                                                                                                                                                                             

    for S in cprod                                                                                                                                                             
        Sm=[S...]                                                                                                                                                              
        for i = 1:iters                                                                                                                                                        
            F=P[rand(1:4,n)]                                                                                                                                                  
            while all(F==0)                                                                                                                                                   
                F=P[rand(1:4,n)]                                                                                                                                              
            end                                                                                                                                                               
            if  dot(reverse!(F),Sm[1:end-1]) == 0                                                                                                                           
                firstzero += 1                                                                                                                                                 
                if dot(F,Sm[2:end]) == 0                                                                                                                              
                    bothzero += 1                                                                                                                                              
                end                                                                                                                                                            
            end                                                                                                                                                                
        end                                                                                                                                                                    
    end
    return firstzero,bothzero
end

আমি আরমানের জুলিয়া উত্তরের কিছু পরিবর্তন করেছি: প্রথমত, আমি এটিকে একটি ফাংশনে আবৃত করি, কারণ বৈশ্বিক চলকগুলি জুলিয়ার ধরণের অনুকরণ এবং জেআইটি-র পক্ষে শক্ত করে তোলে: একটি বৈশ্বিক পরিবর্তনশীল যে কোনও সময় তার ধরণের পরিবর্তন করতে পারে এবং প্রতিটি ক্রিয়াকলাপ পরীক্ষা করে দেখতে হবে । তারপরে, আমি বেনামে ফাংশন এবং অ্যারে বোঝাপড়াগুলি থেকে মুক্তি পেয়েছি। এগুলি সত্যই প্রয়োজনীয় নয় এবং এখনও বেশ ধীর। জুলিয়া এখনই নিম্ন-স্তরের বিমূর্ততা সহ দ্রুত।

এটি দ্রুত করার আরও অনেক উপায় রয়েছে তবে এটি একটি শালীন কাজ করে।

Comments

আপনি কি আরপিএলে সময়টি মাপছেন বা কমান্ড লাইন থেকে পুরো ফাইলটি চালাচ্ছেন?

— আদিত্য

উভয়ই REPL থেকে।

— ব্যবহারকারী 20768

Answer 12

ঠিক আছে আমি জাভাকে এখানে উপস্থাপন করা দরকার বলে মনে করি কেবল এটি পোস্ট করছি। আমি অন্যান্য ভাষার সাথে ভয়ানক এবং আমি সমস্যাটি ঠিক বুঝতে না পারার স্বীকার করি, তাই এই কোডটি ঠিক করতে আমার কিছুটা সাহায্যের প্রয়োজন হবে। আমি কোড এসের বেশিরভাগ সি উদাহরণ চুরি করেছি এবং তারপরে অন্যের কাছ থেকে কিছু স্নিপেট ধার করেছিলাম। আমি আশা করি এটি কোনও ভুল প্যাস নয় ...

একটি বিষয় আমি উল্লেখ করতে চাই যে, যে ভাষাগুলি রান সময়কে অনুকূল করে তোলে তাদের পুরো গতিতে উঠতে বেশ কয়েকটি / বহুবার চালানো দরকার। আমি মনে করি সম্পূর্ণ অপ্টিমাইজড গতি (বা কমপক্ষে গড় গতি) গ্রহণ করা ন্যায়সঙ্গত কারণ আপনি বেশিরভাগ জিনিস দ্রুত চালনার সাথে সম্পর্কিত যা বেশ কয়েকবার চালানো হবে।

কোডটি এখনও স্থির করা দরকার, তবে আমি কী সময় পাব তা দেখতে আমি এটি চালিয়ে যাই।

উবুন্টুতে এটি 1000 বার চালিত একটি ইন্টেল (আর) জিয়ন (আর) সিপিইউ E3-1270 ভি 2 @ 3.50GHz এর ফলাফলগুলি এখানে রয়েছে:

সার্ভার: / টিএমপি # সময় জাভা 8 -সিপি। পরীক্ষক

ফার্স্টেরো 40000

দুজনে 20000

প্রথম রান সময়: 41 রান সর্বশেষ রান সময়: 4 এমএস

আসল 0m5.014s ব্যবহারকারী 0 এম 4.664 গুলি 0 ম0.268 এস

এখানে আমার ক্রেপি কোডটি রয়েছে:

public class Tester 
{
    public static void main( String[] args )
    {
        long firstRunTime = 0;
        long lastRunTime = 0;
        String testResults = null;
        for( int i=0 ; i<1000 ; i++ )
        {
            long timer = System.currentTimeMillis();
            testResults = new Tester().runtest();
            lastRunTime = System.currentTimeMillis() - timer;
            if( i ==0 )
            {
                firstRunTime = lastRunTime;
            }
        }
        System.err.println( testResults );
        System.err.println( "first run time: " + firstRunTime + " ms" );
        System.err.println( "last run time: " + lastRunTime + " ms" );
    }

    private int x,y=34353,z=57768,w=1564; 

    public String runtest()
    {
        int n = 6;
        int iters = 1000;
        //#define iters (1000)
        //PRNG seeds

        /* xorshift PRNG
         * Taken from https://en.wikipedia.org/wiki/Xorshift#Example_implementation
         * Used under CC-By-SA */

            int firstzero=0, bothzero=0;
            int[] arr = new int[n+1];
            int i=0, j=0;
            x=(int)(System.currentTimeMillis()/1000l);

            for(i=0; i< 1<<(n+1) ; i++) {
                int tmp=i;
                for(j=0; j<n+1; j++) {
                    arr[j]=(tmp&1)*(-2)+1;
                    tmp>>=1;
                }
                for(j=0; j<iters; j++) {
                    int[] randArr = new int[n];
                    int k=0;
                    long flag = 0;
                    int first=0, second=0;
                    do {
                        for(k=0; k<n; k++) {
                            randArr[k]=(1-(myRand()&3))%2;
                            flag+=(randArr[k]&1);
                            first+=arr[k]*randArr[k];
                            second+=arr[k+1]*randArr[k];
                        }
                    } while(allzero(randArr));
                    if( first == 0 )
                    {
                        firstzero+=1;
                        if( second == 0 )
                        {
                            bothzero++;
                        }
                    }
                }
            }
         return ( "firstzero " + firstzero + "\nbothzero " + bothzero + "\n" );
    }

    private boolean allzero(int[] arr)
    {
       for(int x : arr)
       {
          if(x!=0)
          {
             return false;
          }
       }
       return true;
    }

    public int myRand() 
    {
        long t;
        t = x ^ (x << 11);
        x = y; y = z; z = w;
        return (int)( w ^ (w >> 19) ^ t ^ (t >> 8));
    }
}

এবং আমি পাইথনটি আপগ্রেড করার পরে পাইথন-নিমপি ইনস্টল করার পরে পাইথন কোডটি চালানোর চেষ্টা করেছি তবে আমি এটি পেয়েছি:

server:/tmp# python tester.py
Traceback (most recent call last):
  File "peepee.py", line 15, in <module>
    F = np.random.choice(np.array([-1,0,0,1], dtype=np.int8), size = n)
AttributeError: 'module' object has no attribute 'choice'

Comments

মন্তব্যসমূহ: কখনইcurrentTimeMillis বেঞ্চমার্কিংয়ের জন্য ব্যবহার করবেন না (সিস্টেমে ন্যানো সংস্করণ ব্যবহার করুন) এবং 1 কে রান জেআইটি জড়িত হওয়ার জন্য যথেষ্ট নাও হতে পারে (ক্লায়েন্টের জন্য 1.5k এবং সার্ভারের জন্য 10 কে ডিফল্ট হবে, যদিও আপনি মাইআর্যান্ডকে প্রায়শই যথেষ্ট বলে থাকেন যে এটি হবে জেআইটিড যার ফলে কলস্ট্যাকের কিছু ফাংশন সংকলিত হওয়া উচিত যা এখানে কাজ করতে পারে) ast গত তবে কমপক্ষে দুর্বল পিএনআরজি প্রতারণা করছে না, তবে সি ++ সলিউশন এবং অন্যরাও তাই, আমি অনুমান করি যে এটি খুব বেশি অন্যায় নয়।

— ভু

উইন্ডোজগুলিতে আপনাকে কারেন্টটাইমমিলিস এড়াতে হবে, তবে লিনাক্সের জন্য তবে খুব সূক্ষ্ম গ্রানুলারিটি পরিমাপের জন্য আপনার ন্যানো সময় লাগবে না, এবং ন্যানো সময় পাওয়ার জন্য কলটি মিলিসের চেয়ে অনেক বেশি ব্যয়বহুল। সুতরাং আমি খুব একটা দ্বিমত পোষণ করছি যে আপনার এটি ব্যবহার করা উচিত নয়।

— ক্রিস সাইলিন

সুতরাং আপনি একটি নির্দিষ্ট ওএস এবং জেভিএম বাস্তবায়নের জন্য জাভা কোডটি লিখছেন? আসলে আপনি কোন ওএস ব্যবহার করছেন তা আমি নিশ্চিত নই , কারণ আমি সবেমাত্র আমার হটস্পট ডেভ gettimeofday(&time, NULL)ট্রিটিতে পরীক্ষা করেছি এবং লিনাক্স মিলিসেকেন্ডগুলির জন্য ব্যবহার করে যা একঘেয়ে নয় এবং কোনও নির্ভুলতার গ্যারান্টি দেয় না (সুতরাং কিছু প্ল্যাটফর্ম / কার্নেলগুলি ঠিক একই রকম কারেন্টটাইমমিলিস উইন্ডোজ বাস্তবায়ন হিসাবে সমস্যা - তাই হয় এটির জরিমানাও হয় না হয় হয়)। অন্যদিকে ন্যানোটাইম ব্যবহার করে clock_gettime(CLOCK_MONOTONIC, &tp)যা লিনাক্সে বেঞ্চমার্ক করার সময় স্পষ্টভাবে ব্যবহার করা সঠিক জিনিস।

— ভু

যেহেতু আমি কোনও লিনাক্স ডিস্ট্রো বা কার্নেলে জাভা কোড করে আসছি এটি আমার পক্ষে কোনও সমস্যা তৈরি করে না।

— ক্রিস সাইলিন

Answer 13

গোলাং কোডগুলির নীচে আমার মেশিনে পাইথনের 45X সংস্করণ:

package main

import (
"fmt"
"time"
)

const (
n     = 6
iters = 1000
)

var (
x, y, z, w = 34353, 34353, 57768, 1564 //PRNG seeds
)

/* xorshift PRNG
 * Taken from https://en.wikipedia.org/wiki/Xorshift#Example_implementation
 * Used under CC-By-SA */
func myRand() int {
var t uint
t = uint(x ^ (x << 11))
x, y, z = y, z, w
w = int(uint(w^w>>19) ^ t ^ (t >> 8))
return w
}

func main() {
var firstzero, bothzero int
var arr [n + 1]int
var i, j int
x = int(time.Now().Unix())

for i = 0; i < 1<<(n+1); i = i + 1 {
    tmp := i
    for j = 0; j < n+1; j = j + 1 {
        arr[j] = (tmp&1)*(-2) + 1
        tmp >>= 1
    }
    for j = 0; j < iters; j = j + 1 {
        var randArr [n]int
        var flag uint
        var k, first, second int
        for {
            for k = 0; k < n; k = k + 1 {
                randArr[k] = (1 - (myRand() & 3)) % 2
                flag += uint(randArr[k] & 1)
                first += arr[k] * randArr[k]
                second += arr[k+1] * randArr[k]
            }
            if flag != 0 {
                break
            }
        }
        if first == 0 {
            firstzero += 1
            if second == 0 {
                bothzero += 1
            }
        }
    }
}
println("firstzero", firstzero, "bothzero", bothzero)
}

এবং নীচে পাইথন কোডগুলি উপরে থেকে অনুলিপি করা হয়েছে:

import itertools
import operator
import random

n=6
iters = 1000
firstzero = 0
bothzero = 0

choicesF = filter(any, itertools.product([-1, 0, 0, 1], repeat=n))

for S in itertools.product([-1,1], repeat = n+1):
    for i in xrange(iters):
        F = random.choice(choicesF)
        if not sum(map(operator.mul, F, S[:-1])):
            firstzero += 1
            if not sum(map(operator.mul, F, S[1:])):
                bothzero += 1

print "firstzero", firstzero
print "bothzero", bothzero

এবং নীচের সময়:

$time python test.py
firstzero 27349
bothzero 12125

real    0m0.477s
user    0m0.461s
sys 0m0.014s

$time ./hf
firstzero 27253 bothzero 12142

real    0m0.011s
user    0m0.008s
sys 0m0.002s

Comments

আপনি ব্যবহার সম্পর্কে চিন্তা আছে "github.com/yanatan16/itertools"? এছাড়াও আপনি কি বলবেন যে এটি একাধিক গরোটিনগুলিতে দুর্দান্ত কাজ করবে?

— ymg

Answer 14

সি # 0.135s

সি # অ্যালিস্টায়ার বুক্সটনের সমতল অজগরটির উপর ভিত্তি করে : 0.278s
সমান্তরাল সি #: 0.135s
পাইথন প্রশ্ন থেকে: 5.907s
অ্যালিস্টায়ারের সরল অজগর: 0.853s

আমি বাস্তবে নিশ্চিত নই যে এই বাস্তবায়নটি সঠিক - এর ফলাফল আউটপুট ভিন্ন, যদি আপনি নীচে নীচে ফলাফলগুলি দেখেন।

অবশ্যই আরও অনুকূল অ্যালগরিদম আছে। আমি কেবল পাইথনের সাথে একটি খুব অনুরূপ অ্যালগরিদম ব্যবহার করার সিদ্ধান্ত নিয়েছি।

একক থ্রেডেড সি

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConvolvingArrays
{
    static class Program
    {
        static void Main(string[] args)
        {
            int n=6;
            int iters = 1000;
            int firstzero = 0;
            int bothzero = 0;

            int[] arraySeed = new int[] {-1, 1};
            int[] randomSource = new int[] {-1, 0, 0, 1};
            Random rand = new Random();

            foreach (var S in Enumerable.Repeat(arraySeed, n+1).CartesianProduct())
            {
                for (int i = 0; i < iters; i++)
                {
                    var F = Enumerable.Range(0, n).Select(_ => randomSource[rand.Next(randomSource.Length)]);
                    while (!F.Any(f => f != 0))
                    {
                        F = Enumerable.Range(0, n).Select(_ => randomSource[rand.Next(randomSource.Length)]);
                    }
                    if (Enumerable.Zip(F, S.Take(n), (f, s) => f * s).Sum() == 0)
                    {
                        firstzero++;
                        if (Enumerable.Zip(F, S.Skip(1), (f, s) => f * s).Sum() == 0)
                        {
                            bothzero++;
                        }
                    }
                }
            }

            Console.WriteLine("firstzero {0}", firstzero);
            Console.WriteLine("bothzero {0}", bothzero);
        }

        // itertools.product?
        // http://ericlippert.com/2010/06/28/computing-a-cartesian-product-with-linq/
        static IEnumerable<IEnumerable<T>> CartesianProduct<T>
            (this IEnumerable<IEnumerable<T>> sequences)
        {
            IEnumerable<IEnumerable<T>> emptyProduct =
              new[] { Enumerable.Empty<T>() };
            return sequences.Aggregate(
              emptyProduct,
              (accumulator, sequence) =>
                from accseq in accumulator
                from item in sequence
                select accseq.Concat(new[] { item }));
        }
    }
}

সমান্তরাল সি #:

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConvolvingArrays
{
    static class Program
    {
        static void Main(string[] args)
        {
            int n=6;
            int iters = 1000;
            int firstzero = 0;
            int bothzero = 0;

            int[] arraySeed = new int[] {-1, 1};
            int[] randomSource = new int[] {-1, 0, 0, 1};

            ConcurrentBag<int[]> results = new ConcurrentBag<int[]>();

            // The next line iterates over arrays of length n+1 which contain only -1s and 1s
            Parallel.ForEach(Enumerable.Repeat(arraySeed, n + 1).CartesianProduct(), (S) =>
            {
                int fz = 0;
                int bz = 0;
                ThreadSafeRandom rand = new ThreadSafeRandom();
                for (int i = 0; i < iters; i++)
                {
                    var F = Enumerable.Range(0, n).Select(_ => randomSource[rand.Next(randomSource.Length)]);
                    while (!F.Any(f => f != 0))
                    {
                        F = Enumerable.Range(0, n).Select(_ => randomSource[rand.Next(randomSource.Length)]);
                    }
                    if (Enumerable.Zip(F, S.Take(n), (f, s) => f * s).Sum() == 0)
                    {
                        fz++;
                        if (Enumerable.Zip(F, S.Skip(1), (f, s) => f * s).Sum() == 0)
                        {
                            bz++;
                        }
                    }
                }

                results.Add(new int[] { fz, bz });
            });

            foreach (int[] res in results)
            {
                firstzero += res[0];
                bothzero += res[1];
            }

            Console.WriteLine("firstzero {0}", firstzero);
            Console.WriteLine("bothzero {0}", bothzero);
        }

        // itertools.product?
        // http://ericlippert.com/2010/06/28/computing-a-cartesian-product-with-linq/
        static IEnumerable<IEnumerable<T>> CartesianProduct<T>
            (this IEnumerable<IEnumerable<T>> sequences)
        {
            IEnumerable<IEnumerable<T>> emptyProduct =
              new[] { Enumerable.Empty<T>() };
            return sequences.Aggregate(
              emptyProduct,
              (accumulator, sequence) =>
                from accseq in accumulator
                from item in sequence
                select accseq.Concat(new[] { item }));
        }
    }

    // http://stackoverflow.com/a/11109361/1030702
    public class ThreadSafeRandom
    {
        private static readonly Random _global = new Random();
        [ThreadStatic]
        private static Random _local;

        public ThreadSafeRandom()
        {
            if (_local == null)
            {
                int seed;
                lock (_global)
                {
                    seed = _global.Next();
                }
                _local = new Random(seed);
            }
        }
        public int Next()
        {
            return _local.Next();
        }
        public int Next(int maxValue)
        {
            return _local.Next(maxValue);
        }
    }
}

পরীক্ষার আউটপুট:

উইন্ডোজ (। নেট)

উইন্ডোজে সি # অনেক দ্রুত। সম্ভবত কারণ .NET মনো থেকে দ্রুত।

ব্যবহারকারী এবং সিস টাইমিং কাজ করে না বলে মনে হচ্ছে ( git bashসময় দেওয়ার জন্য ব্যবহৃত )।

$ time /c/Python27/python.exe numpypython.py
firstzero 27413
bothzero 12073

real    0m5.907s
user    0m0.000s
sys     0m0.000s
$ time /c/Python27/python.exe plainpython.py
firstzero 26983
bothzero 12033

real    0m0.853s
user    0m0.000s
sys     0m0.000s
$ time ConvolvingArrays.exe
firstzero 28526
bothzero 6453

real    0m0.278s
user    0m0.000s
sys     0m0.000s
$ time ConvolvingArraysParallel.exe
firstzero 28857
bothzero 6485

real    0m0.135s
user    0m0.000s
sys     0m0.000s

লিনাক্স (মনো)

bob@phoebe:~/convolvingarrays$ time python program.py
firstzero 27059
bothzero 12131

real    0m11.932s
user    0m11.912s
sys     0m0.012s
bob@phoebe:~/convolvingarrays$ mcs -optimize+ -debug- program.cs
bob@phoebe:~/convolvingarrays$ time mono program.exe
firstzero 28982
bothzero 6512

real    0m1.360s
user    0m1.532s
sys     0m0.872s
bob@phoebe:~/convolvingarrays$ mcs -optimize+ -debug- parallelprogram.cs
bob@phoebe:~/convolvingarrays$ time mono parallelprogram.exe
firstzero 28857
bothzero 6496

real    0m0.851s
user    0m2.708s
sys     0m3.028s

Comments

আপনি যেভাবে বলেছেন কোডটি সঠিক বলে আমি মনে করি না। ফলাফলগুলি সঠিক নয় are

নিবন্ধ আমি এটির প্রশংসা করব যদি কেউ আমাকে এটির ভুল কোথায় তা বলতে পারে, যদিও - আমি এটি নির্ধারণ করতে পারি না (কেবল এটির সাহায্যে কিছু করা উচিত নয় তার ন্যূনতম বোধগম্য হওয়া )।

— বব

এটি কীভাবে নেট নেট ব্লগস.এমএসএনএন

— রিক মিনারিচ

@ ল্যাম্বিক আমি এগুলি সবেমাত্র পেরেছি, যতদূর আমি বলতে পারি এটি অন্যান্য পাইথন সমাধানের মতো হওয়া উচিত ... এখন আমি সত্যিই বিভ্রান্ত।

— বব

Answer 15

হাস্কেল: প্রতি কোর ~ 2000x স্পিডআপ

'Ghc -O3 -funbox- কঠোর ক্ষেত্র -ত্রে-পরিহিত -fllvm' দিয়ে সংকলন করুন এবং '+ আরটিএস -Nk' দিয়ে চালান যেখানে k আপনার মেশিনে কোরের সংখ্যা।

import Control.Parallel.Strategies
import Data.Bits
import Data.List
import Data.Word
import System.Random

n = 6 :: Int
iters = 1000 :: Int

data G = G !Word !Word !Word !Word deriving (Eq, Show)

gen :: G -> (Word, G)
gen (G x y z w) = let t  = x `xor` (x `shiftL` 11)
                      w' = w `xor` (w `shiftR` 19) `xor` t `xor` (t `shiftR` 8)
                  in (w', G y z w w')  

mask :: Word -> Word
mask = (.&.) $ (2 ^ n) - 1

gen_nonzero :: G -> (Word, G)
gen_nonzero g = let (x, g') = gen g 
                    a = mask x
                in if a == 0 then gen_nonzero g' else (a, g')


data F = F {zeros  :: !Word, 
            posneg :: !Word} deriving (Eq, Show)

gen_f :: G -> (F, G)       
gen_f g = let (a, g')  = gen_nonzero g
              (b, g'') = gen g'
          in  (F a $ mask b, g'')

inner :: Word -> F -> Int
inner s (F zs pn) = let s' = complement $ s `xor` pn
                        ones = s' .&. zs
                        negs = (complement s') .&. zs
                    in popCount ones - popCount negs

specialised_convolve :: Word -> F -> (Int, Int)
specialised_convolve s f@(F zs pn) = (inner s f', inner s f) 
    where f' = F (zs `shiftL` 1) (pn `shiftL` 1)

ss :: [Word]
ss = [0..2 ^ (n + 1) - 1]

main_loop :: [G] -> (Int, Int)
main_loop gs = foldl1' (\(fz, bz) (fz', bz') -> (fz + fz', bz + bz')) . parMap rdeepseq helper $ zip ss gs
    where helper (s, g) = go 0 (0, 0) g
                where go k u@(fz, bz) g = if k == iters 
                                              then u 
                                              else let (f, g') = gen_f g
                                                       v = case specialised_convolve s f
                                                               of (0, 0) -> (fz + 1, bz + 1)
                                                                  (0, _) -> (fz + 1, bz)
                                                                  _      -> (fz, bz)
                                                   in go (k + 1) v g'

seed :: IO G                                        
seed = do std_g <- newStdGen
          let [x, y, z, w] = map fromIntegral $ take 4 (randoms std_g :: [Int])
          return $ G x y z w

main :: IO ()
main = (sequence $ map (const seed) ss) >>= print . main_loop

Comments

তাহলে 4 টি কোর দিয়ে এটি 9000 এরও বেশি ?! সঠিক হতে পারে এমন কোনও উপায় নেই।

— সিস টিমারম্যান

আমদাহের আইন অনুসারে সমান্তরাল গতিপথ সমান্তরাল প্রক্রিয়াকরণ ইউনিটের সংখ্যার সাথে লিনিয়ার নয়। পরিবর্তে তারা কেবল ম্লান রিটার্ন সরবরাহ করে

— xaedes

@ এক্সএডিস স্পিডআপটি কম সংখ্যক কোরের জন্য মূলত রৈখিক বলে মনে হয়

— ইউজার1502040

Answer 16

চুনি

রুবি (২.১.০) ০.২7777 এস
রুবি (২.১.১) 0.281 এস
পাইথন (অ্যালিস্টায়ার বুকসটন) 0.330 এস
পাইথন (আলেমি) 0.097 এস

n = 6
iters = 1000
first_zero = 0
both_zero = 0

choices = [-1, 0, 0, 1].repeated_permutation(n).select{|v| [0] != v.uniq}

def convolve(v1, v2)
  [0, 1].map do |i|
    r = 0
    6.times do |j|
      r += v1[i+j] * v2[j]
    end
    r
  end
end

[-1, 1].repeated_permutation(n+1) do |s|
  iters.times do
    f = choices.sample
    fs = convolve s, f
    if 0 == fs[0]
      first_zero += 1
      if 0 == fs[1]
        both_zero += 1
      end
    end
  end
end

puts 'firstzero %i' % first_zero
puts 'bothzero %i' % both_zero

Answer 17

থ্রেড পিএইচপি ছাড়াই সম্পূর্ণ হবে

6.6x দ্রুত

পিএইচপি v5.5.9 - 1.223 0.646 সেকেন্ড;

বনাম

পাইথন ভি 2.7.6 - 8.072 সেকেন্ড

<?php

$n = 6;
$iters = 1000;
$firstzero = 0;
$bothzero = 0;

$x=time();
$y=34353;
$z=57768;
$w=1564; //PRNG seeds

function myRand() {
    global $x;
    global $y;
    global $z;
    global $w;
    $t = $x ^ ($x << 11);
    $x = $y; $y = $z; $z = $w;
    return $w = $w ^ ($w >> 19) ^ $t ^ ($t >> 8);
}

function array_cartesian() {
    $_ = func_get_args();
    if (count($_) == 0)
        return array();
    $a = array_shift($_);
    if (count($_) == 0)
        $c = array(array());
    else
        $c = call_user_func_array(__FUNCTION__, $_);
    $r = array();
    foreach($a as $v)
        foreach($c as $p)
            $r[] = array_merge(array($v), $p);
    return $r;
}

function rand_array($a, $n)
{
    $r = array();
    for($i = 0; $i < $n; $i++)
        $r[] = $a[myRand()%count($a)];
    return $r;
}

function convolve($a, $b)
{
    // slows down
    /*if(count($a) < count($b))
        return convolve($b,$a);*/
    $result = array();
    $w = count($a) - count($b) + 1;
    for($i = 0; $i < $w; $i++){
        $r = 0;
        for($k = 0; $k < count($b); $k++)
            $r += $b[$k] * $a[$i + $k];
        $result[] = $r;
    }
    return $result;
}

$cross = call_user_func_array('array_cartesian',array_fill(0,$n+1,array(-1,1)));

foreach($cross as $S)
    for($i = 0; $i < $iters; $i++){
        while(true)
        {
            $F = rand_array(array(-1,0,0,1), $n);
            if(in_array(-1, $F) || in_array(1, $F))
                break;
        }
        $FS = convolve($S, $F);
        if(0==$FS[0]) $firstzero += 1;
        if(0==$FS[0] && 0==$FS[1]) $bothzero += 1;
    }

echo "firstzero $firstzero\n";
echo "bothzero $bothzero\n";

• একটি কাস্টম র্যান্ডম জেনারেটর (সি উত্তর থেকে চুরি) ব্যবহার করেছেন, পিএইচপি একটি সাফল্য এবং সংখ্যা মেলে না
• convolve আরও দ্রুত হতে ফাংশনটি কিছুটা সরলীকৃত হয়েছে
• কেবলমাত্র শূন্য-সহ অ্যারেগুলির জন্য চেক করা খুব অপ্টিমাইজড (দেখুন $Fএবং $FSচেক করা হয়েছে)।

আউটপুট:

$ time python num.py 
firstzero 27050
bothzero 11990

real    0m8.072s
user    0m8.037s
sys 0m0.024s
$ time php num.php
firstzero 27407
bothzero 12216

real    0m1.223s
user    0m1.210s
sys 0m0.012s

সম্পাদনা করুন। স্ক্রিপ্টের দ্বিতীয় সংস্করণটি কেবল এর জন্য কাজ করে 0.646 sec:

<?php

$n = 6;
$iters = 1000;
$firstzero = 0;
$bothzero = 0;

$x=time();
$y=34353;
$z=57768;
$w=1564; //PRNG seeds

function myRand() {
    global $x;
    global $y;
    global $z;
    global $w;
    $t = $x ^ ($x << 11);
    $x = $y; $y = $z; $z = $w;
    return $w = $w ^ ($w >> 19) ^ $t ^ ($t >> 8);
}

function array_cartesian() {
    $_ = func_get_args();
    if (count($_) == 0)
        return array();
    $a = array_shift($_);
    if (count($_) == 0)
        $c = array(array());
    else
        $c = call_user_func_array(__FUNCTION__, $_);
    $r = array();
    foreach($a as $v)
        foreach($c as $p)
            $r[] = array_merge(array($v), $p);
    return $r;
}

function convolve($a, $b)
{
    // slows down
    /*if(count($a) < count($b))
        return convolve($b,$a);*/
    $result = array();
    $w = count($a) - count($b) + 1;
    for($i = 0; $i < $w; $i++){
        $r = 0;
        for($k = 0; $k < count($b); $k++)
            $r += $b[$k] * $a[$i + $k];
        $result[] = $r;
    }
    return $result;
}

$cross = call_user_func_array('array_cartesian',array_fill(0,$n+1,array(-1,1)));

$choices = call_user_func_array('array_cartesian',array_fill(0,$n,array(-1,0,0,1)));

foreach($cross as $S)
    for($i = 0; $i < $iters; $i++){
        while(true)
        {
            $F = $choices[myRand()%count($choices)];
            if(in_array(-1, $F) || in_array(1, $F))
                break;
        }
        $FS = convolve($S, $F);
        if(0==$FS[0]){
            $firstzero += 1;
            if(0==$FS[1])
                $bothzero += 1;
        }
    }

echo "firstzero $firstzero\n";
echo "bothzero $bothzero\n";

Answer 18

F # সমাধান

সিএলআর কোর আই 7 4 (8) @ 3.4 গিগাজে x86 এ সংকলিত হওয়ার সময় রানটাইম 0.030s হয়

কোডটি সঠিক কিনা আমার কোনও ধারণা নেই।

• কার্যকরী অপ্টিমাইজেশন (ইনলাইন ভাঁজ) -> 0.026 গুলি
• কনসোল প্রকল্পের মাধ্যমে বিল্ডিং -> 0.022 এস s
• পারমিটেশন অ্যারে তৈরির জন্য আরও ভাল অ্যালগরিদম যুক্ত হয়েছে -> 0.018s
• উইন্ডো -> 0.089 এর জন্য মনো
• অ্যালিস্টায়ারের পাইথন স্ক্রিপ্ট চালানো -> 0.259s

let inline ffoldi n f state =
    let mutable state = state
    for i = 0 to n - 1 do
        state <- f state i
    state

let product values n =
    let p = Array.length values
    Array.init (pown p n) (fun i ->
        (Array.zeroCreate n, i)
        |> ffoldi n (fun (result, i') j ->
            result.[j] <- values.[i' % p]
            result, i' / p
        )
        |> fst
    )

let convolute signals filter =
    let m = Array.length signals
    let n = Array.length filter
    let len = max m n - min m n + 1

    Array.init len (fun offset ->
        ffoldi n (fun acc i ->
            acc + filter.[i] * signals.[m - 1 - offset - i]
        ) 0
    )

let n = 6
let iters = 1000

let next =
    let arrays =
        product [|-1; 0; 0; 1|] n
        |> Array.filter (Array.forall ((=) 0) >> not)
    let rnd = System.Random()
    fun () -> arrays.[rnd.Next arrays.Length]

let signals = product [|-1; 1|] (n + 1)

let firstzero, bothzero =
    ffoldi signals.Length (fun (firstzero, bothzero) i ->
        let s = signals.[i]
        ffoldi iters (fun (first, both) _ ->
            let f = next()
            match convolute s f with
            | [|0; 0|] -> first + 1, both + 1
            | [|0; _|] -> first + 1, both
            | _ -> first, both
        ) (firstzero, bothzero)
    ) (0, 0)

printfn "firstzero %i" firstzero
printfn "bothzero %i" bothzero

Answer 19

প্রশ্ন, 0.296 সেগ

n:6; iter:1000  /parametrization (constants)
c:n#0           /auxiliar constant (sequence 0 0.. 0 (n))
A:B:();         /A and B accumulates results of inner product (firstresult, secondresult)

/S=sequence with all arrays of length n+1 with values -1 and 1
S:+(2**m)#/:{,/x#/:-1 1}'m:|n(2*)\1 

f:{do[iter; F:c; while[F~c; F:n?-1 0 0 1]; A,:+/F*-1_x; B,:+/F*1_x];} /hard work
f'S               /map(S,f)
N:~A; +/'(N;N&~B) / ~A is not A (or A=0) ->bitmap.  +/ is sum (population over a bitmap)
                  / +/'(N;N&~B) = count firstResult=0, count firstResult=0 and secondResult=0

প্রশ্ন হল একটি সংগ্রহ-ভিত্তিক ভাষা (কেএক্স.কম)

আইডিয়োম্যাটিক কিউকে এক্সপ্লিট করার জন্য কোডটি পুনরায় লিখিত হয়েছে, তবে অন্য কোনও চালাক অপ্টিমাইজেশন নেই

স্ক্রিপ্টিং ভাষাগুলি প্রোগ্রামার সময়টিকে কার্যকর করে, কার্যকর করার সময় নয় execution

• প্রশ্ন এই সমস্যার জন্য সর্বোত্তম সরঞ্জাম নয়

প্রথম কোডিংয়ের প্রচেষ্টা = কোনও বিজয়ী নয়, তবে যুক্তিসঙ্গত সময় (প্রায় 30x স্পিডআপ)

• দোভাষীদের মধ্যে বেশ প্রতিযোগিতামূলক
• থামুন এবং অন্য সমস্যা চয়ন করুন

নোট.-

• প্রোগ্রামটি ডিফল্ট বীজ ব্যবহার করে (পুনরাবৃত্তিমূলক এক্সিকিউটিস) এলোমেলো জেনারেটর ব্যবহারের জন্য অন্য বীজ চয়ন করতে \S seed
• ফলাফল দুটি ইন্টের স্কোয়েন্স হিসাবে দেওয়া হয়, সুতরাং দ্বিতীয় মান 27421 12133i -> হিসাবে পড়ুন (27241, 12133) এ চূড়ান্ত আই-প্রত্যয় রয়েছে
• দোভাষী শুরুর সময় গণনা করা হচ্ছে না। \t sentence এই বাক্যটির দ্বারা সময় কাটায় mes

Comments

খুব আকর্ষণীয় আপনাকে ধন্যবাদ।

Answer 20

জুলিয়া: 12.149 6.929 এস

তাদের দাবিতে গতি বাড়ানোর পরেও , প্রাথমিক জেআইটি সংকলনের সময় আমাদের পিছনে ফেলেছে !

নোট করুন যে নীচের জুলিয়া কোডটি কার্যকরভাবে মূল পাইথন কোডের সরাসরি অনুবাদ (কোনও প্রত্যাশা করা হয়নি) যা আপনি সহজেই আপনার প্রোগ্রামিংয়ের অভিজ্ঞতাটি একটি দ্রুততর ভাষায় স্থানান্তর করতে পারেন;)

require("Iterators")

n = 6
iters = 1000
firstzero = 0
bothzero = 0

for S in Iterators.product(fill([-1,1], n+1)...)
    for i = 1:iters
        F = [[-1 0 0 1][rand(1:4)] for _ = 1:n]
        while all((x) -> round(x,8) == 0, F)
            F = [[-1 0 0 1][rand(1:4)] for _ = 1:n]
        end
        FS = conv(F, [S...])
        if round(FS[1],8) == 0
            firstzero += 1
        end
        if all((x) -> round(x,8) == 0, FS)
            bothzero += 1
        end
    end
end

println("firstzero ", firstzero)
println("bothzero ", bothzero)

সম্পাদন করা

সঙ্গে চললে n = 832,935 গুলি লাগে। এই অ্যালগরিদমের জটিলতা বিবেচনা করে O(2^n), তখন 4 * (12.149 - C) = (32.935 - C), যেখানে Cজেআইটি সংকলনের সময়কে ধ্রুবক উপস্থাপন করে। এর সমাধান Cআমরা যে এটি C = 5.2203জন্য বোঝা যায় যে প্রকৃত সঞ্চালনের সময় n = 66,929 গুলি করা হয়।

Comments

জুলিয়া তার নিজের মধ্যে আসে কিনা তা দেখার জন্য এন থেকে 8 বাড়ানোর বিষয়ে কীভাবে?

এটি এখানে পারফরম্যান্সের বেশ কয়েকটি টিপস উপেক্ষা করে: julia.readthedocs.org/en/latest/manual/performance-tips । অন্যান্য জুলিয়া এন্ট্রি দেখুন যা উল্লেখযোগ্যভাবে আরও ভাল করে।

— জমাটি

Answer 21

মরিচা, 6.6 এমএস, 1950x স্পিডআপ

মরিচায় অ্যালিস্টায়ার বুকস্টনের কোডটির সরাসরি অনুবাদ খুব সুন্দর । আমি রেইনের সাথে একাধিক কোর ব্যবহারের বিষয়টি বিবেচনা করেছি (নির্ভীক সম্মতি!), তবে এটির কার্যকারিতা উন্নতি হয়নি, সম্ভবত এটি ইতিমধ্যে খুব দ্রুত।

extern crate itertools;
extern crate rand;
extern crate time;

use itertools::Itertools;
use rand::{prelude::*, prng::XorShiftRng};
use std::iter;
use time::precise_time_ns;

fn main() {
    let start = precise_time_ns();

    let n = 6;
    let iters = 1000;
    let mut first_zero = 0;
    let mut both_zero = 0;
    let choices_f: Vec<Vec<i8>> = iter::repeat([-1, 0, 0, 1].iter().cloned())
        .take(n)
        .multi_cartesian_product()
        .filter(|i| i.iter().any(|&x| x != 0))
        .collect();
    // xorshift RNG is faster than default algorithm designed for security
    // rather than performance.
    let mut rng = XorShiftRng::from_entropy(); 
    for s in iter::repeat(&[-1, 1]).take(n + 1).multi_cartesian_product() {
        for _ in 0..iters {
            let f = rng.choose(&choices_f).unwrap();
            if f.iter()
                .zip(&s[..s.len() - 1])
                .map(|(a, &b)| a * b)
                .sum::<i8>() == 0
            {
                first_zero += 1;
                if f.iter().zip(&s[1..]).map(|(a, &b)| a * b).sum::<i8>() == 0 {
                    both_zero += 1;
                }
            }
        }
    }
    println!("first_zero = {}\nboth_zero = {}", first_zero, both_zero);

    println!("runtime {} ns", precise_time_ns() - start);
}

এবং কার্গো.টমল, যেমন আমি বাহ্যিক নির্ভরতা ব্যবহার করি:

[package]
name = "how_slow_is_python"
version = "0.1.0"

[dependencies]
itertools = "0.7.8"
rand = "0.5.3"
time = "0.1.40"

গতির তুলনা:

$ time python2 py.py
firstzero: 27478
bothzero: 12246
12.80user 0.02system 0:12.90elapsed 99%CPU (0avgtext+0avgdata 23328maxresident)k
0inputs+0outputs (0major+3544minor)pagefaults 0swaps
$ time target/release/how_slow_is_python
first_zero = 27359
both_zero = 12162
runtime 6625608 ns
0.00user 0.00system 0:00.00elapsed 100%CPU (0avgtext+0avgdata 2784maxresident)k
0inputs+0outputs (0major+189minor)pagefaults 0swaps

6625608 এনএস প্রায় 6.6 এমএস। এর অর্থ 1950 বার স্পিডআপ। এখানে অনেকগুলি অপ্টিমাইজেশন সম্ভব, তবে আমি পারফরম্যান্সের পরিবর্তে পঠনযোগ্যতার জন্য যাচ্ছিলাম। একটি সম্ভাব্য অপ্টিমাইজেশন হ'ল পছন্দগুলি সংরক্ষণ করার জন্য ভেক্টরগুলির পরিবর্তে অ্যারে ব্যবহার করা হবে কারণ তাদের সর্বদা nউপাদান থাকবে। জোরশিফ্ট ব্যতীত আরএনজি ব্যবহার করাও সম্ভব, কারণ জোরশিফ্টটি ডিফল্ট এইচসি -128 সিএসপিআরএনজি থেকে দ্রুততর, এটি পিআরএনজি অ্যালগরিদমের তুলনায় নিচুতম।