রিমান থেটা ফাংশনটির একটি বিশেষ কেস অনুমান করা

27

এই চ্যালেঞ্জটি হ'ল দ্রুত কোড লিখুন যা একটি গণনামূলকভাবে কঠিন অসীম যোগফল সম্পাদন করতে পারে।

ইনপুট

একটি nদ্বারা nম্যাট্রিক্স Pপূর্ণসংখ্যা এন্ট্রি চেয়ে ছোট সঙ্গে 100পরম মান। পরীক্ষার সময় আমি আপনার কোডটি যে কোনও সংবেদনশীল বিন্যাসে আপনার কোডটিকে ইনপুট সরবরাহ করতে পেরে খুশি। ডিফল্ট হ'ল ম্যাট্রিক্সের প্রতি সারি এক লাইন, স্থান পৃথক এবং স্ট্যান্ডার্ড ইনপুটটিতে সরবরাহ করা হবে।

Pহতে হবে ইতিবাচক নির্দিষ্ট বোঝা যার ফলে এটি সবসময় প্রতিসম হবে। চ্যালেঞ্জের উত্তর দেওয়ার জন্য ইতিবাচক সুনির্দিষ্ট অর্থ কী তা ছাড়া আপনার সত্যিকারের জানা দরকার নেই। তবে এর অর্থ এই নয় যে নীচে সংজ্ঞায়িত সমষ্টিটির আসলে একটি উত্তর থাকবে।

তবে ম্যাট্রিক্স-ভেক্টর পণ্যটি কী তা আপনার জানা দরকার ।

আউটপুট

আপনার কোডটি অসীম যোগফল গণনা করা উচিত:

এখানে চিত্র বর্ণনা লিখুন

সঠিক উত্তরের যোগ বা বিয়োগ 0.0001 এর মধ্যে। এখানে Zপূর্ণসংখ্যার সেট এবং তাই Z^nদিয়ে সব সম্ভব ভেক্টর হয় nপূর্ণসংখ্যা উপাদান এবং eহয় বিখ্যাত গাণিতিক ধ্রুবক প্রায় 2,71828 সমান। দ্রষ্টব্য যে খাঁটির মানটি কেবল একটি সংখ্যা। একটি স্পষ্ট উদাহরণ জন্য নীচে দেখুন।

এটি কীভাবে রিমন থেটা ফাংশনের সাথে সম্পর্কিত?

রিমন থেটা ফাংশনটি অনুমান করার বিষয়ে এই কাগজের স্বীকৃতিতে আমরা গণনা করার চেষ্টা করছি এখানে চিত্র বর্ণনা লিখুন। আমাদের সমস্যাটি একটি বিশেষ ক্ষেত্রে কমপক্ষে দুটি কারণে।

  • আমরা zলিঙ্কযুক্ত কাগজে ডাকা প্রাথমিক প্যারামিটারটি 0 তে সেট করেছিলাম ।
  • আমরা ম্যাট্রিক্সটি Pএমনভাবে তৈরি করি যে কোনও ইগন্যালুজের সর্বনিম্ন আকার 1। (কীভাবে ম্যাট্রিক্স তৈরি হয় তার জন্য নীচে দেখুন))

উদাহরণ

P = [[ 5.,  2.,  0.,  0.],
     [ 2.,  5.,  2., -2.],
     [ 0.,  2.,  5.,  0.],
     [ 0., -2.,  0.,  5.]]

Output: 1.07551411208

আরও বিশদে, আসুন আমরা এই পি এর যোগফলের মধ্যে কেবল একটি পদ দেখতে পাই example উদাহরণস্বরূপ যোগফলের মধ্যে কেবলমাত্র একটি শব্দটি ধরুন:

এখানে চিত্র বর্ণনা লিখুন

এবং x^T P x = 30। লক্ষ করুন যে, e^(-30)আমার হয় 10^(-14)এবং তাই দেওয়া সহনশীলতা সঠিক উত্তর আপ পাওয়ার জন্য গুরুত্বপূর্ণ হতে করার সম্ভাবনা কম। মনে রাখবেন যে অসীম যোগফল 4 দৈর্ঘ্যের প্রতিটি সম্ভাব্য ভেক্টর ব্যবহার করবে যেখানে উপাদানগুলি পূর্ণসংখ্যার হয়। আমি একটি স্পষ্ট উদাহরণ দেওয়ার জন্য একটি বেছে নিয়েছি।

