নিকটতম 10 (বা 100 বা এক্স) পর্যন্ত কী করে যাবে?

Question 1

আমি ডেটা প্লট করার জন্য একটি ফাংশন লিখছি। আমি y- অক্ষের জন্য একটি দুর্দান্ত গোল সংখ্যা উল্লেখ করতে চাই maxযা ডেটাসেটের সর্বাধিকের চেয়ে বড়।

বিশেষত, আমি একটি ফাংশন চাই fooযা নিম্নলিখিতগুলি সম্পাদন করে:

foo(4) == 5
foo(6.1) == 10 #maybe 7 would be better
foo(30.1) == 40
foo(100.1) == 110

আমি যতদূর পেরেছি

foo <- function(x) ceiling(max(x)/10)*10

নিকটতম 10 এ গোল করার জন্য, তবে এটি স্বেচ্ছাসেবী বৃত্তাকার অন্তরগুলির জন্য কাজ করে না।

আর-তে এটি করার আরও ভাল উপায় আছে কি?

Question 2

আপনি যদি কেবলমাত্র 10 এর নিকটতম শক্তিটি পেতে চান তবে কেবল সংজ্ঞা দিন:

roundUp <- function(x) 10^ceiling(log10(x))

এক্স আসলে ভেক্টর হলে এটিও কার্যকরভাবে কাজ করে:

> roundUp(c(0.0023, 3.99, 10, 1003))
[1] 1e-02 1e+01 1e+01 1e+04

.. তবে আপনি যদি কোনও "সুন্দর" সংখ্যায় গোল করতে চান, আপনাকে প্রথমে একটি "সুন্দর" সংখ্যাটি নির্ধারণ করতে হবে। নিম্নলিখিতটি আমাদের 1 থেকে 10 পর্যন্ত দুর্দান্ত বেস মান সহ ভেক্টর হিসাবে "দুর্দান্ত" সংজ্ঞা দিতে দেয় The

roundUpNice <- function(x, nice=c(1,2,4,5,6,8,10)) {
    if(length(x) != 1) stop("'x' must be of length 1")
    10^floor(log10(x)) * nice[[which(x <= 10^floor(log10(x)) * nice)[[1]]]]
}

এক্স ভেক্টর হলে উপরেরটি কাজ করে না - এখন সন্ধ্যা খুব দেরিতে :)

> roundUpNice(0.0322)
[1] 0.04
> roundUpNice(3.22)
[1] 4
> roundUpNice(32.2)
[1] 40
> roundUpNice(42.2)
[1] 50
> roundUpNice(422.2)
[1] 500

[[সম্পাদনা]]

যদি প্রশ্নটি নির্ধারিত নিকটতম মানের (10 বা 100 এর মতো) গোল করে কীভাবে হয় তবে জেমসের উত্তরটি সবচেয়ে উপযুক্ত বলে মনে হয়। আমার সংস্করণ আপনাকে যে কোনও মান নিতে এবং স্বয়ংক্রিয়ভাবে এটিকে যুক্তিসঙ্গতভাবে "সুন্দর" মান হিসাবে গোল করতে দেয়। উপরের "দুর্দান্ত" ভেক্টরের আরও কয়েকটি ভাল পছন্দগুলি হ'ল:1:10, c(1,5,10), seq(1, 10, 0.1)

যদি আপনার প্লটে আপনার মানগুলির একটি ব্যাপ্তি থাকে, উদাহরণস্বরূপ [3996.225, 40001.893]তবে স্বয়ংক্রিয় পদ্ধতিতে পরিসরের আকার এবং সংখ্যার বিশালতা উভয়ই বিবেচনায় নেওয়া উচিত। এবং হ্যাডলি দ্বারা উল্লিখিত হিসাবে , pretty()ফাংশনটি আপনি চান তা হতে পারে।

Question 3

plyrগ্রন্থাগার একটি ফাংশন আছে round_anyযে বেশ rounding সব ধরণের কাজ করতে জেনেরিক হয়। উদাহরণ স্বরূপ

library(plyr)
round_any(132.1, 10)               # returns 130
round_any(132.1, 10, f = ceiling)  # returns 140
round_any(132.1, 5, f = ceiling)   # returns 135

Question 4

আর এর মধ্যে গোলাকার ফাংশনটি যদি paraণাত্মক হয় তবে অঙ্কগুলির পরামিতিগুলির বিশেষ অর্থ নির্ধারণ করে।

গোল (x, সংখ্যা = 0)

Aণাত্মক সংখ্যার সাথে গোলাকৃতির অর্থ দশটির শক্তির সাথে বৃত্তাকার, সুতরাং উদাহরণস্বরূপ গোল (x, অঙ্কগুলি = -2) নিকটতম শতকে রাউন্ড করুন।

এই নিচের মত একটি ফাংশন পায় মানে চমত্কার বন্ধ আপনি যা জিজ্ঞাসা করা হয় হয়।

