আমি আসলে খুব অবাক হয়েছি আমি এখানে এর উত্তর খুঁজে নিতে পারিনি, যদিও আমি কেবল ভুল অনুসন্ধানের শব্দ বা কিছু ব্যবহার করছি। নিকটতম আমি খুঁজে পাইনি এই , কিন্তু তারা একটি নির্দিষ্ট সীমার উৎপাদিত সম্পর্কে জিজ্ঞাসা doubleএকটি নির্দিষ্ট পদক্ষেপ আকার সঙ্গে s, এবং উত্তর যেমন এটা আচরণ। আমার এমন কিছু দরকার যা স্বেচ্ছাসেবী শুরু, শেষ এবং ধাপের আকারের সাথে সংখ্যাগুলি তৈরি করবে।
আমি চিন্তা সেখানে রয়েছে কোথাও ইতিমধ্যে একটি লাইব্রেরিতে এই মত কিছু পদ্ধতি, কিন্তু যদি তাই আমি এটিকে সহজে খুঁজে পেতে সক্ষম ছিল না (আবার, হয়তো আমি শুধু ভুল খঁোজা বা কিছু ব্যবহার করছি)। এটি করার জন্য আমি কয়েক মিনিটের মধ্যে নিজের থেকে কী রান্না করেছি তা এখানে:
import java.lang.Math;
import java.util.List;
import java.util.ArrayList;
public class DoubleSequenceGenerator {
/**
* Generates a List of Double values beginning with `start` and ending with
* the last step from `start` which includes the provided `end` value.
**/
public static List<Double> generateSequence(double start, double end, double step) {
Double numValues = (end-start)/step + 1.0;
List<Double> sequence = new ArrayList<Double>(numValues.intValue());
sequence.add(start);
for (int i=1; i < numValues; i++) {
sequence.add(start + step*i);
}
return sequence;
}
/**
* Generates a List of Double values beginning with `start` and ending with
* the last step from `start` which includes the provided `end` value.
*
* Each number in the sequence is rounded to the precision of the `step`
* value. For instance, if step=0.025, values will round to the nearest
* thousandth value (0.001).
**/
public static List<Double> generateSequenceRounded(double start, double end, double step) {
if (step != Math.floor(step)) {
Double numValues = (end-start)/step + 1.0;
List<Double> sequence = new ArrayList<Double>(numValues.intValue());
double fraction = step - Math.floor(step);
double mult = 10;
while (mult*fraction < 1.0) {
mult *= 10;
}
sequence.add(start);
for (int i=1; i < numValues; i++) {
sequence.add(Math.round(mult*(start + step*i))/mult);
}
return sequence;
}
return generateSequence(start, end, step);
}
}এই পদ্ধতিগুলি stepসিক্যুয়েন্স সূচক দ্বারা গুণিত করে startঅফসেটে যোগ করে একটি সাধারণ লুপ চালায় । এটি ক্রমবর্ধমান ভাসমান-পয়েন্ট ত্রুটিগুলি হ্রাস করে যা ক্রমাগত বর্ধনের সাথে ঘটে (যেমন stepপ্রতিটি পুনরাবৃত্তির উপর একটি ভেরিয়েবল যুক্ত করে)।
আমি generateSequenceRoundedcases ক্ষেত্রেগুলির জন্য পদ্ধতিটি যুক্ত করেছি যেখানে ভগ্নাংশের পদক্ষেপের আকারটি লক্ষণীয় ভাসমান-পয়েন্ট ত্রুটির কারণ হতে পারে। এটির জন্য আরও কিছু গাণিতিক প্রয়োজন, সুতরাং আমাদের মতো চূড়ান্ত পারফরম্যান্স সংবেদনশীল পরিস্থিতিতে, যখন গোলটি অপ্রয়োজনীয় হয় তখন সহজ পদ্ধতিটি ব্যবহার করার বিকল্পটি পাওয়া ভাল। আমার সন্দেহ হয় যে বেশিরভাগ সাধারণ ব্যবহারের ক্ষেত্রে গোলাকার ওভারহেডটি নগণ্য হবে।
লক্ষ্য করুন আমি ইচ্ছাকৃতভাবে হ্যান্ডলিং যেমন "অস্বাভাবিক" আর্গুমেন্ট জন্য যুক্তিবিজ্ঞান বহির্ভূত Infinity, NaN, start> end, অথবা একটি নেতিবাচক stepসরলীকরণের জন্য আকার এবং হাতের প্রশ্ন উপর ফোকাস করার ইচ্ছা।
এখানে কয়েকটি ব্যবহার এবং সম্পর্কিত আউটপুট উদাহরণ রয়েছে:
System.out.println(DoubleSequenceGenerator.generateSequence(0.0, 2.0, 0.2))
System.out.println(DoubleSequenceGenerator.generateSequenceRounded(0.0, 2.0, 0.2));
System.out.println(DoubleSequenceGenerator.generateSequence(0.0, 102.0, 10.2));
System.out.println(DoubleSequenceGenerator.generateSequenceRounded(0.0, 102.0, 10.2));[0.0, 0.2, 0.4, 0.6000000000000001, 0.8, 1.0, 1.2000000000000002, 1.4000000000000001, 1.6, 1.8, 2.0]
[0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0]
[0.0, 10.2, 20.4, 30.599999999999998, 40.8, 51.0, 61.199999999999996, 71.39999999999999, 81.6, 91.8, 102.0]
[0.0, 10.2, 20.4, 30.6, 40.8, 51.0, 61.2, 71.4, 81.6, 91.8, 102.0]ইতিমধ্যে এই ধরনের কার্যকারিতা সরবরাহ করে এমন কোনও গ্রন্থাগার রয়েছে কি?
যদি তা না হয় তবে আমার পদ্ধতির সাথে কোনও সমস্যা আছে?
কারও কি এই সম্পর্কে আরও ভাল পদ্ধতির থাকতে পারে?