P = [[ 5.,  2.,  2.,  2.],
     [ 2.,  5.,  4.,  4.],
     [ 2.,  4.,  5.,  4.],
     [ 2.,  4.,  4.,  5.]]

Output = 1.91841190706

P = [[ 6., -3.,  3., -3.,  3.],
     [-3.,  6., -5.,  5., -5.],
     [ 3., -5.,  6., -5.,  5.],
     [-3.,  5., -5.,  6., -5.],
     [ 3., -5.,  5., -5.,  6.]]

Output = 2.87091065342

P = [[6., -1., -3., 1., 3., -1., -3., 1., 3.],
     [-1., 6., -1., -5., 1., 5., -1., -5., 1.],
     [-3., -1., 6., 1., -5., -1., 5., 1., -5.],
     [1., -5., 1., 6., -1., -5., 1., 5., -1.],
     [3., 1., -5., -1., 6., 1., -5., -1., 5.],
     [-1., 5., -1., -5., 1., 6., -1., -5., 1.],
     [-3., -1., 5., 1., -5., -1., 6., 1., -5.],
     [1., -5., 1., 5., -1., -5., 1., 6., -1.],
     [3., 1., -5., -1., 5., 1., -5., -1., 6.]]

Output: 8.1443647932

P = [[ 7.,  2.,  0.,  0.,  6.,  2.,  0.,  0.,  6.],
     [ 2.,  7.,  0.,  0.,  2.,  6.,  0.,  0.,  2.],
     [ 0.,  0.,  7., -2.,  0.,  0.,  6., -2.,  0.],
     [ 0.,  0., -2.,  7.,  0.,  0., -2.,  6.,  0.],
     [ 6.,  2.,  0.,  0.,  7.,  2.,  0.,  0.,  6.],
     [ 2.,  6.,  0.,  0.,  2.,  7.,  0.,  0.,  2.],
     [ 0.,  0.,  6., -2.,  0.,  0.,  7., -2.,  0.],
     [ 0.,  0., -2.,  6.,  0.,  0., -2.,  7.,  0.],
     [ 6.,  2.,  0.,  0.,  6.,  2.,  0.,  0.,  7.]]

Output = 3.80639191181

স্কোর

আমি আপনার কোডটি বর্ধমান আকারের এলোমেলোভাবে নির্বাচিত ম্যাট্রিকেস পি তে পরীক্ষা করব।

আপনার স্কোরটি সর্বাধিক বৃহত্তম nযার জন্য আমি 30 সেকেন্ডেরও কম সময়ে সঠিক উত্তর পেয়ে যাই যখন Pসেই আকারের এলোমেলোভাবে নির্বাচিত ম্যাট্রিকগুলি সহ 5 রান বেশি হয় ।

টাই সম্পর্কে কি?

যদি টাই থাকে তবে বিজয়ী হবেন যার কোডটি দ্রুততম রান গড়ে 5 টিরও বেশি। ইভেন্টটি যখন সেই সময়গুলিও সমান, বিজয়ীর প্রথম উত্তর।

কিভাবে এলোমেলো ইনপুট তৈরি করা হবে?

  1. এম সঙ্গে এন ম্যাট্রিক্স দ্বারা একটি র্যান্ডম মি হতে দিন মি <= n এবং এন্ট্রি যা হয় -1 বা 1. পাইথন / numpy সালে M = np.random.choice([0,1], size = (m,n))*2-1। অনুশীলনে আমি mপ্রায় হতে হবে n/2।
  2. পাইথন / অদ্ভুতভাবে পি পরিচয় ম্যাট্রিক্স + এম ^ টি এম হতে দিন P =np.identity(n)+np.dot(M.T,M)। আমরা এখন গ্যারান্টিযুক্ত যা Pইতিবাচক সুনির্দিষ্ট এবং এন্ট্রিগুলি একটি উপযুক্ত পরিসরে রয়েছে।

মনে রাখবেন যে এর অর্থ পি এর সমস্ত ইগেনালুগুলি কমপক্ষে 1 হয়, সমস্যাটি রিমন থেটা ফাংশনটি প্রায় অনুমান করার সাধারণ সমস্যার তুলনায় সম্ভাব্যভাবে সহজ করে তোলে।

ভাষা ও গ্রন্থাগার