foo <- function(x)
{
    round(x+5,-1)
}

আউটপুট নিম্নলিখিত মত দেখাচ্ছে

foo(4)
[1] 10
foo(6.1)
[1] 10
foo(30.1)
[1] 40
foo(100.1)
[1] 110

Question 5

কেমন:

roundUp <- function(x,to=10)
{
  to*(x%/%to + as.logical(x%%to))
}

যা দেয়:

> roundUp(c(4,6.1,30.1,100.1))
[1]  10  10  40 110
> roundUp(4,5)
[1] 5
> roundUp(12,7)
[1] 14

Question 6

আপনি যদি রাউন্ড () এর ডিজিটস-আর্গুমেন্টে একটি নেতিবাচক সংখ্যা যুক্ত করেন তবে আর, এটি 10, 100 ইত্যাদির গুণকগুলিতে গোল করবে R

    round(9, digits = -1) 
    [1] 10    
    round(89, digits = -1) 
    [1] 90
    round(89, digits = -2) 
    [1] 100

Question 7

যে কোনও সংখ্যার উপরে / নিচে রাউন্ডের যে কোনও নম্বর val

আপনি সহজেই মডুলো অপারেটরটি ব্যবহার করে একটি নির্দিষ্ট বিরতিতে সংখ্যার বৃত্তাকার করতে পারেন %%।

কাজ:

round.choose <- function(x, roundTo, dir = 1) {
  if(dir == 1) {  ##ROUND UP
    x + (roundTo - x %% roundTo)
  } else {
    if(dir == 0) {  ##ROUND DOWN
      x - (x %% roundTo)
    }
  }
}

উদাহরণ:

> round.choose(17,5,1)   #round 17 UP to the next 5th
[1] 20
> round.choose(17,5,0)   #round 17 DOWN to the next 5th
[1] 15
> round.choose(17,2,1)   #round 17 UP to the next even number
[1] 18
> round.choose(17,2,0)   #round 17 DOWN to the next even number
[1] 16

কিভাবে এটা কাজ করে:

মডুলো অপারেটর %%প্রথম সংখ্যাটি ২ য় দ্বারা ভাগ করার বাকিটি নির্ধারণ করে। আপনার আগ্রহের সংখ্যার সাথে এই অন্তর অন্তর্ভুক্ত করা বা বিয়োগ করা আপনার পছন্দসই একটি ব্যবধানে মূলত নম্বরটি 'বৃত্তাকার' করতে পারে।

> 7 + (5 - 7 %% 5)       #round UP to the nearest 5
[1] 10
> 7 + (10 - 7 %% 10)     #round UP to the nearest 10
[1] 10
> 7 + (2 - 7 %% 2)       #round UP to the nearest even number
[1] 8
> 7 + (100 - 7 %% 100)   #round UP to the nearest 100
[1] 100
> 7 + (4 - 7 %% 4)       #round UP to the nearest interval of 4
[1] 8
> 7 + (4.5 - 7 %% 4.5)   #round UP to the nearest interval of 4.5
[1] 9

> 7 - (7 %% 5)           #round DOWN to the nearest 5
[1] 5
> 7 - (7 %% 10)          #round DOWN to the nearest 10
[1] 0
> 7 - (7 %% 2)           #round DOWN to the nearest even number
[1] 6

হালনাগাদ:

সুবিধাজনক 2-যুক্তি সংস্করণ:

rounder <- function(x,y) {
  if(y >= 0) { x + (y - x %% y)}
  else { x - (x %% abs(y))}
}

ধনাত্মক yমান roundUp, তবে নেতিবাচক yমানগুলি roundDown:

 # rounder(7, -4.5) = 4.5, while rounder(7, 4.5) = 9.

বা ....

ফাংশন যা স্ট্যান্ডার্ড রাউন্ডিং নিয়মের ভিত্তিতে স্বয়ংক্রিয়ভাবে UP বা DOWN গোল করে:

Round <- function(x,y) {
  if((y - x %% y) <= x %% y) { x + (y - x %% y)}
  else { x - (x %% y)}
}

রাউন্ডিং মানের পরবর্তী দৃষ্টান্তগুলির মধ্যে যদি xমানটি >অর্ধেক হয়ে যায় তবে স্বয়ংক্রিয়ভাবে গোল হয়ে যায় y:

# Round(1.3,1) = 1 while Round(1.6,1) = 2
# Round(1.024,0.05) = 1 while Round(1.03,0.05) = 1.05

Question 8

একটি স্বেচ্ছাসেবী সংখ্যার সংখ্যাবৃদ্ধি , যেমন 10 এর গুণগত মান সম্পর্কে , এখানে জেমসের উত্তরের একটি সহজ বিকল্প।

এটি যেকোন আসল সংখ্যাকে ( from) এবং যে কোনও বাস্তব ধনাত্মক সংখ্যাকে ( to) অবধি গোল করবে :

> RoundUp <- function(from,to) ceiling(from/to)*to

উদাহরণ:

