[Question]
  [
[Sandbox](https://codegolf.meta.stackexchange.com/a/18335/85052)
Given two positive integers a and b, return the smallest multiple of b that is greater than or equal to a.
## Examples
Definitions: `true` = `is a multiple of b`, `false` = `is not a multiple of b`.
* `f(1,3) = 3` because `1` is false, `1+1` is false, but `1+1+1` is true. Therefore `3` is returned.
* `f(5,3) = 6` because `5` is false, but `5+1` is true. Therefore `6` is returned.
* `f(9,3) = 9` because `9` is already a multiple of 3.
* `f(12,5) = 15` because `12` is false, `12+1` is false, `12+2` is false, but `12+3` is true. Therefore `15` is returned.
## Rules
* Input/output can be given by [any convenient method](http://meta.codegolf.stackexchange.com/q/2447/42963).
* You can print it to STDOUT or return it as a function result.
* Either a full program or a function are acceptable.
* Any amount of extraneous whitespace is permitted, provided the characters line up appropriately.
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
## The Catalogue
The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
## Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
## Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
## Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the snippet:
```
## [><>](https://esolangs.org/wiki/Fish), 121 bytes
```
```
/* Configuration */
var QUESTION_ID = 196683; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.
/* App */
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}
function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}
getAnswers();
var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) {
  return a.owner.display_name;
}
function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });
  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);
    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });
  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);
  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });
  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }
}
```
```
body {
  text-align: left !important;
  display: block !important;
}
#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}
#language-list {
  padding: 10px;
  width: 500px;
  float: left;
}
table thead {
  font-weight: bold;
}
table td {
  padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">
    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">
    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
```
  
[Answer]
# [Python](https://docs.python.org/2/), 17 bytes
```
lambda a,b:a+-a%b
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSFRJ8kqUVs3UTXpf1p@kUKmQmaeQlFiXnqqhqmmVUFRZl6JQqZOmkamjrHmf0NzHRMA "Python 2 – Try It Online")
Since this doesn't use division, it works for both Python 2 and 3. Note that we can't cut out the `+` sign because `a-a%b` does `a-(a%b)`, whereas we want to do`(-a)%b` and add that to `a`. We could also write it as `-a%b+a`.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 2 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
cV
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=Y1Y&input=MTIsNQ)
```
cV     :Implicit input of integers U & V
cV     :Round U up to the nearest multiple of V
```
With input as an array:
```
rc
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=cmM&input=WzEyLDVd)
```
rc     :Implicit input of array
r      :Reduce by
 c     :Rounding the first element up to the nearest multiple of the second
```
## Less Trivial!, 6 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
_vV}aU
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=X3ZWfWFV&input=MTIsNQ)
```
_vV}aU     :Implicit input of integers U & V
_          :Function taking an integer Z as input
 vV        :  Is Z divisible by V?
   }       :End function
    aU     :Starting from U, return the first integer that returns true when passed through that function
```
```
ôV ævV
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=9FYg5nZW&input=MTIsNQ)
```
ôV ævV     :Implicit input of integers U & V
ôV         :Range [U,U+V]
   æ       :Get first element
    vV     :  Divisible by V