আপনি যে কোনও ভাষা বা লাইব্রেরি পছন্দ করতে পারেন। তবে স্কোর করার উদ্দেশ্যে আমি আপনার কোডটি আমার মেশিনে চালাচ্ছি তাই দয়া করে উবুন্টুতে এটি কীভাবে চালানো যায় তার জন্য সুস্পষ্ট নির্দেশনা সরবরাহ করুন।

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

শীর্ষস্থানীয় উত্তর

  • n = 47মধ্যে সি ++ টন Hospel দ্বারা
  • n = 8মধ্যে পাইথন Maltysen দ্বারা
math  fastest-code 
— Glorfindel
সূত্র
এটি উল্লেখযোগ্য হতে পারে যে একটি ইতিবাচক নির্দিষ্ট ম্যাট্রিক্স সংজ্ঞা দ্বারা প্রতিসম হয়।
— 2012campion
ধন্যবাদ যোগ করা হয়েছে।
ঠিক আছে, হয়তো এই একটি মূক প্রশ্ন, কিন্তু আমি বয়সের জন্য এই এ stared করেছি এবং আমি চিন্তা করতে পারে না কিভাবে আপনি একটি পেয়েছিলাম xএর [-1,0,2,1]। আপনি এই সম্পর্কে বিস্তারিত বলতে পারেন? (ইঙ্গিত: আমি কোনও গণিত গুরু নই)
— wnnmaw
@wnnmaw বিভ্রান্ত হওয়ার জন্য দুঃখিত এই ক্ষেত্রে প্রতিটি সম্ভাব্য ভেক্টর এক্স দৈর্ঘ্যের 4 এর জন্য যোগফলের একটি শব্দ রয়েছে । [-1,0,2,1] এই ক্ষেত্রে শব্দটি কী হবে তা স্পষ্টভাবে দেখানোর জন্য আমি এলোমেলোভাবে বেছে নিয়েছি।
1
@ ল্যাম্বিক আপনি এসপিডি ম্যাট্রিকগুলি যেভাবে উত্পন্ন করেন তা বোঝায় যে কোনও একক মানের নীচে কখনও নিরঙ্কুশ মান থাকে না we আমরা কি সেই জ্ঞানটি ব্যবহার করতে পারি?
— flawr

উত্তর:

15

সি ++

আর কোন নিষ্পাপ পদ্ধতির। শুধুমাত্র উপবৃত্তাকার ভিতরে মূল্যায়ন করুন।

আর্মাদিলো, এনটিএল, জিএসএল এবং pthread লাইব্রেরি ব্যবহার করে। ব্যবহার করে ইনস্টল করুন

apt-get install libarmadillo-dev libntl-dev libgsl-dev

প্রোগ্রামটির মতো কিছু ব্যবহার করে সংকলন করুন:

g++ -Wall -std=c++11 -O3 -fno-math-errno -funsafe-math-optimizations -ffast-math -fno-signed-zeros -fno-trapping-math -fomit-frame-pointer -march=native -s infinity.cpp -larmadillo -lntl -lgsl -lpthread -o infinity

কিছু সিস্টেমে আপনার -lgslcblasপরে যোগ করার প্রয়োজন হতে পারে -lgsl।

এসটিডিআইএন-এর উপাদানগুলির পরে ম্যাট্রিক্সের আকার দিয়ে চালান:

./infinity < matrix.txt

matrix.txt:

4
5  2  0  0
2  5  2 -2
0  2  5  0
0 -2  0  5

বা 1e-5 এর নির্ভুলতার চেষ্টা করতে:

./infinity -p 1e-5 < matrix.txt

infinity.cpp:

// Based on http://arxiv.org/abs/nlin/0206009

#include <iostream>
#include <vector>
#include <stdexcept>
#include <cstdlib>
#include <cmath>
#include <string>
#include <thread>
#include <future>
#include <chrono>

using namespace std;

#include <getopt.h>

#include <armadillo>

using namespace arma;

#include <NTL/mat_ZZ.h>
#include <NTL/LLL.h>

using namespace NTL;

#include <gsl/gsl_sf_gamma.h>
#include <gsl/gsl_errno.h>
#include <gsl/gsl_roots.h>