> RoundUp(-11,10)
[1] -10
> RoundUp(-0.1,10)
[1] 0
> RoundUp(0,10)
[1] 0
> RoundUp(8.9,10)
[1] 10
> RoundUp(135,10)
[1] 140

> RoundUp(from=c(1.3,2.4,5.6),to=1.1)  
[1] 2.2 3.3 6.6

Question 9

আমি মনে করি আপনার কোডটি কেবলমাত্র একটি ছোট সংশোধন করে দুর্দান্ত কাজ করে:

foo <- function(x, round=10) ceiling(max(x+10^-9)/round + 1/round)*round

এবং আপনার উদাহরণগুলি চালিত:

> foo(4, round=1) == 5
[1] TRUE
> foo(6.1) == 10            #maybe 7 would be better
[1] TRUE
> foo(6.1, round=1) == 7    # you got 7
[1] TRUE
> foo(30.1) == 40
[1] TRUE
> foo(100.1) == 110
[1] TRUE
> # ALL in one:
> foo(c(4, 6.1, 30.1, 100))
[1] 110
> foo(c(4, 6.1, 30.1, 100), round=10)
[1] 110
> foo(c(4, 6.1, 30.1, 100), round=2.3)
[1] 101.2

আমি আপনার কার্যটি দুটি উপায়ে পরিবর্তন করেছি:

দ্বিতীয় যুক্তি যুক্ত করা হয়েছে (আপনার নির্দিষ্ট এক্সের জন্য )
আপনি যদি একটি বৃহত সংখ্যা চান তবে একটি স্বল্প মূল্য (( =1e-09সংশোধন করতে নির্দ্বিধায়!) যোগ করুন addedmax(x)

Question 10

আপনি যদি সর্বদা নিকটতম এক্স পর্যন্ত কোনও সংখ্যাটি গোল করতে চান তবে আপনি এই ceilingফাংশনটি ব্যবহার করতে পারেন :

#Round 354 up to the nearest 100:
> X=100
> ceiling(354/X)*X
[1] 400

#Round 47 up to the nearest 30:
> Y=30
> ceiling(47/Y)*Y
[1] 60

একইভাবে, আপনি যদি সর্বদা গোল হয়ে যেতে চান তবে floorফাংশনটি ব্যবহার করুন । আপনি যদি নিকটস্থ Z তে কেবল উপরের দিকে বা নীচে নামাতে চান তবে roundপরিবর্তে ব্যবহার করুন।

> Z=5
> round(367.8/Z)*Z
[1] 370
> round(367.2/Z)*Z
[1] 365

Question 11

টমির উত্তরের একটি আপগ্রেড সংস্করণ আপনি পাবেন যা বেশ কয়েকটি ক্ষেত্রে বিবেচনা করে:

নিম্ন বা উচ্চতর গণ্ডির মধ্যে নির্বাচন করা
নেতিবাচক এবং শূন্য মান গ্রহণ করা
আপনি যদি ফাংশনটি ভিন্নভাবে ছোট এবং বড় সংখ্যককে গোল করতে চান তবে দুটি ভিন্ন সুন্দর স্কেল। উদাহরণ: 4 গোলাকার হবে 0 এবং 400 টি 400 এ গোল করা হবে।

কোডের নীচে:

round.up.nice <- function(x, lower_bound = TRUE, nice_small=c(0,5,10), nice_big=c(1,2,3,4,5,6,7,8,9,10)) {
  if (abs(x) > 100) {
    nice = nice_big
  } else {
    nice = nice_small
  }
  if (lower_bound == TRUE) {
    if (x > 0) {
      return(10^floor(log10(x)) * nice[[max(which(x >= 10^floor(log10(x)) * nice))[[1]]]])
    } else if (x < 0) {
      return(- 10^floor(log10(-x)) * nice[[min(which(-x <= 10^floor(log10(-x)) * nice))[[1]]]])
    } else {
      return(0)
    }
  } else {
    if (x > 0) {
      return(10^floor(log10(x)) * nice[[min(which(x <= 10^floor(log10(x)) * nice))[[1]]]])
    } else if (x < 0) {
      return(- 10^floor(log10(-x)) * nice[[max(which(-x >= 10^floor(log10(-x)) * nice))[[1]]]])
    } else {
      return(0)
    }
  }
}

Question 12

আমি কোনও বাহ্যিক গ্রন্থাগার বা ক্রিপ্টিক বৈশিষ্ট্য ব্যবহার না করে এটি চেষ্টা করেছি এবং এটি কার্যকর!

আশা করি এটি কাউকে সাহায্য করবে।

ceil <- function(val, multiple){
  div = val/multiple
  int_div = as.integer(div)
  return (int_div * multiple + ceiling(div - int_div) * multiple)
}

> ceil(2.1, 2.2)
[1] 2.2
> ceil(3, 2.2)
[1] 4.4
> ceil(5, 10)
[1] 10
> ceil(0, 10)
[1] 0