```
[Answer]
## [Intcode (day 5)](https://github.com/tckmn/polyaoc-2019/blob/master/05/rb/05.rb), ~~70~~ ~~66~~ 64 bytes
```
3,0,3,2,102,-1,2,4,1,0,4,0,1,1,8,1,7,9,0,5,5,5,14,2,1,2,0,4,0,99
```
[Try it online!](https://tio.run/##jVNNU4MwEL3zK9ZDbWsjEj5sqTI9edSTN4ZxaEktYwUGwlh0/O24SVosQp0mE9i3ee9l2A15uazqVRox8GBYW8QgFjEJNUxyTTGwCcWUjYvinOGaEheRIye1BReXorhuPdSLbBvz0YKM9fcwg8s5T19iLWJriBMuzwkJhlnJNcAR4rGhHpWZRDEiQ0ZpyZGC0A8kXrLXOJGRGNs0zeCrgWLskDsK/Ti4oYYxHlADcx66wQJCH/MTGgQwBxVBzopVySCJty2T6thk79IyMRsT86TJZ8tEubRMrMbEOmmyCgsmKAEMAG1aex8blgAFLl6/jh6WYALVHRZx4oHdVZh9iqv/FNaxgkqF7JxebOI13@vMrs5WOtVDPSuLDexOsx3F3sGFKtJI3IJqjCUaSYk17mpuDxrvfM207/vvRdMXWM05GKcLMeuT4tFnSF1XaZc5C99a22yLLc4ZL/Ok036WRA3@ltH@njylj4xv0ughz9OcwHOVMRk27D@GByPVC01ALWt@RfEg4FNiBd2s05t1e7PUJE5Q/wA)
Intcode is a programming language invented for [Advent of Code 2019](https://adventofcode.com/2019). It was first introduced on [day 2](https://adventofcode.com/2019/day/2), then further expanded upon on [day 5](https://adventofcode.com/2019/day/5), which is the version used here.
Since on PPCG, languages are defined by their interpreters, I am using the interpreter that I wrote for my day 5 solution (which was written before this challenge).
Explanation:
```
3,0,          store first input in cell 0
3,2,          store second input in cell 2
              (cell 1 is a counter, because it's already initialized to zero)
102,-1,2,4,   negate the second input and store in cell 4
              (begin loop)
1,0,4,0,      subtract the second input from the first input
1,1,8,1,      increment the counter (by adding cell 8)
7,9,0,5,      if the first input is greater than zero (cell 9)...
5,5,14,       ... jump to the beginning of the loop (reusing the cell 8 reference)
2,1,2,0,      multiply the counter by the second input
4,0,99        output and quit
```
[Answer]
# x86 Machine Code, 7 bytes
Since x86 integer division instructions do only floor rounding, this uses the formula: `f(a,b) = floor((a+b-1)/b)*b` to accomplish ceiling rounding.
```
02 C3   ADD  AL, BL     ; a = a + b
48      DEC  AX         ; a = a - 1
F6 F3   DIV  BL         ; a = a / b
F6 E3   MUL  BL         ; a = a * b
```
Input is in `AL` and `BL`, output is `AL`.
**Testing**
Here is output from a test program for PC DOS that takes interactive input.
[![enter image description here](https://i.stack.imgur.com/5Pvvn.png)](https://i.stack.imgur.com/5Pvvn.png)
Download and test [ROUNDMY.COM](https://stage.stonedrop.com/ppcg/ROUNDMY.COM).
[Answer]
# [MATL](https://github.com/lmendo/MATL), 4 bytes
```
:ien
```
[Try it online!](https://tio.run/##y00syfn/3yozNe//f0MjLlMA "MATL – Try It Online")
### Explanation
Consider inputs `12`, `5`.
```
     % Implicit input
:    % Range
     % STACK: [1 2 3 4 5 6 7 8 9 10 11 12]
i    % Input
     % STACK: [1 2 3 4 5 6 7 8 9 10 11 12], 5
e    % Reshape as a matrix with that number of rows, padding with zeros
     % STACK: [1  6 11;
               2  7 12;
               3  8  0;
               4  9  0;
               5 10  0]
n    % Number of elements
     % STACK: 15
     % Implicit display
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 17 bytes
Same method as [this JS answer](https://codegolf.stackexchange.com/questions/196683/round-up-my-number/196690#196690):
```
@(a,b)ceil(a/b)*b
```
[Try it online!](https://tio.run/##y08uSSxL/Z9mq6en999BI1EnSTM5NTNHI1E/SVMr6X@ahqGOsaaCqoKtgrECV5qGKZhnq2AGZFvCZCyBHEMjHVMIz9CU6z8A "Octave – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~23~~ ~~20~~ 18 bytes
```
lambda a,b:-a/b*-b
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSFRJ8lKN1E/SUs36X9afpFCpkJmnkJRYl56qoapplVBUWZeiUKmTppGpo6x5n9Dcx0TAA "Python 2 – Try It Online")
2 bytes thanks to [tsh](https://codegolf.stackexchange.com/users/44718/tsh)
[Answer]
# [Haskell](https://www.haskell.org/), 14 bytes
```
a%b=a+mod(-a)b
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P1E1yTZROzc/RUM3UTPpf25iZp6CrUJBUWZeiYKKQm5igYKGqrGmQrSBnp6hQez/f8lpOYnpxf91kwsKAA "Haskell – Try It Online")
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), ~~43~~ ~~41~~ ~~40~~ ~~36~~ 25 bytes
```
#define f(a,b)(b-a%b)%b+a
```
[Try it online!](https://tio.run/##hY7NCoJAFIXXzlNcFMEhhSxciNa7zM9VBvQqzswqevapKEkX0Vmdb/FxjprnolcqhERjZwihy0QueSYLkUqeyoMIiSE1eI3Qmsm6BcV4ZcxbQz2QGNHOQiFYpxvGDDkYhaGMsxuL1OQdtC3EXVbmcOZwgfjFKz4rkh4aBp9shGovVKvw26j3Rv13ojzlUG1Pvfk7Ei3o/EJwbNg9PAA "C++ (gcc) – Try It Online")
Saved 4 bytes thanks to @Neil!!! 
Saved 11 bytes thanks to @AZTECCO!!!
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 17 bytes
```
a=>b=>a+(b-a%b)%b
```
[Try it online!](https://tio.run/##Nco7DoMwDADQvafwgmSrAQkqhg7O1lNEGeyQ9CNEEIl6/XSh01veR75SwvHea7/lJbbETdgqW7mi9tIpddpqLDVIicDg3Gjg5g24@fR@Ok4GZu8v/zykfDwkvBCdGFBPwBZC3kpe47DmJyYUQiWi9gM "JavaScript (Node.js) – Try It Online")
* -1 byte by [Neil](https://codegolf.stackexchange.com/users/17602/neil)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes
```
÷Ċ×
```
[Try it online!](https://tio.run/##y0rNyan8///w9iNdh6f/97Z@1DBHQddO4VHDXOvDy/W5Drc/aloT@f9/tKGOcaxOtCmYtASThkY6prEA "Jelly – Try It Online")
Simply divide, ceiling, multiply. 
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~47~~ ~~31~~ 25 bytes
```
f(a,b){a=a%b?f(++a,b):a;}
```
[Try it online!](https://tio.run/##S9ZNT07@r5yZl5xTmpKqYFNckpKZr5dh9z9NI1EnSbM60TZRNck@TUNbG8S1SrSu/Z@ZV6KQm5iZp1GWn5miWc3FWVAEFErTUFJNiclDYCUdhTQNQx1jTRBtCqUtobShkY6ppqY1F2dRaklpUZ6CgTVX7X8A "C (gcc) – Try It Online")
-16 bytes thanks to A̲̲ (forgot that return types and parameters would default to int if not defined, whoops!)
-6 thanks to AZTECCO for using a ternary and making the function recursive
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 7 bytes
```
Ceiling
```
Just pointing out that Mathematica's builtin, which is most commonly called with one argument, actually does exactly the desired operation when called with two arguments.
[Answer]
## Brainfuck, ~~52~~ 49 bytes
Thanks to [Jo King](https://codegolf.stackexchange.com/users/76162/jo-king) for finding a bug, helping fix it with some extra golfing.
```
,>>,<<[>+>->+<[>]>[<+>-]<<[<]>-]>>>[<[-<+>]>,]<<.
```
Input and output is in character codes.
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fx85Ox8Ym2k7bTtdOG0jH2kXbANmxQDGbWCBtZwcUiNYFisXa6QBF9f7/T00EAA)
**Explanation**
```
,>>,<<                     [>a, 0,     b,   0]
[>+>->+<[>]>[<+>-]<<[<]>-] [>0, a, b-a%b, a%b]
>>>[<[-<+>]>,]             If a%b is nonzero, add b-a%b to a, and clear a%b
<<.                        Output a+(b-a%b)
```
Modulus algorithm is straight from [the esolang list of brainfuck algorithms](https://esolangs.org/wiki/Brainfuck_algorithms#Modulus_algorithm).
[Answer]
# [JavaScript (V8)](https://v8.dev/), 22 bytes
This is the function \$(a,b) \mapsto \left\lceil \frac{a}{b} \right\rceil b\$.
```
a=>b=>Math.ceil(a/b)*b
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/ifZvs/0dYuydbON7EkQy85NTNHI1E/SVMr6X9yfl5xfk6qXk5@ukaahqGRpoappuZ/AA "JavaScript (V8) – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 20 bytes
```
function(a,b)a+-a%%b
```
[Try it online!](https://tio.run/##K/qfpmCj@z@tNC@5JDM/TyNRJ0kzUVs3UVU16X@ahqGOsSZXmoYphLKEUIZGOqaa/wE "R – Try It Online")
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 8 bytes
```
{x+y!-x}
```
[Try it online!](https://tio.run/##y9bNz/7/P82qukK7UlG3ovZ/mp66hqGCsbUpEFsCsaGRgqnmfwA "K (oK) – Try It Online")
Another port of [xnor's Python answer](https://codegolf.stackexchange.com/a/196700/75681).
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 3 bytes
```
/⌈*
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%2F%E2%8C%88*&inputs=5%0A12&header=&footer=)
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 28 bytes
```
\d+
$*
r`1+(\2*) (1+)
$1$2
1
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wPyZFm0tFi6sowVBbI8ZIS1NBw1Bbk0vFUMWIy/D/f0MFYy5TILYEYkMjBVMA "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
\d+
$*
```
Convert the inputs to unary.
```
r`
```
Process this stage from right-to-left, so that `\2` gets to match \$ b \$ first, allowing us to refer to it when matching within \$ a \$.
```
1+(\2*) (1+)
```
Match \$ b \$ in `\2`, then as many copies of \$ b \$ as we can, without completely exhausting \$ a \$. `\1` thus matches \$ b \lfloor \frac {a - 1} b \rfloor = b \lceil \frac {a - b} b \rceil \$
```
$1$2
```
Add that to \$ b \$ to give \$ b \lceil \frac a b \rceil \$.
```
1
```
Convert to decimal.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 13 bytes
```
->a,b{-a%b+a}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y5RJ6laN1E1STux9n9BUWZeiUKaXnJiTo6GoY6xJldBaUkxF4qwKXZhS@zChkY6ppr/AQ)
[Answer]
# [Red](http://www.red-lang.org), 31 bytes
```
func[a b][round/to/ceiling a b]
```
[Try it online!](https://tio.run/##K0pN@R@UmhIdy5Vm9T@tNC85OlEhKTa6KL80L0W/JF8/OTUzJzMvXQEk@j8tvyg1MTlDAaLGUMFYwRSILYHY0EjBNDa6oCgzrwQoqa6nkKSgrmunkAbWF/sfAA "Red – Try It Online")
Just a built-in `round` with refinements `to`, which scales the first argument according to the second, and `ceiling`, which indicates the direction.
# [Red](http://www.red-lang.org), 25 bytes
```
func[a b][0 - a // b + a]
```
[Try it online!](https://tio.run/##K0pN@R@UmhIdy5Vm9T@tNC85OlEhKTbaQEFXIVFBX18hSUFbITH2f1p@UWpicoYCRNZQwVjBFIgtgdjQSME0NrqgKDOvBCiprgfUoa5rp5CmAFIZ@x8A "Red – Try It Online")
A port of [xnor's Python answer](https://codegolf.stackexchange.com/a/196700/75681). Don't forget to upvote his answer!
[Answer]
# [Prolog (SWI)](http://www.swi-prolog.org) + [CLPFD](https://www.swi-prolog.org/man/clpfd.html), 30 bytes
```
f(R,X,Y):-R#=_*Y,R-Y#<X,R#>=X.
```
[Try it online!](https://tio.run/##KyjKz8lP1y0uz/xvpatQWpwan5ufUpqTqpGTmVSUWFSpkZxTkJaiqan3P00jSCdCJ1LTSjdI2TZeK1InSDdS2SZCJ0jZzjZC7z9Y3tBIx1RTj4sLAA "Prolog (SWI) – Try It Online")
```
f(R,X,Y)
```
`f` is a predicate taking in a variable `R`, and two integers `X` and `Y`.
The CLPFD constraints are expressed using the `#`-prefixed operators. `,` means and, so `f` is true iff all these constraints are satisfied, i.e.,
1) `R#=_*Y` R is a multiple of Y `,` and
2) `R-Y#<X` R-Y < X `,` and
3) `R#>=X` R >= X `.`
[Answer]
# [SimpleTemplate](https://github.com/ismael-miguel/SimpleTemplate), 61 bytes
This was quite fun! Sadly, I had to do the dumb way :(
```
{@fn F A,B}{@whileA is notmultipleB}{@incA}{@/}{@returnA}{@/}
```
Creates a function that iterates until it finds a number that's multiple of the 2nd number.
This was actually way smaller than doing it without a function.
---
**Ungolfed:**
```
{@fn F numberA, numberB}
    {@while numberA is not multiple of numberB}
        {@inc by 1 numberA}
    {@/}
    {@return numberA}
{@/}
```
Should be mostly straightforward.
You can see it running on <https://ideone.com/MR7t1E> (golfed version only).
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 10 bytes
```
≔±ＮθＩ×θ÷Ｎθ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/9@xuDgzPU/DLzU9sSRVwzOvoLTErzQ3KbVIQ1NTR6FQ05oroCgzr0TDObG4RCMkMze1WKNQR8Ezr8QlsywzBU0HSAMQWP//b6pgaPRftywHAA "Charcoal – Try It Online") Link is to verbose version of code. Takes \$ b \$ first and \$ a \$ second. Explanation:
```
≔±Ｎθ
```
Input \$ b \$, negate it, and save the result.
```
Ｉ×θ÷Ｎθ
```
Input \$ a \$ and compute \$ -b \lfloor \frac a {-b} \rfloor \$, then cast to string for implicit print.
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 6 bytes
```
.~)@%+
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/X69O00FV@/9/AA "GolfScript – Try It Online")
Function which consumes A and B from the stack, assuming B is below A. 
### Explanation:
```
           #Example input: A = 12, B = 5          stack is  5  12
.~)        #Duplicate A and negate the duplicate  stack is  5  12 -12
   @       #Pull 3rd from top to top              stack is 12 -12   5
    %      #Second to top mod top                 stack is 12 3
     +     #Add remaining values                  stack is 15
```
[Answer]
# Javascript (ES6), 19 bytes
```
a=>b=>a%b?a-a%b+b:a
```
Naive attempt, pretty sure this can be golfed further.
[Answer]
# Java, 99 bytes
```
static int r(int a,int b){int t=a%b<1||b%a<1?a:r(a+1,b);return t;}
```
[Answer]
## JavaScript, 15 bytes
```
a=>b=>--a+b-a%b
```
More expressively, the answer is `a => b => a + b-((a-1)%b) - 1`, but by decrementing `a` we can handle both the "subtract one" steps at once, saving a couple of bytes. Then we just get lucky with operator presidencies.
[Answer]
## Perl 5, (111 bytes with footer) 52 bytes
`sub f{($a,$b)=@_;$c=$b;$c++until!($c%$b)&&$c>=$a;$c}`
[Try it online!](https://tio.run/##K0gtyjH9/7@4NEkhrVpDJVFHJUnT1iHeWiXZViUJSGprl@aVZOYoaqgkqwKl1NRUku1sVRKBMrX/C4oy80oU0jQMdYw1FfQUlHSUgGSahikq1xKVa2ikY6r5HwA "Perl 5 – Try It Online")
Takes `a` and `b` as arguments to a subroutine named `f` and increases `$c` until it is both a multiple of `$b` and greater than or equal to `$a`. Then returns `$c` (the last value evaluated in a subroutine is the return value).
[Answer]
# [Java (JDK)](http://jdk.java.net/), 15 bytes
```
b->a->--a+b-a%b
```
[Try it online!](https://tio.run/##XVBNa4QwFLz7Kx4LgrYx1JY9tFahl0IPpYelp8XDix9LrEZJnoIs/nabVXcPe0gyM5k3Q1LhgEGV/82y6VpNUFnOe5I1L3uVkWwVf4icrEZj4BulgrMD0PWilhkYQrLH0MocGnvnHUhLdTqmgPpk/MUK8KXoc4t6t/hXoR5/ukIjtTqBEuJZBAkGSRDgowjQFXO0zElFx9RmUWHIQLylAZwhZPACE7vx/R1/vePhM4P9VZjW9LLV3oB6SX9bO/xbha0GtJUX@fiUMhBXEqbR5jmMhoqGtz3xzr6aSm@HsZtb77LrwvQ1WeiqHQO0MoOSY9fVoyf8FXwY@x8e@v6aOTmXNc3/ "Java (JDK) – Try It Online")
]