double const EPSILON = 1e-4;       // default precision
double const GROW    = 2;          // By how much we grow the ellipsoid volume
double const UPSCALE = 1e9;        // lattice reduction, upscale real to integer
double const THREAD_SEC = 0.1;     // Use threads if need more time than this
double const RADIUS_MAX = 1e6;     // Maximum radius used in root finding
double const RADIUS_INTERVAL = 1e-6; // precision of target radius
int const ITER_MAX = 1000;         // Maximum iterations in root finding
unsigned long POINTS_MIN = 1000;   // Minimum points before getting fancy

struct Result {
    Result& operator+=(Result const& add) {
        sum     += add.sum;
        elapsed += add.elapsed;
        points  += add.points;
        return *this;
    }

    friend Result operator-(Result const& left, Result const& right) {
        return Result{left.sum - right.sum,
                left.elapsed - right.elapsed,
                left.points - right.points};
    }

    double sum, elapsed;
    unsigned long points;
};

struct Params {
    double half_rho, half_N, epsilon;
};

double fill_factor_error(double r, void *void_params) {
    auto params = static_cast<Params*>(void_params);
    r -= params->half_rho;
    return gsl_sf_gamma_inc(params->half_N, r*r) - params->epsilon;
}

// Calculate radius needed for target precision
double radius(int N, double rho, double lat_det, double epsilon) {
    Params params;

    params.half_rho = rho / 2.;
    params.half_N   = N   / 2.;
    params.epsilon = epsilon*lat_det*gsl_sf_gamma(params.half_N)/pow(M_PI, params.half_N);

    // Calculate minimum allowed radius
    auto r = sqrt(params.half_N)+params.half_rho;
    auto val = fill_factor_error(r, &params);
    cout << "Minimum R=" << r << " -> " << val << endl;

    if (val > 0) {
        // The minimum radius is not good enough. Work out a better one by
        // finding the root of a tricky function
        auto low  = r;
        auto high = RADIUS_MAX * 2 * params.half_rho;
        auto val = fill_factor_error(high, &params);
        if (val >= 0)
            throw(logic_error("huge RADIUS_MAX is still not big enough"));

        gsl_function F;
        F.function = fill_factor_error;
        F.params   = &params;

        auto T = gsl_root_fsolver_brent;
        auto s = gsl_root_fsolver_alloc (T);
        gsl_root_fsolver_set (s, &F, low, high);

        int status = GSL_CONTINUE;
        for (auto iter=1; status == GSL_CONTINUE && iter <= ITER_MAX; ++iter) {
            gsl_root_fsolver_iterate (s);
            low  = gsl_root_fsolver_x_lower (s);
            high = gsl_root_fsolver_x_upper (s);
            status = gsl_root_test_interval(low, high, 0, RADIUS_INTERVAL  * 2 * params.half_rho);
        }
        r = gsl_root_fsolver_root(s);
        gsl_root_fsolver_free(s);
        if (status == GSL_CONTINUE)
            throw(logic_error("Search for R did not converge"));
    }
    return r;
}

// Recursively walk down the ellipsoids in each dimension
void ellipsoid(int d, mat const& A, double const* InvD, mat& Accu,
               Result& result, double r2) {
    auto r = sqrt(r2);
    auto offset = Accu(d, d);
    // InvD[d] = 1/ A(d, d)
    auto from = ceil((-r-offset) * InvD[d]);
    auto to   = floor((r-offset) * InvD[d]);
    for (auto v = from; v <= to; ++v) {
        auto value  = v * A(d, d)+offset;
        auto residu = r2 - value*value;
        if (d == 0) {
            result.sum += exp(residu);
            ++result.points;
        } else {
            for (auto i=0; i<d; ++i) Accu(d-1, i) = Accu(d, i) + v * A(d, i);
            ellipsoid(d-1, A, InvD, Accu, result, residu);
        }
    }
}

// Specialised version of ellipsoid() that will only process points an octant
void ellipsoid(int d, mat const& A, double const* InvD, mat& Accu,
               Result& result, double r2, unsigned int octant) {
    auto r = sqrt(r2);
    auto offset = Accu(d, d);
    // InvD[d] = 1/ A(d, d)
    long from = ceil((-r-offset) * InvD[d]);
    long to   = floor((r-offset) * InvD[d]);
    auto points = to-from+1;
    auto base = from + points/2;
    if (points & 1) {
        auto value = base * A(d, d) + offset;
        auto residu = r2 - value * value;
        if (d == 0) {
            if ((octant & (octant - 1)) == 0) {
                result.sum += exp(residu);
                ++result.points;
            }
        } else {
            for (auto i=0; i<d; ++i) Accu(d-1, i) = Accu(d, i) + base * A(d, i);
            ellipsoid(d-1, A, InvD, Accu, result, residu, octant);
        }
        ++base;
    }
    if ((octant & 1) == 0) {
        to = from + points / 2 - 1;
        base = from;
    }
    octant /= 2;
    for (auto v = base; v <= to; ++v) {
        auto value = v * A(d,d)+offset;
        auto residu = r2 - value*value;
        if (d == 0) {
            if ((octant & (octant - 1)) == 0) {
                result.sum += exp(residu);
                ++result.points;
            }
        } else {
            for (auto i=0; i<d; ++i) Accu(d-1, i) = Accu(d, i) + v * A(d, i);
            if (octant == 1)
                ellipsoid(d-1, A, InvD, Accu, result, residu);
            else
                ellipsoid(d-1, A, InvD, Accu, result, residu, octant);
        }
    }
}

// Prepare call to ellipsoid()
Result sym_ellipsoid(int N, mat const& A, const vector<double>& InvD, double r,
                     unsigned int octant = 1) {
    auto start = chrono::steady_clock::now();
    auto r2 = r*r;

    mat Accu(N, N);
    Accu.row(N-1).zeros();

    Result result{0, 0, 0};
    // 2*octant+1 forces the points into the upper half plane, skipping 0
    // This way we use the lattice symmetry and calculate only half the points
    ellipsoid(N-1, A, &InvD[0], Accu, result, r2, 2*octant+1);
    // Compensate for the extra factor exp(r*r) we always add in ellipsoid()
    result.sum /= exp(r2);
    auto end = chrono::steady_clock::now();
    result.elapsed = chrono::duration<double>{end-start}.count();

    return result;
}

// Prepare multithreaded use of sym_ellipsoid(). Each thread gets 1 octant
Result sym_ellipsoid_t(int N, mat const& A, const vector<double>& InvD, double r, unsigned int nr_threads) {
    nr_threads = pow(2, ceil(log2(nr_threads)));

    vector<future<Result>> results;
    for (auto i=nr_threads+1; i<2*nr_threads; ++i)
        results.emplace_back(async(launch::async, sym_ellipsoid, N, ref(A), ref(InvD), r, i));
    auto result = sym_ellipsoid(N, A, InvD, r, nr_threads);
    for (auto i=0U; i<nr_threads-1; ++i) result += results[i].get();
    return result;
}

int main(int argc, char* const* argv) {
    cin.exceptions(ios::failbit | ios::badbit);
    cout.precision(12);

    double epsilon    = EPSILON; // Target absolute error
    bool inv_modular  = true;    // Use modular transform to get the best matrix
    bool lat_reduce   = true;    // Use lattice reduction to align the ellipsoid
    bool conservative = false;   // Use provable error bound instead of a guess
    bool eigen_values = false;   // Show eigenvalues
    int  threads_max  = thread::hardware_concurrency();

    int option_char;
    while ((option_char = getopt(argc, argv, "p:n:MRce")) != EOF)
        switch (option_char) {
            case 'p': epsilon      = atof(optarg); break;
            case 'n': threads_max  = atoi(optarg); break;
            case 'M': inv_modular  = false;        break;
            case 'R': lat_reduce   = false;        break;
            case 'c': conservative = true;         break;
            case 'e': eigen_values = true;         break;
            default:
              cerr << "usage: " << argv[0] << " [-p epsilon] [-n threads] [-M] [-R] [-e] [-c]" << endl;
              exit(EXIT_FAILURE);
        }
    if (optind < argc) {
        cerr << "Unexpected argument" << endl;
        exit(EXIT_FAILURE);
    }
    if (threads_max < 1) threads_max = 1;
    threads_max = pow(2, ceil(log2(threads_max)));
    cout << "Using up to " << threads_max << " threads" << endl;

    int N;
    cin >> N;

    mat P(N, N);
    for (auto& v: P) cin >> v;

    if (eigen_values) {
        vec eigval = eig_sym(P);
        cout << "Eigenvalues:\n" << eigval << endl;
    }

    // Decompose P = A * A.t()
    mat A = chol(P, "lower");

    // Calculate lattice determinant
    double lat_det = 1;
    for (auto i=0; i<N; ++i) {
        if (A(i,i) <= 0) throw(logic_error("Diagonal not Positive"));
        lat_det *= A(i,i);
    }
    cout << "Lattice determinant=" << lat_det << endl;

    auto factor = lat_det / pow(M_PI, N/2.0);
    if (inv_modular && factor < 1) {
        epsilon *= factor;
        cout << "Lattice determinant is small. Using inverse instead. Factor=" << factor << endl;
        P = M_PI * M_PI * inv(P);
        A = chol(P, "lower");
        // We could simple calculate the new lat_det as pow(M_PI,N)/lat_det
        lat_det = 1;
        for (auto i=0; i<N; ++i) {
            if (A(i,i) <= 0) throw(logic_error("Diagonal not Positive"));
            lat_det *= A(i,i);
        }
        cout << "New lattice determinant=" << lat_det << endl;
    } else
        factor = 1;

    // Prepare for lattice reduction.
    // Since the library works on integer lattices we will scale up our matrix
    double min = INFINITY;
    for (auto i=0; i<N; ++i) {
        for (auto j=0; j<N;++j)
            if (A(i,j) != 0 && abs(A(i,j) < min)) min = abs(A(i,j));
    }

    auto upscale = UPSCALE/min;
    mat_ZZ a;
    a.SetDims(N,N);
    for (auto i=0; i<N; ++i)
        for (auto j=0; j<N;++j) a[i][j] = to_ZZ(A(i,j)*upscale);

    // Finally do the actual lattice reduction
    mat_ZZ u;
    auto rank = G_BKZ_FP(a, u);
    if (rank != N) throw(logic_error("Matrix is singular"));
    mat U(N,N);
    for (auto i=0; i<N;++i)
        for (auto j=0; j<N;++j) U(i,j) = to_double(u[i][j]);

    // There should now be a short lattice vector at row 0
    ZZ sum = to_ZZ(0);
    for (auto j=0; j<N;++j) sum += a[0][j]*a[0][j];
    auto rho = sqrt(to_double(sum))/upscale;
    cout << "Rho=" << rho << " (integer square " <<
        rho*rho << " ~ " <<
        static_cast<int>(rho*rho+0.5) << ")" << endl;

    // Lattice reduction doesn't gain us anything conceptually.
    // The same number of points is evaluated for the same exponential values
    // However working through the ellipsoid dimensions from large lattice
    // base vectors to small makes ellipsoid() a *lot* faster
    if (lat_reduce) {
        mat B = U * A;
        P = B * B.t();
        A = chol(P, "lower");
        if (eigen_values) {
            vec eigval = eig_sym(P);
            cout << "New eigenvalues:\n" << eigval << endl;
        }
    }

    vector<double> InvD(N);;
    for (auto i=0; i<N; ++i) InvD[i] = 1 / A(i, i);

    // Calculate radius needed for target precision
    auto r = radius(N, rho, lat_det, epsilon);
    cout << "Safe R=" << r << endl;

    auto nr_threads = threads_max;
    Result result;
    if (conservative) {
        // Walk all points inside the ellipsoid with transformed radius r
        result = sym_ellipsoid_t(N, A, InvD, r, nr_threads);
    } else {
        // First grow the radius until we saw POINTS_MIN points or reach the
        // target radius
        double i = floor(N * log2(r/rho) / log2(GROW));
        if (i < 0) i = 0;
        auto R = r * pow(GROW, -i/N);
        cout << "Initial R=" << R << endl;
        result = sym_ellipsoid_t(N, A, InvD, R, nr_threads);
        nr_threads = result.elapsed < THREAD_SEC ? 1 : threads_max;
        auto max_new_points = result.points;
        while (--i >= 0 && result.points < POINTS_MIN) {
            R = r * pow(GROW, -i/N);
            auto change = result;
            result = sym_ellipsoid_t(N, A, InvD, R, nr_threads);
            nr_threads = result.elapsed < THREAD_SEC ? 1 : threads_max;
            change = result - change;

            if (change.points > max_new_points) max_new_points = change.points;
        }

        // Now we have enough points that it's worth bothering to use threads
        while (--i >= 0) {
            R = r * pow(GROW, -i/N);
            auto change = result;
            result = sym_ellipsoid_t(N, A, InvD, R, nr_threads);
            nr_threads = result.elapsed < THREAD_SEC ? 1 : threads_max;
            change = result - change;
            // This is probably too crude and might misestimate the error
            // I've never seen it fail though
            if (change.points > max_new_points) {
                max_new_points = change.points;
                if (change.sum < epsilon/2) break;
            }
        }
        cout << "Final R=" << R << endl;
    }

    // We calculated half the points and skipped 0.
    result.sum = 2*result.sum+1;

    // Modular transform factor
    result.sum /= factor;

    // Report result
    cout <<
        "Evaluated " << result.points << " points\n" <<
        "Sum = " << result.sum << endl;
}
— টন হসপেল
সূত্র
এটি আমার দৃষ্টিতে নিষ্পাপ পদ্ধতির চেয়ে অত্যন্ত চিত্তাকর্ষক এবং অনেক ভাল better আমি ডকুমেন্টেশনের অপেক্ষায়
1
@ টনহোস্পেল আপনি কীভাবে সীমাবদ্ধতা নিয়ে এসেছেন সে সম্পর্কে কিছুটা বলতে পারেন?
— flawr
2
আমি আর্চ লিনাক্স ব্যবহার করছি এবং -lgslcblasসংকলনের জন্য পতাকাটির প্রয়োজন । উপায় দ্বারা আশ্চর্যজনক উত্তর!
— রাইজোম্যাটিক
2

পাইথন ঘ

আমার কম্পিউটারে 12 সেকেন্ড n = 8, উবুন্টু 4 কোর।

সত্যিই নির্বোধ, আমি কি করছি তার কোনও ক্লু নেই।

from itertools import product
from math import e

P = [[ 6., -3.,  3., -3.,  3.],
     [-3.,  6., -5.,  5., -5.],
     [ 3., -5.,  6., -5.,  5.],
     [-3.,  5., -5.,  6., -5.],
     [ 3., -5.,  5., -5.,  6.]]

N = 2

n = [1]

while e** -n[-1] > 0.0001:
    n = []
    for x in product(list(range(-N, N+1)), repeat = len(P)):
        n.append(sum(k[0] * k[1] for k in zip([sum(j[0] * j[1] for j in zip(i, x)) for i in P], x)))
    N += 1

print(sum(e** -i for i in n))

এটি Zযথেষ্ট ভাল উত্তর না পাওয়া পর্যন্ত এটি এর ব্যবহারের পরিধি বাড়িয়ে রাখবে । আমি আমার নিজের ম্যাট্রিক্সের গুণটি লিখেছি, প্রলি নাম্বার ব্যবহার করা উচিত।

— Maltysen
সূত্র
ধন্যবাদ! আপনি কি আপনার কম্পিউটারে কিছু আউটপুট এবং সময় প্রদর্শন করতে পারেন?
আপনার কোডটি পাইপিতে চলে যা দুর্দান্ত এবং দ্রুত। দুর্ভাগ্যক্রমে, [[6.0, -1.0, -3.0, 1.0, 3.0, -1.0, -3.0, 1.0, 3.0], [-1.0, 6.0, -1.0, -5.0, 1.0, 5.0, -1.0, -5.0, 1.0 ], [-৩.০, -১.০, .0.০, 1.0, -5.0, -1.0, 5.0, 1.0, -5.0], [1.0, -5.0, 1.0, 6.0, -1.0, -5.0, 1.0, 5.0, -1.0] , [3.0, 1.0, -5.0, -1.0, 6.0, 1.0, -5.0, -1.0, 5.0], [-1.0, 5.0, -1.0, -5.0, 1.0, 6.0, -1.0, -5.0, 1.0], [-3.0, -1.0, 5.0, 1.0, -5.0, -1.0, 6.0, 1.0, -5.0], [1.0, -5.0, 1.0, 5.0, -1.0, -5.0, 1.0, 6.0, -1.0], [ 3.0, 1.0, -5.0, -1.0, 5.0, 1.0, -5.0, -1.0, 6.0]] ঠিক ভুল উত্তর দেয়।
8.1443647932-8.14381938863 = 0.00054540457> 0.0001।
3
@ মালটিসেন আপনার প্রোগ্রামটি কেবলমাত্র শেষ শব্দটি প্রদত্ত নির্ভুলতার চেয়ে ছোট কিনা তা পরীক্ষা করে । তবে আপনি যে ত্রুটিটি করেছেন তা অনেক বড়, কারণ আপনাকেও ত্রুটির জন্য অন্যান্য সমস্ত পদগুলির যোগফল বিবেচনা করতে হবে!
— flawr
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.