text:
Multiply two numbers
Input: Two decimal integers. These can be given to the code in standard input, as arguments to the program or function, or as a list.
Output: Their product, as a decimal integer. For example, the input 5 16 would lead to the output 80.
Restrictions: No standard loopholes please. This is code-golf, answer in lowest amount of bytes wins.
Notes: Layout stolen from my earlier challenge, Add two numbers.
Test cases:
1 2   -> 2
4 5   -> 20
7 9   -> 63
-2 8  -> -16
8 -9  -> -72
-8 -9 -> 72
0 8   -> 0
0 -8  -> 0
8 0   -> 0
-8 0  -> 0
0 0   -> 0

Or as CSV:
a,b,c
1,2,2
4,5,20
7,9,63
-2,8,-16
8,-9,-72
-8,-9,72
0,8,0
0,-8,0
8,0,0
-8,0,0
0,0,0

Leaderboard

var QUESTION_ID=106182,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

I think this is too trivial and too similar to your "add two numbers" challenge.

@FlipTack That's assuming addition and multiplication are as easy in any language, which I don't know if it's actually true.

@Fatalize Well, there will be several 1 byte answers, such as mine below :P

There are dedicated array summation functions in some languages, like add in jq and array_sum() in PHP, so not all answers are portable, but I think they not worth a separate challenge.

I don't think it's fair to allow the "add two numbers" challenge but close this one. Even though it's very trivial in most programming languages, it's still a valid challenge. If this is too broad, then the "add two numbers" challenge must also be too broad.

Anyone is free to downvote trivial challenges if they don't like them, but this is a perfectly valid and on-topic challenge and it's nowhere near "too broad" (if anything, you might call a trivial challenge too narrow). I'm reopening this. That said, if anyone feels that trivial challenges insult their intelligence, I encourage them to seek out languages that make the task less trivial.

Uo next: Subtract two numbers!

Every answer so far except one is equivalent to one to adding numbers, but with a * operator in place of + (or a synonym like product for sum). I'm closing as duplicate of "Add two numbers" on the principle that answers could be copied over in mass with a simple systematic modification.

@xnor I'm sure there are languages that multiplication is much more nontrivial than simple addition, and, sometimes, the signs of the numbers have to be determined first (that can be exceptionally difficult too in languages like Sesos for example).

One example in favor to this. I made a language called SimpleTemplate. To sum, 2 numbers, I just do {@call array_sum intoX argv}{@echoX}. While, for this answer, I must loop manually the values, giving me {@setx 0}{@for_ from1 toargv.0}{@incbyargv.1 x}{@/}{@echox}.

@xnor I agree with Martin. I think it's worth having. A solution in Retina, for example, would not be the same as the addition one, nor is it trivial, since negative numbers are part of the challenge.

@mbomb007 I would like to allow non-trivial answers to be posted, but trivial single-operator solutions have been and will be cranked out and upvoted by the HNQ lemmings. Maybe we can collapse these into a single CW answer?

If I was about to post "Exponent 2 Numbers", if we aren't voting to close this one, then we wouldn't vote to close that one, right? Kinda dumb imho...

@carusocomputing This was closed, but Martin reopened it

@steenbergh that would be a dupe of addition since a-b=a+(-b)

I may do division, exponentiation, and roots soon.

@wat Leaving no barrel-bottom unscraped, eh?

Who's going around downvoting working, competitive answers?

@SuperJedi224 I down vote boring answers and some of them belong to you.

@WheatWizard Yes I know it's not just my answers, you also got wat's ruby answer (and probably others)

What is the largest and smallest values that need to be supported?

@steenbergh that was made by a new user and was closed

Is there any reason why the numbers have to be in decimal? There are many esolangs where inputting and outputting decimal numbers (as opposed to e.g. unary or Church numerals) is hard (or sometimes even impossible), and it seems artificial to exclude those languages. Can I edit the question to get rid of that restriction?

Brachylog V1, 05AB1E, J, K, Underload, MATL, Forth, PigeonScript, Stacked, Implicit, Jolf, Clojure, Braingolf, 8th, Common Lisp, Julia, Pyt, Appleseed, Stax, Reality, dc, Vyxal, Keg, Swift, Fig*, Chocolate, ><>, Thunno*: 1 byte
*

You may edit this answer to add other languages for which * is a valid answer.
*Actually \$\log_{256}(96)\approx\$ 0.823 bytes in Fig and Thunno

Polygot, 05AB1E and like 5 other languages.

I edited Underload into this. It's possibly the most interesting of these, because Underload does not have a 1 byte method of doing subtraction, division, or addition.

Here's another one: http://codegolf.stackexchange.com/a/106187/62257

This isn't valid in Pyth. Pyth doesn't take implicit input like this.

Added Julia, eg *(5,16)

added pyt

Doesn't really work as-is in K... * is 'first' if you give it a list. */ for 2 bytes would work.

I think this also works in Ohm v2

And Ly https://tio.run/##y6n8/1/r/39TLhMA

C (GCC), 13 bytes
Doesn't work on all implementations, but that's OK.
f(a,b){a*=b;}

Try it on TIO!

Wait, is this supposed to somehow return a? I don't get it...

An explanation to how this works would be helpful. (a is a local stack variable to f() - why is its value returned?).  +1, btw - very clever abuse of the ABI.

@EriktheOutgolfer The return keyword simply places the redult of the its argument in the EAX register. In this case, the generated executable does the computation of a*b in that register, so return doesn't do anything.

Hey, that was my trick! http://codegolf.stackexchange.com/a/106067/18535 :-)

@GB, oh nice, but I didn't see this on your tip, I saw it somewhere else on the internet.

So happy to see C at the top for once! You can actually shave off about 9 bytes by simply replacing the f(a,b){a*=b;} part with 1##& and then just changing your language to Mathematica.

Umm, So C++ has lambdas, any answers with that? Nobody? Okay then, I have to post it. sigh

@You I thought I posted that, but I didn't remember posting that, then I realized it was You who posted that.

Beatnik, 888 bytes
k I
j k ZZZZX z
xw k C vp yQ KD xw z j k ZZZZX z
j k ZZZD z xw bZ ZX
k XX z qs xw vp xw xw vp xw vp vp vp k I Xj ZZD hd
xw yQ K k ZZZZX xo exx
qs yQ XA xw xw xw xw z xw bZ K
xw xw k I
j k ZZZZX z
xw k C vp yQ XA hd k I z j k ZZZZX z
j xw k A vp bZ ZX
k ZZZZX z qs xw vp xw xw vp xw vp vp vp k I Xj ZZD hd
xw yQ K k ZZZZX xo exx
qs yQ F k ZZZZK xo
vp
xw xw z qs xw bZ X xw k I z xw Xj K
qs xw bZ KA vp qs xw Xj C hd
qs z xw xw xw xw z qs
xw xw xw xw z qs k I qs k I z xw Xj ZC
qs bZ ZZZX qs xw yQ C hd xw
k I vp qs k I qs
xw Xj ZZC hd hd z Kz ZZD
k I z xw xw xw xw z qs k I qs k I Xj ZZZZF
z
xw xw z qs xw bZ X xw k I z xw Xj K
qs xw bZ KA vp qs xw Xj C hd
z qs xw
xw xw z qs xw bZ X xw k I z xw Xj K
qs xw bZ KA vp qs xw Xj C hd
z vp
xw xw z qs
xw xw z qs
k I qs
xw bZ ZZX k I z qs k I vp
xw k ZA z yQ ZA hd qs k I vp qs k I Xj ZZKD
qs xw Xj ZZK
hd qs xw Xj ZZZZ hd
k ZZZZKD vp xo xw Xj K

Try it online!
I'm using the C interpreter because the Python interpreter on TIO annoyingly executes the address if the condition for jumping backward isn't met. An easy workaround for the Python interpreter is to pad some nops to make the address nop. I believe neither is correct:
                                   C       Python  My interpretation
IP after skiping N words           IP+N+1  IP+N+2  IP+N+2
IP after skiping back N words      IP-N    IP-N+1  IP-N+2
IP after not skiping N words       IP+2    IP+2    IP+2
IP after not skiping back N words  IP+2    IP+1    IP+2

Input should be two integers separated by a space, without trailing newlines.
This answer works in theory for all integers, if each cell can store an arbitrarily large value, not limited to 0 - 255. But it overflows if |A|+|B| > 22. And it runs very slowly if |A|+|B| > 6. So there is not many cases you can actually test and an if-else solution for those cases might be even shorter.
The idea is to compute the triangular numbers T(N) = N(N+1)/2 by decrementing the value to 0 and summing up all the intermediate values. Then we can get the answer A*B = T(A+B) - T(A) - T(B).
But it is tricky to compute all the 3 values. It does this by firstly computing T(A+B) - A, leaving a copy of A in the stack to add back later, and using up the input B. Then recursively find the greatest triangular number smaller than that, which is T(A+B-1) except for the zero special cases. We can get back B = T(A+B) - A - T(A+B-1) and compute T(B) from there.
A number N is a triangular number iff it equals to the greatest triangular number smaller than N, plus the number of non-negative triangular numbers smaller than N. This runs in O(2^(T(A+B)-A)) and is the slowest part in the program.
k I                                         Push 1
j k ZZZZKAAA z                              Input and decrement by 48.
xw k AAA vp yQ (input_a_loop)               If the character was '-':
xw z j k ZZZZKAAA z                           Replace with 0 and input another.
input_a_loop:
j k ZZZAA z xw bZ (input_a_end)             Input and break if it is a space.
k ZKA z qs xw vp xw xw vp xw vp vp vp       Otherwise multiply the previous
                                              value by 10 and add.
k I Xj (input_a_loop)                       Continue the loop.
input_a_end: hd                             Discard the space.
xw yQ (check_sign) k ZZZZKAAA xo exx        If A=0, print 0 and exit.
                                            Stack: ?, A_is_positive, A
check_sign:
qs yQ (check_sign_else)                     If A is positive... or not,
xw xw xw xw z xw bZ (check_sign_end)          in either cases, push 2 copies
check_sign_else: xw xw k I                    of A and the negated flag back
check_sign_end:                               as a constant.
                                            Stack: A, A, A, A_is_negative
j k ZZZZKAAA z                              Similar for B.
xw k AAA vp yQ (input_b_loop)               If the character was '-':
hd k I z j k ZZZZKAAA z                       Decrement the flag and input another.
input_b_loop:
j xw k A vp bZ (input_b_end)                EOF is checked instead of a space.
k ZZZZKAAA z qs xw vp xw xw vp xw vp vp vp
k I Xj (input_b_loop)
input_b_end: hd
xw yQ (output_sign) k ZZZZKAAA xo exx       If B=0, print 0 and exit.
                                            Stack: A, A, A, A*B_is_negative, B
output_sign:
qs yQ (output_sign_end) k ZZZZK xo          If negative, output '-'.
output_sign_end:

vp                                          Add.        Stack: A, A, A+B
xw xw z qs                                  Insert a 0. Stack: A, A, 0, A+B.
xw bZ { xw k I z xw Xj }                    Copy and decrement while nonzero.
                                            Stack: A, A, 0, A+B, A+B-1, ..., 0
qs xw bZ { vp qs xw Xj } hd                 Add while the second value in the
                                              stack is nonzero.
                                            Stack: A, A, T(A+B)
qs z xw xw xw xw z qs                       Stack: A, C0=T(A+B)-A, C0, F0=0, C0

expand_loop:
xw xw xw xw z qs k I qs                     Stack: A, C0, C0, F0=0,
                                              ..., [P=C, P, S=0, F=1], C
dec_expand: k I z xw Xj (expand_loop)       Decrement and continue if nonzero.
                                            Stack: [P=1, P, S, F], C=0
                                            The last number 0 is assumed to
                                              be a triangular number.
test: qs bZ (extract_end)                   If F=0, break.
qs xw yQ (test_not_first) hd xw             If S=0, it's the first triangular
                                              number below previous C. Set S=C.
test_not_first: k I vp qs k I qs            S+=1 and restore F=1.
xw Xj (dec_expand)                          If C!=0, recursively expand from C-1.
hd hd z Kz (test)                           If S=P, P is a triangular number,
                                              return to the previous level.
k I z xw xw xw xw z qs k I qs               Otherwise, decrement P and try again.
k I Xj (dec_expand)
extract_end:                                Stack: A, C0, C0, T(A+B-1)

z                                           Subtract and get B.
xw xw z qs xw bZ { xw k I z xw Xj }         Computes T(B).
qs xw bZ { vp qs xw Xj } hd
                                            Stack: A, C0, T(B)
z qs xw                                     Stack: C0-T(B), A, A

xw xw z qs xw bZ { xw k I z xw Xj }         Computes T(A).
qs xw bZ { vp qs xw Xj } hd
z vp                                        Get A*B=(C0-T(B))+(A-T(A))
xw xw z qs                                  Stack: 0, X=A*B

divide: xw xw z qs                          Stack: 0, ..., Y=0, X
subtract: k I qs                            Stack: 0, ..., Y, Z=1, X
xw bZ {                                     While X!=0:
k I z qs k I vp                               X-=1, Z+=1.
xw k ZA z yQ (not_ten)                        But if Z=11:
hd qs k I vp qs k I Xj (subtract)               Y+=1, reset Z and restart the loop.
not_ten: qs xw Xj }
hd qs xw Xj (divide)                        Put Z under Y and make Y the new X,
                                              continue the loop if X!=0.
hd                                          Discard X.

print_loop:
k ZZZZKAA vp xo xw Xj (print_loop)          Add each cell by 47 and print.

Woah. Just... woah. I've place the bounty, you'll get it in 7 days.

Scratch, 1 byte

Usage: Place numbers in both sides of * sign
Note: Since Scratch is a visual language I could not figure out how many bytes it consumes until @mbomb007 noted me about a method for counting scratch bytes

http://meta.codegolf.stackexchange.com/a/5013/34718

@mbomb007 Thanks for your comment!

Mathematica, 4 bytes
1##&

Example usage: 1##&[7,9] returns 63. Indeed, this same function multplies any number of arguments of any type together.
As Mathematica codegolfers know, this works because ## refers to the entire sequence of arguments to a function, and concatenation in Mathematica (often) represents multiplication; so 1## refers to (1 times) the product of all the arguments of the function. The & is just short for the Function command that defines a pure (unnamed) function.
Inside other code, the common symbol * does act as multiplication. So does a space, so that 7 9 is interpreted as 7*9 (indeed, the current REPL version of Mathematica actually displays such spaces as multiplication signs!). Even better, though, if Mathematica can tell where one token starts and another ends, then no bytes at all are needed for a multiplication operator: 5y is automatically interpreted as 5*y, and 3.14Log[9] as 3.14*Log[9].

What makes ##& invalid?

##& returns its list of arguments as a 'Sequence' object—suitable for plugging into other functions that take multiple arguments. In this context, ##& doesn't do anything to its list of arguments; we want that list to be multiplied together.

Retina, 38 37 31 bytes
Completely new approach, the old one is below.
M!`-
*\)`-¶-

.*
$*_
_
$'$*_
_

Try it online!
Explanation
First, we deal with the sign:
M!`-

matches all - in the string and returns them separated by newlines
*\)`-¶-

(with a following empty line)
*\) means the result of this and the previous stages should be printed without a newline, and then the string reverted to what it was before (the input string). The remaining part removes two - separated by a newline.
Then we convert the first number to unary:
.*
$*_

(there's a space at the end of the first line). We use _ as our unary digit in this case, because the standard digit 1 can be present in the second number, and this would conflict later.
Now we get to the actual multiplication:
_
$'$*_

Each _ is replaced by the unary representation of everything following it (still using _ as the unary digit). Since conversion to unary ignores non-digit characters, this will repeat the unary representation of the second number for "first number" times. The second number will remain in decimal representation at the end of the string.
In the end, with a single _ we return the number of _ in the string, which will be the result of the multiplication.

Previous answer:
(warning: outputs an empty string when it should output 0)
Retina,  45  42 41 bytes
Let's play a game! Multiply relative numbers with a language which has no arithmetic operators and limited support only for natural numbers... Sounds funny :)
O^`^|-
--

\d+
$*
1(?=1* (1*))?
$1
1+
$.&

Explanation
The first three lines deal with the sign:
O^`^|-

This sorts O and then reverses ^ all strings matching the regex ^|-. In practice this matches the empty string at the start, and the eventual minus sign before the second number, and reorders them placing the empty string in the place of the minus. After this, all - are at the beginning of the string, and a pair of them can be removed easily with the next two lines.
After that, we use a builtin to convert numbers to unary representation, and then comes the actual multiplication:
1(?=1* (1*))?
$1

We match any 1, and substitute each of them with all the 1 after a following space. Each digit of the first number will be replaced by the full second number, while each digit of the second number will be replaced by the empty string.
The last part is again a builtin to convert back from unary to decimal.
Try it online!

I wish I could upvote submission each time you golf it, nice job!

Wow, that new approach is amazing. I think you win. :) (And it convinces me even more that the default character for $* should be _.)

Btw, here is an ASCII-only solution at the same byte count in case you  prefer that: https://tio.run/nexus/retina#U9VwT/ivFZOgq6etWxMdpxvLxaWnpcClohXPFc@log6m//83VDDiMlEw5TJXsOTSNVKw4LJQ0AWywKQBkGugoAsSMwAJGQB5BgA

Fun fact: apparently I had figured out the trick of mixing one unary and one decimal operator myself at some point.

@MartinEnder thank you :) You still have some time to find another approach or a way to golf this one ;)

I tried updating this to Retina 1.0 and thanks to the new limits and the new repetition operator, it only needs 23 bytes now: https://tio.run/##K0otycxLNPyvpxqj4Z7wX8vOR9dQxyBBl0tPW4dLiyueS0UdSP7/b6hjxGWiY8plrmPJpWukY8FloaMLZIFJAyDXQEcXJGYAEjIA8gwA ... you can even do the multiplication of positive numbers in a single stage now (.+,(.+) to $.($1**) but that is actually more bytes here.

Brain-Flak, 56 bytes
([({}<([({})<>])<>>)<>]){({}[()]<(({})<({}{})>)>)<>}{}{}

This must be run as a full program as it is not stack clean and the inputs must be the only elements in either stack.
Try it online!

Explanation: (call the inputs x and y)
Part 1:
([({}<([({})<>])<>>)<>])

([                    ]) # Push negative x on top of:
      ([      ])         # negative y. After...
  ({}<            >)     # pushing x and...
        ({})             # y...
            <>  <>  <>   # on the other stack (and come back)

At this point we have [x,y] on one stack and [-x,-y] on the other.
Part 2:
{({}[()]<(({})<({}{})>)>)<>}{}{}
{                          }     # Loop until x (or -x) is 0
 ({}[()]<              >)        # Decrement x
         (({})<      >)          # Hold onto y
               ({}{})            # Add y and the number under it (initially 0)
                         <>      # Switch stacks
                            {}{} # Pop x and y leaving the sum

Wow! Definitely the most impressive answer so far

@DJMcMayhem And (slightly modified) it beats the one on the wiki by 18 bytes

Do you have write access to the brain-flak wiki? I'd love to upload a shorter version.

@DJMcMayhem I do not have access. I posted the shorter one in the Brain-Flak chatroom if you want to take a look, and upload it.

I know its been a while but you have some competition ;)

@FunkyComputerMan I saw that. Very impressive!

JavaScript (ES6), 9 bytes
ES6 has a dedicated function for 32-bit integers, faster than the more generic * operator.
Math.imul

Incidentally, this is just as long as:
a=>b=>a*b

Awesome, now I know Math.imul, thank you !

Brain-Flak, 56 54 52 bytes
2 bytes saved thanks to a mistake caught by Nitrodon
({}(<()>)<>)({<([{}({}())])><>([{}]([{}]))<>}<{}{}>)

Try it online!
Stack clean version, 62 60 bytes
({}(<()>)(<>))({<([{}({}())])><>([{}]([{}]))<>}<{}{}<>{}{}>)

Try it online!
Explanation
This explanation is more of an explanation of the algorithm involved and leaves out any actual code.  It assumes that you know how to read Brain-Flak proficiently.  If you need help understanding either the code or the algorithm I would be happy to edit or respond if you leave a comment.
This is a little bit of a strange one and uses some weird math that just barely works out.  The first thing I did was to make a loop that would always terminate in O(n) steps.  The normal way to do this is to put n and -n on opposite stacks and add one to each until one hits zero, however I did it in a slightly stranger way.  In my method I put a counter underneath the input and each step I increment the counter add it to n and flip the sign of n.
Let's walk through an example.  Say n = 7
7  -8   6  -9   5 -10   4 -11   3 -12   2 -13   1 -14   0
0   1   2   3   4   5   6   7   8   9  10  11  12  13  14

I won't prove it here but this will always terminate for any input and will do so in about 2n steps.  In fact it will terminate in 2n steps if n is positive and 2n-1 steps if n is negative.  You can test that out here.
Now we have about 2n steps in our loop how do we multiply by n?  Well here have some math magic.  Here's what we do:  We make an accumulator, each step of the process we add the second input (m) to the accumulator and flip the sign of both of them, we then push the total over all the loops that occur, this is the product.
Why on earth is that the case?
Well lets walk through an example and hopefully it will become clear.  In this example we are multiplying 5 by 3, I will show only the important values
total       -> 0  -5   5 -10  10 -15  15
accumulator -> 0  -5  10 -15  20 -25  30
m           -> 5  -5   5  -5   5  -5   5

Hopefully the mechanism is apparent here.  We are stepping through all the multiples of m in order of their absolute values.  You will then notice that the 2nth term is always m * n and the term before always -m * n.  This makes it so that our looping perfectly lines up with the results we want.  A bit of a happy coincidence ;)

Dyalog APL, 1 byte
× takes one number on the left, and one on the right
× ... or even multiple numbers on the left or on the right or on both sides
×/ multiplies all numbers in a list
×/¨ multiplies the pairs in a given list
×/∊ mulitplies all numbers in an array
This applies to all arithmetic functions, arrays of all sizes and ranks, and numbers of all datatypes.

Hexagony, 9 bytes
?{?/*!@'/

Try it online!
This is actually fairly straightforward. Here is the unfolded version:
  ? { ?
 / * ! @
' / . . .
 . . . .
  . . .

The / just redirect the control flow to the second line to save bytes on the third. That reduces the code to this linear program:
?{?'*!@

This linear code on its own would actually be a valid solution if the input was limited to strictly positive numbers, but due to the possibility of non-positive results, this isn't guaranteed to terminate.
The program makes use of three memory edges in a Y-shape:
A   B
 \ /
  |
  C

The memory pointer starts on edge A pointing towards the centre.
?   Read first input into edge A.
{   Move forward to edge B.
?   Read second input into edge B.
'   Move backward to edge C.
*   Multiply edges A and B and store the result in C.
!   Print the result.
@   Terminate the program.

I ran a brute force search for 7-byte solutions (i.e. those that fit into side-length 2), and if I didn't make a mistake (or there's a busy-beaver-y solution that takes a long time to complete, which I doubt) then a 7-byte solution doesn't exist. There might be an 8-byte solution (e.g. by reusing the ? or using only one redirection command instead of two /), but that's beyond what my brute force search can do, and I haven't found one by hand yet.

R, 3 bytes
'*'

This is a function which takes exactly two arguments. Run as '*'(a,b).
See also prod which does the same thing but can take an arbitrary number of arguments.

Is this a valid expression in its own right? If not, it needs to be submitted as '*'.

@ais523 Ah, you're right, it's not a valid expression on its own. I've edited the post to clarify. Thanks!

To the downvoters: This has been fixed.

ArnoldC, 152 bytes
HEY CHRISTMAS TREE c
YOU SET US UP 0
GET TO THE CHOPPER c
HERE IS MY INVITATION a
YOU'RE FIRED b
ENOUGH TALK
TALK TO THE HAND c
YOU HAVE BEEN TERMINATED

Try it online!

+1 ENOUGH TALK (newline) TALK TO THE HAND

Piet, 16 bytes
5bpiaibpikibptai

Online interpreter available here.
Explanation
To run, paste the code above in the text box on the right side of the linked page. Below is a graphical representation of this code with codel size 31. The grid is for readability and may interfere with traditional Piet interpreters.
The code runs linearly from left to right, going along the top of the image until the first green block, where program flow moves to the middle row of codels. The white lone white codel is necessary for program flow. It could be replaced with a codel of any color other than green or dark blue, but I have chosen white for readability.

Instruction    Δ Hue    Δ Lightness    Stack
-----------    -----    -----------    -----
In (Number)    4        2              m
In (Number)    4        2              n, m
Multiply       1        2              m*n
Out (Number)   5        1              [Empty]
[Exit]         [N/A]    [N/A]          [Empty]

If you think that text is not the best way to represent a Piet program or have an issue with the byte size of Piet programs in general, please let your opinion be known in the discussion on meta.

BitCycle -U, 68 bytes
  >    > v
 ?+ >  +
Bv ?^ v ~
 \  v<CB~\v
 Cv  ^  <\/
^ <@=!   <
0A^

Try it online!
Multiplying two numbers is not a trivial problem in BitCycle, especially when signs need to be handled! This is my second attempt; the first one (essentially same algorithm, different layout) was 81 bytes, so it's quite possible this one could be shortened too.
The program takes the two numbers as command-line arguments and outputs to stdout. The -U flag is to convert the decimal numbers to signed unary, since BitCycle knows only of 0's and 1's.
Explanation
This explanation assumes you understand the basics of BitCycle (see Esolangs or the GitHub readme). I'll base my explanation on this ungolfed version, seen here computing -2 times 3:

Overview
Signed unary numbers consist of the sign (0 for nonpositive, empty for positive) followed by the magnitude (a number of 1s equal to the number's absolute value). To multiply two of them, we need to XOR the signs (output a 0 if exactly one of them is 0, or nothing if both or neither are) and then multiply the magnitudes (and output that many 1s). We'll achieve the multiplication by repeated addition.
Sign bits
Starting from the two sources ?, we split off the signs from the magnitudes using +. 0s (sign bits) turn left and are directed along the top row, while 1s (magnitudes) turn right and end up in the two B collectors.
The section that handles the signs looks like this:
  v

  \  v
> \  /

! <

If both numbers are nonpositive, two 0 bits come in from the top v. The first one reflects off the top \, is sent southward, and reflects off the /. Meanwhile, the second bit passes through the deactivated top \ and reflects off the bottom \. The two bits pass each other, go straight through the now-deactivated splitters on the bottom row, and go off the playfield.
If only one of the numbers is nonpositive, one 0 comes in from the top. It bounces around all three splitters and ends up going northward again, until it hits the v and is once more sent south. This time, it passes through the deactivated splitters and reaches the <, which sends it into the sink !.
Loops to store the magnitudes
The magnitude of the first number goes into the B collector in this section:
B v
  \
  C v
^   <

0 A ^

Before the B collector opens, the A collector releases the single 0 that was placed in it, which then goes onto the end of the queue in B. We'll use it as a flag value to terminate the loop when all the 1 bits in B are gone.
Each time the B collectors open, the \ splitter peels off the first bit from the queue and sends it to the processing logic in the middle. The rest of the bits go into C, and when the C collectors open, they are sent back into B.
The magnitude of the second number goes into the B collector in this section:
v   ~
C B ~
    <

When the B collectors open, the bits go into the bottom dupneg ~. The original 1 bits turn right and are sent west into the processing logic in the middle. The negated copies (0s) turn left and immediately hit another dupneg. Here the 0s turn right and go off the playfield, while the (now doubly) negated 1s turn left and are sent into C. When C opens, they go back into B.
Repeated addition
The central processing logic is this part:
   v
   v

@  =  !

Bits from both loops (one from the western side, and everything from the eastern side) are sent south into the switch =. The timing has to be set up so that the bit from the western loop gets there first. If it is a 1, the switch changes to }, sending the following bits eastward into the sink ! to be output. Once all the 1s are gone, we get the 0, which changes the switch to {. This sends the following bits into the @, which terminates the program. In short, we output the (unary) magnitude of the second number as many times as there are 1s in the (unary) magnitude of the first number.

MATLAB, 5 4 bytes
@dot

dot takes the dot product of two vectors of equal length. If we feed it with two scalars, it will simply multiply the two numbers.
prod takes the product of the values in all rows of each column of a matrix. If the matrix is one-dimensional (i.e. a vector), then it acts along the non-singleton dimension, taking the product of all elements in the vector.
dot is one byte shorter than prod which is one byte shorter than the even more obvious builtin times.
Call it as such:
@dot
ans(3,4)
ans =
   12

Java 8, 10 9 bytes
a->b->a*b

Try it here.
Java 7, 31 bytes
int c(int a,int b){return a*b;}

Try it here.
As full program (99 90 bytes):
interface M{static void main(String[]a){System.out.print(new Long(a[0])*new Long(a[1]));}}

Try it here.

There's a typo in you full program, should be * instaed of +.

You don't need parenthesis around a,b in the lambda expression.

Python 3, 11 bytes
int.__mul__

Try it online!
Also works for integers under 2**32 in Python 2.

TI-Basic, 2 bytes
Very straightforward.
prod(Ans

Ans is not an allowed I/O method.

According to who? That link shows seven votes

@Timtech it wasn't at the time of the comment but it was posted in chat so just became valid

Alright, thanks for the tip @muddyfish

Intel 8080 machine code, MITS Altair 8800, 28 bytes
This implements binary multiplication on the Intel 8080 CPU (c. 1974) which did not have multiplication or division instructions.  Inputs are 8-bit values and the product is a 16-bit value returned in the BC register pair.
Here is the machine code along with step-by-step instructions to load the program into an Altair 8800 using the front panel switches.
Step    Switches 0-7    Control Switch  Instruction Comment
1                       RESET
2       00 001 110      DEPOSIT         MVI  C, 5   Load multiplier into C
3       00 000 101      DEPOSIT NEXT                value is 5
4       00 010 110      DEPOSIT NEXT    MVI  D, 16  Load multiplicand into D
5       00 010 000      DEPOSIT NEXT                value is 16
6       00 000 110      DEPOSIT NEXT    MVI  B, 0   clear B register (high byte of result)
7       00 000 000      DEPOSIT NEXT
8       00 011 110      DEPOSIT NEXT    MVI  E, 9   set loop counter E multiplier size
9       00 001 001      DEPOSIT NEXT                (8 bits + 1 since loop ends in middle)
10      01 111 001      DEPOSIT NEXT    MOV  A, C   move multiplier into A for shift
11      00 011 111      DEPOSIT NEXT    RAR         shift right-most bit to CF
12      01 001 111      DEPOSIT NEXT    MOV  C, A   move back into C
13      00 011 101      DEPOSIT NEXT    DCR  E      decrement loop counter
14      11 001 010      DEPOSIT NEXT    JZ   19 00  loop until E=0, then go to step 27
15      00 011 001      DEPOSIT NEXT
16      00 000 000      DEPOSIT NEXT
17      01 111 000      DEPOSIT NEXT    MOV  A, B   move sum high byte into A
18      11 010 010      DEPOSIT NEXT    JNC  14 00  add if right-most bit of
19      00 010 100      DEPOSIT NEXT                multiplier is 1, else go to 22
20      00 000 000      DEPOSIT NEXT
21      10 000 010      DEPOSIT NEXT    ADD  D      add shifted sums
22      00 011 111      DEPOSIT NEXT    RAR         shift right new multiplier/sum
23      01 000 111      DEPOSIT NEXT    MOV  B, A   move back into B
24      11 000 011      DEPOSIT NEXT    JMP  08 00  go to step 10
25      00 001 000      DEPOSIT NEXT
26      00 000 000      DEPOSIT NEXT
27      11 010 011      DEPOSIT NEXT    OUT  255    display contents of A on data panel
28      11 111 111      DEPOSIT NEXT
30      01 110 110      DEPOSIT NEXT    HLT         Halt CPU
31                      RESET                       Reset program counter to beginning
32                      RUN
33                      STOP

Try it online!
If you've entered it all correctly, on the machine state drawer in the simulator your RAM contents will look like:
0000    0e 05 16 10 06 00 1e 09 79 1f 4f 1d ca 19 00 78
0010    d2 14 00 82 1f 47 c3 08 00 d3 ff 76

Input
Multiplier in C register, and multiplicand into D.  The stock Altair has no STDIN so input is by front panel switches only.
Output
The result is displayed on the D7-D0 lights (top right row) in binary.
5 x 16 = 80 (0101 0000)

4 x 5 = 20 (0001 0100)

7 x 9 = 63 (0011 1111)

8 x -9 = -72 (1011 1000)

Compatibility note: this should also run on the IMSAI 8080, though currently untested.

Pyth, 2 bytes
*E

Try it here!
Pyth's automatic evaluation gets in the way here. To get around it, I'm using explicit evaluation for one of the arguments

Wow, that's nice. This will be handy in future.

PHP, 21 bytes
<?=$argv[1]*$argv[2];

takes input from command line arguments. Also works with floats.

Retina, 39 35 bytes
Thanks to Leo for letting me use an idea of his that ended up saving 4 bytes.
[^-]

*\)`--

.+
$*
\G1
_
_|1+
$'
1

Input is linefeed-separated.
Try it online! (Space-separated test suite for convenience.)
Explanation
The first two stages print a minus sign if exactly one of the two inputs is negative. They do this without actually changing the input. This is done by grouping them in the second stage with ) and turning them into a dry-run with *. The \ option on the second stage prevents printing a trailing linefeed.
[^-]

First, we remove everything except the minus signs.
*\)`--

Then we cancel the minus signs if there are two of them left.
.+
$*

Now we convert each line to the unary representation of its absolute value. This will get rid of the minus sign because $* only looks for the first non-negative number in the match (i.e. it doesn't know about minus signs and ignores them).
\G1
_

The first line is converted to _, by matching individual 1s as long as their adjacent to the previous match (hence, we can't match the 1s on the second line, because the linefeed breaks this chain).
_|1+
$'

This performs the actual multiplication. We replace each _ (on the first line) as well as the entire second line everything after that match. The _ matches will therefore include the entire second line (multiplying it by the number of 0s in the first line), and the second line will be removed because there is nothing after that match. Of course the result will also include some junk in the form of _s and linefeeds, but that won't matter.
1

We finish by simply counting the number of 1s in the result.

PigeonScript, 1 byte
*

Explanation:
* looks to the stack to see if there is anything there. If not, it prompts for input and multiplies the inputs together

This should be added here instead

Perl 6, 4 bytes
&[*]

This is just the ordinary infix multiplication operator *, expressed as an ordinary function.  As a bonus, if given one number it returns that number, and if given no numbers it returns 1, the multiplicative identity.

Alternative 4 UTF-8 byte solution: *×*

Owk, 11 bytes
λx.λy.x*y

This can be assigned to a function like this:
multiply:λx.λy.x*y

and called like this:
result<multiply(a,b)

Does this not work? Please explain the doe vote.

I wasn't the downvoter, but I think I can guess what happened: this is a very trivial question (and thus very heavily downvoted, but with many upvotes cancelling that out), and likely to attract people who downvote trivial questions. This answer's also fairly trivial, and it's likely that some of the people who downvote trivial questions also like to downvote trivial answers. (Personally, I prefer to leave trivial answers at 0, so I'm not voting either way on this one.)

><>, 5 Bytes
i|;n*

Takes input as an ascii character, outputs a number.
Explanation:
i                        | Get input.
 |                       | Mirror: Change the pointer's direction.
i                        | Get input again.
    *                    | Loop around to the right side. Multiply
   n                     | Print the value on the stack, as a number
  ;                      | End the program

You could also do
ii*n;

But I feel my solution is waaay cooler.
Another possibility is dropping the semicolon, which would result in the pointer bouncing off the mirror, hitting the print command, and throwing an error since the stack is empty.

BitCycle, 33 bytes
 >>\/v
?+ \/
? +~!/
 A + =
  ~BC^

Try it online!
This takes input via command line args, with the -U flag to convert it into signed unary.
This only uses one pair of collectors in the main loop by representing the first number with unary 0s and the other number with 1s, allowing us to store both in the same collector.
Explanation:
No fancy gifs sorry. This also assumes you have at least a passing familiarity with BitCycle.
?+       Get both numbers as signed unary from the ? sources
? +      Sends 0s upwards (0s signify that the number is negative), and 1s downwards

  >>\/v  Given either 0, 1 or 2 zeroes
  + \/
   + !/  Push a 0 (signifying negative) if there is exactly one 0

 +      Push the first number as unary 1s to collector A
  +     Push the second number as unary 0s to collector B
 A +    Then push the first number into collector B
  ~BC   Then push both into collector C

     /    If the first bit out of collector C is 0
   + =    Turn the = into { and discard the first bit
   BC^    All the 0s go back to collector B, and the 1s go up

  +~!     Duplicate and print all the 1s
   +      Push the duplicates back into B
  ~B

This loops until it runs out of 0s in the collector, then the = turns into a } and discards the rest of the 1 bits.

C#, 10 bytes
a=>b=>a*b;

It's just a simply multiplication.

You beat me to it!

How does the => => work? I'd expect (a,b)=>a*b;

@Carra It works, that this lambda expression returns a delegate, which returns the result, so you call it this way, if you call this lambda f:f(a)(b).

This would be a form of function currying

Jelly, 1 byte
×

Try it online!
Obligatory Jelly submission.

Haskell, 3 bytes
(*)

Call it as a function: (*) a b
or as an operator: a * b .

Our standard is to require (*) so that the expression evaluates to a function and can be stored.

@xnor I'm not sure, but I think if there is a built-in command, then it seems that just writing that down is enough. (At least when looking at other challenges/submissions.)

@flawr It's difficult to score this, to assign it to a new name, you need to add parenthesis, but it can be called as a*b without.

According to the definition I gave on Meta, which seems well-received at the moment, this sort of function definition must be an expression that evaluates to a value of function type. * is not an expression in Haskell. (*) is.

Proton Polyglot :P

Clojure, 1 byte
*

:P As a bonus this works on any number of arguments:
[(*)
 (* 2)
 (* 2 3)
 (* 2 3 4)
 (* 2 3 4 5)] => [1 2 6 24 120]

Interestingly you can easily get its source code:
(source *)
(defn *
  "Returns the product of nums. (*) returns 1. Does not auto-promote
  longs, will throw on overflow. See also: *'"
  {:inline (nary-inline 'multiply 'unchecked_multiply)
   :inline-arities >1?
   :added "1.2"}
  ([] 1)
  ([x] (cast Number x))
  ([x y] (. clojure.lang.Numbers (multiply x y)))
  ([x y & more]
     (reduce1 * (* x y) more)))

C# - 11 bytes
(a,b)=>a*b;

Anonymous lambda.

LOLCODE, 95 bytes
HAI 1.3
I HAS A J
GIMMEH J
I HAS A Q
GIMMEH Q
I HAS A T
T R PRODUKT OF J AN Q
VISIBLE T
KTHXBYE

Try it online!

In Floop, 70 bytes, pos. only
r+s[r-]r[-n?o?s+]r+s-[@[-r-n+]r[s-o-[r-]r[-@;]]]r[n[-r@+r-@+]r[-s+]]s+

I wrote this in three parts:

Outer part: r+s[r-]r[-n?o?s+]r+s-[A]r[B]s+ (based off of my add-two-numbers program)
A: @[-r-n+]r[s-o-[r-]r[-@;]] (copies @1 to n, 1 at a time)
B: n[-r@+r-@+]r[-s+] (copies n to @1 and adds it to @1, 1 at a time)

This forms a loop, until o- is 0 after A runs. Then, @0 is printed.
Try It Online!

Try It Online?

Labyrinth, 5 bytes
??*!@

Try it online!
Input format can be almost anything (this simply multiplies the first two decimal integers it finds in the input).

05AB1E, 1 byte
*

Try it online!

@downvoter: This is a built-in answer, and the convention is not to upvote them too much. But you should not downvote a perfectly valid answer either.

Upvoted it to make up for whoever downvoted

@Metoniem I think that upvoting just because you feel sorry isn't recommended though.

Japt, 1 byte
×

Here is a non-1 byte solution
U*V

Run it here

× was added before this challenge was posted (at 13:37 UTC on 7 Jan 2016), so this answer is actually competing

Did I say 2016? Gosh, I really need to get used to this whole "2017" thing :P

FOG, 3 bytes
^^*

Takes input twice and multiplies.  I can also just use * and call it a function, but for the sake of uniqueness I decided not to.

CJam, 3 bytes
{*}

Try it online!

SimpleTemplate, 59 bytes
Since this language doesn't have math (yet), it requires a loop and an increment, to generate the result.
{@setx 0}{@for_ from1 toargv.0}{@incbyargv.1 x}{@/}{@echox}

Ungolfed, with whitespace:
{@set prod 0}
{@for _ from 1 to argv.0}
    {@inc by argv.1 prod}
{@/}
{@echo prod}

This answer was written to run on the commit 2166e6bdac44064ec5594d511528d1469ea3feef from 2017-01-07.
On the latest version (commit 9857e4277536555d0b06e8ef9c00ba0c7f23cf6d), one could do like this (50 bytes):
{@for_ from1 toargv.0}{@incbyargv.1 x}{@/}{@echox}

This will show a warning saying that the index 'x' doesn't exist.

With a new update (commit 552216290ec0d8cb9893e08d89601c4d67fcc3d1), the code can be written as (21 bytes):
{@set*_ argv}{@echo_}

Math++, 3 bytes
?*?

(Why is there a 30 character minimum?)

To avoid spam...

@Mendeleev: I bet almost all existing spam existing has more than 30 chars, so the limitation is pointless and ineffective .

C#, 112 63 bytes
Saved 49 bytes, thanks to milk
a=>b=>{int r=0,i=0,k=0b=>{int r=0,i=0,k=0<b?1:-1;for(;i!=b;i+=k)r+=a;return r*k;};

Loader, 124 bytes
~A:set B =@IN
~A:set A =@IN
B:~C:decr B
~C:set C =A
C:incr D
C:decr C
set G =0
B:incr G
C:incr G
G:load m
~B:print D
~B:exit

Run from m.ldr, or alternatively replace the m in the third line from the end with the name of the file.

√ å ı ¥ ® Ï Ø ¿, 4 bytes
II*o

Almost identical to my answer for the Add two numbers question.
Explanation
I    › Take input from the command line, evaluate and push to stack
 I   › Take another input
  *  › Times the two values together and push to stack
   o › Output the first value on the stack

Cubix, 6 bytes
OI|u*@

This is a slightly different algorithm than the "Add Two Numbers" Cubix solution. It would have been trivial to simply use that solution with a * instead of a + but the flow here is slightly different.
On a cube:
  O
I | u *
  @

rather than using the control flow \ or / and then duplicating I to read in the inputs, I opted to use | to pass over the I twice instead, which forced me to use u to get to the output commands.
The commands are:

I : read in input
| : reflect IP left-right
I : read in input
* : multiply
u : do a right-hand u-turn (i.e., two right turns)
O : output as a number. the IP is now facing North, and has a right turn to make, which takes it to
* : multiply the top two numbers (essentially a no-op)
@ : terminate program.

Similarly to the addition solution, the cube's symmetry allows the following solution.
  @
I | U *
  O

Additionally, replacing | with < or T will work as well.
Try it online!

x86_64 machine language (Linux), 5 4 bytes
0:       97                      xchg   %edi,%eax
1:       f7 ee                   imul   %esi
3:       c3                      retq

To Try it online!, compile and run the following C program.
#include<stdio.h>

int f(int a,int b){return a*b;}
const char g[]="\x97\xf7\xee\xc3";

int main(){
  for( int i = 0; i < 10; i++ ) {
    for( int j = 0; j < 10; j++ ) {
      printf( "%d %d %d %d\n", i, j, f(i,j), ((int(*)())g)(i,j) );
    }
  }
}

JavaScript (Node.js), 39 36 bytes
-3 bytes thanks to @MartinEnder
f=(a,b)=>b?b>0?a+f(a,b-1):-f(a,-b):0

Try it online!
This is me having fun , it won't win any competitions but it uses recursion and doesn't use the * operator.
Explanation :
f = (a,b) => {
    if (b == 0) {
        return 0;
    }
    if (b > 0) {
        return(a + f(a , b-1))
    }
    else {
        return(-f(a , -b))
    }
};

Cool. Voted up. Very interesting answer

You can save three bytes by dropping ==0 and swapping the true and false branches of the outer ternary: https://tio.run/##Zc7RCoIwGAXg@55il265@P8JhYL6LJtpFOIko9df/ScK0qudwz52dvNPv3T36/ywUzz3KQ115vOg6ya0oaHW7wfplnVlJdmgK0pdnJY49ocxXrIhY5UrJtJyKIO4@xeOCUaIZEFrw44Y1wUekmbQVq5kuPIkDMVI2SwW7PAxd/ysohv0lbXsxGH3nYE2s/Qj9AXpBQ

@MartinEnder : Oh yeah, nice idea thanks

also 36 bytes: no addition

International Phonetic Esoteric Language, 4 bytes (WIP language) (OLD)
ɪɪθo

No TIO interpreter yet, but is runnable by cloning the repository above, and calling python3 main.py "code here".
ɪɪθo
ɪ    ; push int
 ɪ   ; push int
  θ  ; pop, pop, push a * b
   o ; pop, print

Intcode, 22 bytes
3,0,3,1,2,0,1,2,4,2,99

Fairly basic. IO boilerplate takes up most of the bytecount, given that the language has multiplication as a builtin (2,0,1,2 would be a valid answer, if snippets were allowed)

Brainetry, 257 bytes
Golfed version. A more interesting submission follows.
a b c d e f
a b c
a b c d e f
a b
a b c d e f g h
a b c d e
a b c
a b c d e f g h
a b c d e
a b c
a b c d
a b c
a b c d
a b
a b
a b c d e f g h i

a b c d e f g h
a b c d e
a b
a b
a b c d
a b c
a b c
a b c d e f g h i
a
a b c d e f g h i

a b
a b c d e f g

To try this online, follow this repl.it link, paste the code in the btry/replit.btry file and press the green "Run" button.
Ungolfed version:
This is probably my first Brainetry
program that makes
non trivial use of some of
my new
experimental operators that I introduced, expanding the base
brainfuck implementation this is built
upon. We will
see if this made any difference or not.
This program works in a
rather simple way.
First I read inputs.
Then I have
to nest two loops.
One loop,
two loops.
The two loops will be nested, which is nice.

One loop will have me decrement one of
the user inputs, then I
move left,
(not right)
and successively decrement the
cell I'm at.
I do this
and keep accumulating in another cell. If I loop
with
enough dedication, the final result will be stored someplace.

Legend says,
the correct place is the second cell.

lol, the ungolfed program is self-explanatory.

@Memberfor3months yes it is :)

Foam, 10 bytes
;# ;# * .#

Try it online!
I'm gonna be using this lang for the next few weeks
;# returns an integer from input.
* is...multiplication.
.# is output.

LOLCODE, 77 bytes
HAI 1
I HAS A a
I HAS A b
GIMMEH a
GIMMEH b
VISIBLE PRODUKT OF a AN b
KTHXBYE

I has a bettr answar cuz I used PRODUKT OF a AN b in da VISIBLE direktly instaed of in an variable !!1!
Try it Online!

Gramaer misteak on porpose !1!!

Piet, 10 9 codels

Original image
The 2 white codels on the side can be replaced with any color. Most straightforward solution, literally "read 2 numbers, multiply, output", I really don't know why this answer is more complicated.
Update: saved 1 codel by switching from a 2x5 to a 3x3 grid

@DLosc Did you forget the 2 white pixels at the bottom? Works fine with https://gabriellesc.github.io/piet/

Edited the image to clarify

I'm thinking MasterPiet acts as if the whole PNG is surrounded by black codels

I apologize, I was wrong about white blocks. The Esolangs article doesn't describe them properly, and I hadn't read the actual spec in a while. My guess now is that perhaps Npiet treats white blocks correctly except that it doesn't do the "exit if infinite loop" part.

@DLosc Apology accepted :)

rusty_deque, 2 bytes
Two variants: one for the left of the deque, one for the right of the deque.
*! # left
*~ # right

QBIC, 13 bytes
::[a|p=p+b}?p

Adapted my code from 'add two numbers'. This starts a loop and adds 'y' to itself 'x' times.
But seriously, a 6-byte solution is ::?a*b. : gets a cmd line parameter and class it 'a', the next : does the same for 'b', 'cause 'a' is already taken. * multiplies, and ? prints the result. This is virtually identical to this answer, only the operator is different.

Since some time now, QBIC can in-line the 'get var from cmd line'-command, and the above would be ?:*:, at 4 bytes.

Python 2, 14 bytes
lambda a,b:a*b

Try it online!
I feel like this is too much shorter than from operator import*;mul.

Why the downvote? This is a perfectly valid submission.

int.__mul__ would also be valid, but that's already posted.

@TuukkaX Duplicate answers are allowed, but I don't want to dupe an answer I have seen in the past purposefully.

Pyth, 4 bytes
M*GH

Defines a function named g, can call it in this way - gn1 n2, where n1 and n2 are the numbers.
Try it here!
Previous solutions using 5 bytes.
*.).Q and *hQeQ.

OCaml, 4 bytes
( *)

The space after the first parenthesis is needed because (* starts a comment in OCaml.
Try it online!

Scala, 2 bytes
_*

This is a curried lambda / anonymous function. To use it, assign it to a variable:
val f:(Int=>Int=>Int)=_*
f(7)(9)                   //returns 63

How it works:
In Scala, the underscore can be used as a shorthand for the arguments.
_*_, for example, is syntactic sugar for (a,b)=>a*b.
Removing the second underscore is treating the method * of the first argument as a function, results in a curried function that multiplies its arguments.

Pushy, 2 bytes
*#

Try it online!
As you might have guessed, * is the multiplication operator, and # prints the result.

You might be able to remove the the last byte? I don't think output means it has to be printend :o

dc, 3
?*p

Try it online (wrapped in a shell script to run all given tests).
Note dc thinks underscores (_) are -ve signs.

Befunge-93, 5 bytes
&&*.@

Try it online!
&& gets two integers and pushes them to the stack; * multiplies them (duh); . prints the numeric value of the top of the stack, and @ ends the program.

Emacs Lisp, 3 bytes
This is just a function.
(*)

Usage:
(* num1 num2)

Noodel, noncompeting 1 byte
Did not have a full complete version of Noodel until after this challenge, and did not even have multiplication with a single character until recently.
×

Try it:)
How it works
  # Input is implicitly pushed onto the stack with the first element (a) pushed first and the second last (b) making it the top.
× # Pops off two items producing => (b * a) and pushes on the result.
  # The top of the stack is popped off at the end of the program and pushed to stdout.

Microscript, 4 bytes
isi*

Microscript II, also 4 bytes
FsF*

Swift 3, 40 bytes
func f(_ a:Int,_ b:Int)->Int{return a*b}

Takes two parameter, return the two Ints multiplied. Called like this:
f(2, 4)

You can also use a closure {$0*$1} and use it like this let res = {$0 * $1} (2,4) //8

C (gcc), 98 bytes
m(i,j){i=(i&j)<0?m(O(~i,1),-j):i?O(m(i>>1,O(j,j)),i&1?j:0):0;}O(i,j){i^=j,j&=i^j;i=j?O(i,j<<1):i;}

I don't think I have much of a chance against the other entries.
Try it online!

Suggest replacing i>>1 with i/2 :)

C, 56 bytes
main(int i,char**a){printf("%d",atoi(*++a)*atoi(*++a));}

compile
> gcc source.c

usage
> a 8 7

or
> ./a.out 8 7

explanation
main(int i,char**a) {  /* Begin program and accept command-line arguments.    */
   printf("%d",        /* First argument prints the (final) decimal result.   */
         atoi(*++a)    /* Returns int of program's 2nd command-line argument. */
         *             /* Multiplies the values of the 1st & 2nd arguments.   */
         atoi(*++a)    /* Returns int of program's 1st command-line argument. */
   );
}

Request: Don't put the byte count far away from the language and use a code block for the explanation.

@CalculatorFeline Why?

Well, I guess the byte count formatting is okay, but the explanation looks really weird.

That's my style (for the moment)!  If you don't like it then please offer me something more than really weird -- Thanks for the feedback.

Your formatting is all over the place on my phone. Also, I'm sorry, but I just don't get why you'd include an explanation at all if you're not going to make it readable.

@Dennis  O, it's readable, just not pretty on your device.  Edited for your (mobile) enjoyment.

Taxi, 442 bytes
Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to The Babelfishery.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:w 1 l 1 r.Pickup a passenger going to Multiplication Station.Pickup a passenger going to Multiplication Station.Go to Multiplication Station:n 1 r 2 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 r 1 l.Pickup a passenger going to Post Office.Go to Post Office:e 1 l 1 r.

Formatted with line breaks for legibility:
Go to Post Office:w 1 l 1 r 1 l.
Pickup a passenger going to The Babelfishery.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:w 1 l 1 r.
Pickup a passenger going to Multiplication Station.
Pickup a passenger going to Multiplication Station.
Go to Multiplication Station:n 1 r 2 l.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:s 1 r 1 l.
Pickup a passenger going to Post Office.
Go to Post Office:e 1 l 1 r.

I take pride in being last place on this challenge.

ZX80 BASIC ~39 bytes
 1 INPUT A
 2 INPUT B
 3 PRINT A;"X";B;"=";A*B

This program is so simple that it will very likely work on all variants on 8-bit BASIC. However, on the ZX80 (4K ROM) you are limited to integer maths with a signed 16-bit range; so if your answer is >32767 then it will error and you will not see a result.
To remedy this, install a new ROM onto your Sinclair ZX80 to allow 24-bit floating point maths, or upgrade to a Sinclair ZX81.
Save bytes by refactoring line 3 to:
 3 PRINT A*B

Alice, 7 6 bytes
*/
o@i

Try it online!
Follows the same pattern as my solution for addition.

Jellyfish, 6 bytes
P*i
 i

Try it online!
P denotes print, then * multiplies the two numbers below and to the right.
At the start of execution, the two is are replaced with values from STDIN.

Lean Mean Bean Machine, 12 bytes
OO
ii
 /
*
u

Whitespace, 4 bytes

In some other languages, you could quote that as "\t  \n".  Expects two numbers on the stack and leaves the result on the stack.
As a complete program reading from standard input and writing to standard output, it would be 36 bytes:

Try it online!

I know it's been quite a while, but you can golf 1 byte in the full program. Instead of Push_0, Duplicate, STDIN_as_integer, Retrieve for the second input, you can use Duplicate, Duplicate, STDIN_as_integer, Retrieve. Duplicate (SNS) is one byte shorter than Push_0 (SSSN). It will store the second input on the heap at the address of the first input (so if the first input is 3, it will store the second input (i.e. 5) in the heap at {3:5} instead of {0:5}).

Ignore my comment above. Apparently you cannot use an negative integer as heap-address, so it would fail if the first STDIN is negative.

@KevinCruijssen Interesting try, though. And I wouldn't be surprised if at least one existing Whitespace interpreter does allow negative heap addresses...

Perl 5, 7 bytes
6 bytes of code + 1 for -p flag
$_*=<>

Try it online!

Go, 84 bytes
package main
import."fmt"
func main(){a,b:=0,0;Scanf("%d%d",&a,&b);Printf("%d",a*b)}

Try it online!
Worth mentioning:

We import the fmt package to the global namespace by using import.. That way, we can refer to Scanf and Printf as global functions.
a and b are assigned to 0, as that is shorter than doing var a,b int.

Lua, 32 bytes
i=io.read
print(i("*n")*i("*n"))

Try it online!
Program reads 2 numbers from STDIN and prints the result to STDOUT.

"But shouldn't you use io.write?"
Well according to the documentation,

[...] write uses the current output file, whereas print always uses the standard output. Finally, print automatically applies tostring to its arguments, so it can also show tables, functions, and nil.

Go, 28 bytes
func(a,b int)int{return a*b}

Try it online!

Ruby, 10 bytes
:*.to_proc

Try it online!
I really thought this might be shorter...

->a,b{a*b} works too lol

Yeah, I thought I'd try something different. :P

C#, 27 bytes
delegate(a,b){return a*b;};

Welcome to PPCG! You can make this shorter with (a,b)=>a*b, or use currying to get a=>b=>a*b. However, someone has already posted this solution.

Aceto, 6 bytes
riri*p

ri grabs input and converts to integer
* multiplies them
p prints it
Try it online!

Also works in CJam, interestingly.

Forked, 5 bytes
$$*%&

Try it online!

$$ - read two integers
* - multiply top two stack values
% - print top of stack as integer
& - "terminate", prevent IP from wrapping

FRACTRAN, 22 bytes
78/55 5/3 1/5 11/2 5/7

Take 7^a*11^b as input, return 11^b*13^(a*b).
Try it online!
This is a golfed version of the wikipedia example.
I'm not sure whether or not extra bytes should be added for input encoding and output decoding.

Brainfuck, 76 bytes
Not the shortest but my own solution, written a long time ago.
Golfed
>[-]>[-]>[-]<<<<[->>>+<<<]>[->+>>+<<<]>[-<+>]>>[-<[-<+<<+>>>]<[->+<]>>]<<<<.

Explanation
x = x*y
(x)(y)(temp0)(xtemp)(ycount)
Own work! Convoluted solution

,               x
> +++           y=3 (or input)

>[-]>[-]>[-]    set cells to 0
<<<< [->>>+<<<] transfer x to xtemp
> [->+>>+<<<]   transfer y to temp0 and ycount
> [-<+>]        transfer temp0 to y
>>
[               while ycount != 0
 -               ycount decrement
 < [-<+<<+>>>]   transfer xtemp to x and temp0
 < [->+<]        transfer temp0 to xtemp
 >>
]

<<<< .          x (might overflow)

Flobnar, 4 bytes
&
*@

Try it online!

:| this is too golfy

Pepe, 19 bytes
rEeeREeerEEEEeEreEE

Try it online!
Input is a,b. Change the "Separated by" box into , to work.
Explanation:
rEeeREee            # take 2 inputs (not in the same stack)
        rEEEEeE     # A*B -> stack r
               reEE # output as number

Why is this non-competing?

@pppery Language postdates the challenge, but I'm removing it now.

Commodore BASIC v2 (C64, VIC-20 and some PET models), 27 tokenized BASIC bytes
This version uses the limited DEF FN keyword, See description here
 0 DEFFNA(B)=A*B:INPUTA,B:PRINTFNA(B)

Commodore BASIC v2, 14 tokenized BASIC bytes
 0 INPUTA,B:PRINTA*B

Both methods are likely compatible with all 8 BIT BASIC variants on Commodore home computers, but are not tested.

Bourne-shell-based langs all look pretty similar:
Zsh, 11 bytes
<<<$[$1*$2]

Bash, 13 bytes
echo $[$1*$2]

Dash/POSIX sh, 15 bytes
echo $(($1*$2))

$(( )) syntax also works for ksh93. The "fish" shell does its own thing, e.g. math "$1*$2"

GFortran, 51 27 bytes
Fulfils the rules, I suppose integer overflow error is to be expected.
-24 thanks to Ørjan Johansen
Try It Online!
read(*,*)i,j
print*,i*j
end

Seems you have some redundant stuff. (Unlike ab, ij default to integer.)

Thanks! It's been about 20 years since I wrote any real Fortran :P

3+ bytes in various methods of representing lambda calculus, taking numeral input as Church numerals.
19 Bytes, Untyped Lambda Calculus, using named arguments:
λx.λy.λz.x(y(z))

This is the most verbose version, . represents a lambda abstraction and parentheses represent an application
9 or 12 Bytes, Lambda Calculus, using De Brujin Indices:
λλλ3(2 1)

This uses De Brujin Indices instead of variable names, and function application is right-associative and implicit.
Replacing lambda symbols with backslashes (a pretty common form when Unicode is not available) yields us only 6 bytes
It's small, but we can go smaller. Using John Tromp's Binary Lambda Calculus representation, we get the binary representation 0000000111100111010, or separated into individual parts:
3 bytes, Untyped Lambda Calculus, using BLC representation
00 00 00 01 1110 01 110 10 xxxxx

Where the 5 xs are any padding bits.
Explanation
These implement the simple mult function for Church Numerals in the untyped lambda calculus.
In untyped lambda calculus, EVERYTHING is a function, including numbers. All these functions take a maximum of a single argument. So how do you represent arbitrary numbers? Church encodings!
In Church encoding, numbers are represented by repeated recursion. All numbers n are represented by a function taking an argument f, and returning a function taking an argument x, which returns f(x) called n times.
For example:
0: lambda f: lambda x: x
1 = lambda f: lambda x: f(x)
2 = lambda f: lambda x: f(f(x))
3 = lambda f: lambda x: f(f(f(x)))

Etc etc.
All inputs and outputs in most lambda calculus systems are in the form of church numerals.
The multiplication function takes 3 arguments and returns the first argument called on the second called on the third:
mult = lambda m: lambda n: lambda x: m(n(x))

This in lambda calculus simply multiplies the numbers m and n together.
Calling mult(2)(3) using our previous definitions of 2 and 3 results in a function:
lambda f: lambda x: f(f(f(f(f(f(x))))))

Or 6, the result of our multiplication. All the "golfs" are really just more concise ways of representing untyped lambda calculus.

brainfuck, 29 bytes
,<,[>[>+>+<<-]>[<+>-]<<-]>>>.

Try it online!
Input and output as character codes. (Example: 5*7=35)
Code:
[Tape: Y, X, temp, solution]
,<,             input X and Y
[               while Y greater than 0
  >[>+>+<<-]    add X to temp and solution
  >[<+>-]       move temp back to X
  <<-           decrement Y
]
>>>.            print solution

MashedPotatoes, 139 bytes
 synchronized($ARGV){
 case0.0fof{_->usestrictqw/++i/;goto*read-eval*;SETLOCAL<>}WHILEObject>STDERRs/0.0f//gWENDproc++i{`uniq-c`}{OUTPUT=<>}}

MashedPotatoes isn't on TIO, so I linked the Esolangs page for the language.  It's an unusual language, so the code description might not make much sense unless you scan the info about cyclical naming conventions on the Esolangs page first.  But here goes nonetheless...
I'm breaking the code into lines, but it has to be formatted as listed above to work, since the values of the labels is bound to the line number in the code.
synchronized($ARGV){              # Label block, assigns "1" to label 1
  case0.0fof{_->                  # Input block
    usestrictqw/++i/;             # Read first number into register ^A
    goto*read-eval*;              # Shift registers, ^A<-^C<-^E-<^A
    SETLOCAL<>                    # Read second number into register ^A
  }                               # Close input block
  WHILEObject>STDERRs/0.0f//gWEND # Multiply ^A*^E and store in ^E
  proc++i{`uniq-c`}{OUTPUT=<>}    # Print ^E as a number
}                                 # Close label block

Starry, 6 bytes
,,  *.
,,      Push input to stack (twice)
    *   Multiply
     .  Output

A0A0, 28 bytes
I0A1V0O0
I0V0M0
G-2G-1G-1G-1

Adapted from my answer to Add two numbers.
Each number is first put into two separate operands (V0 instructions) on two lines via the I0 instructions on each line and then later combined together for adding. After taking input, we jump to the top. The A1 adds the V0 O0 onto the next line, to get the following code: V2 M0 V1 O0. I've labelled the operands with V1 and V2 to represent the different operands. During execution these contain the actual inputs. From there it's simple.
V2 M0 V1 O0
V2          ; operand, put into the S0 next to it
   M0       ; multiplies its value to the operand next to it (V1)
      V1    ; operand, put into the O0 next to it
         O0 ; outputs its value as a number

The line of jumps at the bottom just goes back to the correct line each time.

Factor, 1 byte
*

Try it online!

Piet + ascii-piet, 7 bytes (5×2=10 codels)
TAJsJjj

Try Piet online!

Z80 machine code, 5 4 bytes with djnz
In Machine Language:
81 10 fd c9

In Assembly:
;8-bit Multiply
;Multiplier in B, multiplicand in C, result in A.
Multiply:
    loop:
        add a, c
        djnz loop
    ret

What is djnz?
djnz decrements the B register (in this case the multiplier), and jumps a certain number of bytes forward or back (in this case, 2 bytes back; essentially jumping to the beginning of the loop), but only if, after being decremented, the B register isn't 0.
Some limitations
This subroutine can only perform 8-bit multiplication, so the result will overflow if it exceeds 0xff.
I believe I have no way of making it do 16-bit multiplication without increasing the byte count.
Without djnz
Here's the code before I added djnz:
In Machine Language:
81 05 20 fc c9

In Assembly:
;8-bit Multiply
;Multiplier in B, multiplicand in C, result in A.
Multiply:
    loop:
        add a, c
        inc b
        jr nz, loop
    ret

Testing
I used this snippet of code to test my submission:
ld c,4
ld b,10
call Multiply
ld ($1000),a

shell, 14 bytes
dc -e"$1 $2*p"

awk, 13 bytes
Simply
{print $1*$2}

Swift, 25 24 20 bytes
let t:(_,_)->Int=(*)

Groovy, 10 bytes
{x,y->x*y}

This is an unnamed closure.
Try it here!

Ruby, 10 bytes
->a,b{a*b}

Answer is two characters too short without this text apparently.

Excel VBA, 8 Bytes
Takes input from cells A1 and B1 and outputs to the VBA immediates window
?[A1*B1]

which is functionally equivalant to
Print ActiveSheet.Range("A1").Value * ActiveSheet.Range("B1").Value

Batch, 57 bytes
set "a1=%1" && set "a2=%2" && set x=%a1%*%a2% && echo %x%

&&: execute another command.
First command: Set %a1% as the first argument
Second command: Set %a2% as the second argument
Third command: Set %x% as %a1% * %a2%.
Fourth command: Type in the value of %x%.

SmileBASIC, 13 bytes
INPUT A,B?A*B

Input should be given as two numbers, separated by a comma.

ForceLang, 36 bytes
def n io.readnum()
io.write n.mult n

Another fun use of def.

Rust, 14
I haven't seen Rust quiet often so let's use it.
|a:u8,b:u8|a*b

This is a lambda expression that takes to 8 bit ints and multiplies them.

Forth, 1 bytes
*

* pops off the top 2 items from the stack, multiplies them and pushes the result.

You can just use *, since it's a word/function. I added it to this polyglot answer

Powershell, 17 Bytes
param($a,$b)$a*$b

takes 2 numbers, returns them multiplied out.

Röda 0.11, 11 bytes
f&a,b{a*=b}

Try it online!
It modifies its first argument (which must be a variable).
Röda 0.12, 7 bytes (non-competing)
{[_*_]}

Try it online!
This kind of syntax was not supported at the time the challenge was posted. It's an anonymous function that reads to numbers from the stream

><>, 3 + 3 = 6 bytes
*n;

Invoke as fish.py -c '*n;' -v 2 -8, which is why I only count the flag once.

QC 4 bytes
QQGN
Requires a newer version which must be compiled manually.
Q Read number from stdin and push to stack
Q Same as above
G Multiply two numbers from stack
N Pop and print number from stack

Maple, 3 bytes
`*`

Usage:
`*`(a,b);

Returns:
a*b

Using this notation, is it possible to supply any number of arguments to the multiplication operator and it will return the product of the sequence.

AHK, 15 bytes
1*=%2%
Send,%1%

1 and 2 are, by default, the first two arguments passed in to a program. Sometimes you have to escape them with percent signs so it doesn't confuse the variable 1 with the number one.

Casio Basic, 6 bytes
a*b

No surprises there. 3 bytes for the program, and 3 bytes to add a,b as parameters.

HEX, 69 bytes non-competing
GBL;
Listen("1");
Listen("2");
Breed("1" * "2");
Scuttle("1");
Write;

I have no idea when HEX was created, but I've listed this as non-competing as the language currently has no publicly-available functional interpreter.

... so how can it be tested?

@StewieGriffin Write your own interpreter ;)

On a more serious note, I'm working on finishing my HEX interpreter, and while it supports GBL, Listen, Breed, Scuttle and Write, so would work for this program, it's still missing most of HEX's features, so it's not public yet.

Braingolf, 1 byte
*

Try it online!
Implicit input, * multiplies the last 2 number on the stack and pushes the result, implicit output.
Here's a slightly more interesting one:
Braingolf, 9 bytes
<2->[.]&+

Try it online!
Implicit input of x and y. Subtracts 2 from x, (because [] is a do-while and we already have one y), then duplicates y x times, finally, sums the entire stack. Implicit output.

Decimal, 12 bytes
81D81D43D301

Reads two integers (separated by a space or newline), multiplies them, and prints them to STDOUT.
Ungolfed:
81D  ; builtin 1 - read INT to stack
81D  ; builtin 1 - read INT to stack
43D  ; math, multiply (postfix *)
301  ; print from stack to standard output

Try it online!

Triangular, 6 bytes
$.$%*<

Try it online!
Formats into this triangle;
  $
 . $
% * <

Without directionals/no-ops, this looks like: $$*%

$ - read input as integer
* - multiply
% - print as integer

Carrot, 5 bytes
$^F*$

Takes the input separated by newlines.
Explanation:
$ //Set the string stack to the first line of the input
^ //Change to operations mode
F //Convert to float stack
* //Multiply the stack by
$ //The second line of the input
  //Implicitly output the result

C, 48 bytes
main(a,b){scanf("%d%d",&a,&b);printf("%d",a*b);}

New to code golf, any suggestions are welcome.

cQuents, 6 bytes
#|1:AB

I really need to implement a byte that simply shorthands #|1: because every "perform this operation once" challenge uses that as the beginning.
Try it online!
Explanation
#|1      Add a 1 to the end of the user's input, it will be n
   :     Mode : (sequence 1: given n, output the nth item in the sequence)
    AB   Each item in the sequence is the first input times the second input

Cubically, 8 7 bytes
$:7$*7%

Explanation:
$        read input
 :7      set notepad to input
   $     read input
    *7   multiply notepad by input
      %  print result

Try it online!

Tcl, 10 bytes
expr $a*$b

Try it online!

If one states
namespace path tcl::mathop

before then *  acts like a procedure:
Tcl, 7 bytes
* $a $b

Try it online!

Implicit, 1 byte
*

Implicit input of two integers, multiply them, implicit output. Try it online!

[C64, BasicV2], 11 bytes
1rEA,B:?A*B

The input can be given like:
0dA45,45

0 INPUTA,B:?A*B Note that Commodore BASIC keyword abbreviations doesn't save BASIC bytes, only typing

@ShaunBebbers As far I know, it is opposite: Basic programs are stored in a tokenized form in the memory, thus even if you write the whole PRINT command, it will be stored as ?. It shows as PRINT only if you LIST it. But it is not very important, because the task is to minimize the code size, not the basic byte size.

Batch File, 23 bytes
@set/ak=%1*%2
@echo %k%

Batch doesn't allow you to print the result of an operation; Thus, we are required to create a temporary variable k which contains the result of the multiplication between argument 1 and 2.
The @'s in front of the commands prevent the current path from being printed before each line on the command prompt.

Falcon, 34 bytes
a=int(input())
b=int(input())
>a*b

Try it online!
Falcon uses a similar syntax to Python. Its output, however, has these awesome aliases called "fast-printing" (as per the documentation):

printl() can be written as >
print() can be written as >>

Pyth - 5 bytes
AQ*GH

Explanation:
AQ*GH
A     Set G and H to the first two elements of
 Q    Evaluated input
      Implicitly print
   G  G
  *   Times
    H H

3 bytes

Verbosity, 392 bytes
Include<Input>
Include<Output>
Include<Integer>
Include<MetaFunctions>
Input:DefineVariable
Output:DefineVariable<o; 0>
Integer:DefineVariable<f; Input:ReadEvaluatedLineFromInput>
Integer:DefineVariable<s; Input:ReadEvaluatedLineFromInput>
Integer:DefineVariable<r; Integer:Product<f; s>>
Output:DisplayAsText<o; r>
DefineMain<> [
MetaFunctions:ExecuteScript<MetaFunctions@FILE>
]

Try it online!

Whispers, 35 bytes
> Input
> Input
>> 1×2
>> Output 3

Try it online!

Wumpus, 5 bytes
II*O@

Try it online!
Explanation
Straight-forward and boring:
I   Read the first integer.
I   Read the second integer.
*   Multiply them.
O   Output the result.
@   Terminate the program.

JavaScript (Node.js), 9 bytes
a=>b=>a*b

Try it online!

Red, 16 bytes
func[a b][a * b]

Try it online!

T-SQL, 17 bytes
SELECT a*b FROM t

Per our IO rules, SQL can take input from a pre-existing table t with integer columns a and b.
This has the bonus of working on an unlimited* number of provided pairs, if they are included in the input table.
*Well, limited only by SQL storage bounds, which are pretty darn high, using enterprise versions.

Python 3, 14 bytes
lambda x,y:x*y

It's literally just multiplication, lol

ARBLE, 3 bytes
a*b

Similar to the answer for Adding two numbers.
Try it online!

gawk '($_*=$2)_'

The final underscore (..)_ is the most succinct way I could think of to force concat an empty string to the zeros and coerce it into a string in order to print it without using the print statement.
weak typing in awk is advantageous cuz I never defined _, so 1st one is used as numeric zero while 2nd one acts as empty string.
2
20
63
-16
-72
72
0
0
0
0
0

Desmoslang Assembly, 5 Bytes
I*IOT

Thunno 2, 1 byte
×

Attempt This Online!
No, * is exponentiation, not multiplication.

HP‑41C series, 7 B
Input is to be placed in the X and Y stack registers.
01♦LBL⸆P           5 Bytes  global label requires 4 + (length of string) Bytes
02 ∗               1 Byte   X ≔ Y × X
03 RTN             1 Byte   `RTN` does not affect local label search

Some other (longer) methods:

stack arithmetic:
ST∗ Y            2 Bytes  Rₙ ≔ Rₙ × X

Result is in Y now.
Necessary keystrokes:
STO × . × (for the letter Y).
statistics functions:
CLΣ              1 Byte   clear statistics registers
Σ+               1 Byte   accumulate statistics values

If ΣREG? = 11 (the default), result is in R15.
Furthermore, there’s % (1 Byte), but it will require scaling the result back by a factor of 100.

ReRegex, 58 bytes
#import math
-(.*?)-/$1/(.+)-/-$1/(\d*)x(\d*)/$1*$2/#input

Try it online!
Ungolfed
#import math
-(.*?)-/$1/#		# Remove pairs of -
(.+)-/-$1/#		# Move any - to the start of the text
(\d*)x(\d*)/$1*$2/#	# Take the input of (number)x(number) and convert it to (number)*(number), implicitly multiplying.
#input

Slightly more interesting, 81 bytes
-(.*?)-/$1/(.+)-/-$1/(?<![:_])(_*)x(_*)/:$1x$2/:(_*)x(_*)_/$1:$1x$2/:_*x$//#input

Try it online!
Ungolfed
-(.*?)-/$1/#			# Remove pairs of -
(.+)-/-$1/#			# Move any - to the start of the text
(?<![:_])(_*)x(_*)/:$1x$2/#	# Add a : if there isn't one, to keep track of the output
:(_*)x(_*)_/$1:$1x$2/#		# Whilst the second argument is > 0, remove one from it, and copy the first argument to the output
:_*x$//#			# When the second argument is zero, remove all the supporting stuff, leaving just the output
#input

Ruby, 10 bytes
->a,b{a*b}

and it would be great to learn if it is possible with fewer bytes

https://codegolf.stackexchange.com/a/106314/53551

haven't seen that

should I supposed to delete/change on such cases? as you see, i am new here, and do not know, "rules of fight club" -))

Ask in chat https://chat.stackexchange.com/rooms/240/the-nineteenth-byte

Duplicate answers are allowed, though they might attract downvotes.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Count the squares
Challenge
Origami (folding paper) is a creative form of art. As far as I know, master of Origami prefers square paper. Let's start from beginning - convert a rectangular paper to a square one.
So the paper is divided into squares. We remove the biggest square which shares one shorter edge with the current shape, step by step (see the picture below). And if the remaining part after one step is less or equal than 0.001 * (area of the original paper), the paper cannot be divided any further. It is possible that nothing remains at last.
Your task is to calculate how many squares are made during the process. The square in the last step that makes the paper unable to be divided is counted into the output.
Example (a paper of 1.350 width/height), output is 10:

Input and Output
Input: width / height ratio for the rectangular paper, one decimal (or an integer without the dot) from 1.002 to 1.999 with a minimal step of 0.001. You may also use any other reasonable format describing the ratio. Just mention it in your answer.
Output: square count, one integer.
Example I/O
A mapping format is used to keep the page tidy, while your code doesn't need to support a list input nor to be a mapping function.
1.002 => 251
1.003 => 223
1.004 => 189
1.005 => 161
1.006 => 140
1.007 => 124
1.008 => 111
1.009 => 100

List of all answers
Thanks to @LuisMendo, here is the graph of answers.

Remarks

This is a code-golf so shortest code wins
Pay attention to standard loopholes
It's your freedom to decide how to deal with input and output  but they should follow standard restrictions.

By the way...

Comment if you have anything unclear about the challenge
Personally I would suggest your answer contains a explanation if you are using a golfing language
Thanks to @GregMartin, read his answer for a good mathematical explanation for the challenge.

Example Code
Here is a ungolfed version of C++ code:
#include <iostream>
#include <utility>

int f (double m)
{
    double n = 1, k = 0.001;
    int cnt = 0;
    k *= m;                       // the target minimum size
    while(m*n >= k)
    {
        m -= n;                   // extract a square
        if(n > m)
            std::swap(n, m);      // keep m > n
        ++ cnt;
    }
    return cnt;
}

int main()
{
    double p;
    std::cin >> p;
    std::cout << f(p);
    return 0;
}

All calculations related in the example code need an accuracy of 6 decimal digits, which is covered in float.

Can two numbers forming the ratio be used as inputs?

@LuisMendo yes, as your wish.

Neat challenge!

The list of answers produces a nice graph

@LuisMendo, would you mind if I add your graph into the description?

@KeyuGan Of course, go ahead! Let me know if you need a version with some other format

Thinking the problem over, there seems to be a bug: 1x1.002 gives first a 1x1 square, leaving 500 0.002x0.002 squares, so the first result should be 501, not 251. While condition should be m*n>1e-6, I think. On mobile, so excuse lack of formatting...

@KenY-N It is because the challenge is not diving the paper into squares as many as you can. Squares are divided one by one. Consider about one 1x1 and 250 0.002x0.002 squares, the total area of 251 squares is 1.001, and the resting part is 0.001 which is smaller than the threshold mentioned in the challenge. (1.002*0.001=0.001002)

Ah, I see now. My misunderstanding.

MATL, 19 bytes
`SZ}y-htG/p1e-3>}x@

The input is an array with the two numbers defining the original ratio, such as [1, 1.009]. (It is not necessary that the numbers be sorted or that one of them be 1.)
Try it online!
Explanation
`        % Do...while loop
  S      %   Sort array. Takes 1×2 array as input (implicit) the first time
  Z}     %   Split array into its 2 elements: first the minimum m, then the maximum M
  y      %   Duplicate m onto the top of the stack. The stack now contains m, M, m
  -      %   Subtract. The stack now contains m, M-m
  h      %   Concatenate into [m, M-m]. This is the remaining piece of paper
  t      %   Duplicate
  G/     %   Divide by input, element-wise
  p      %   Product of array. Gives ratio of current piece's area to initial area
  1e-3>  %   True if this ratio exceeds 1e-3. In that case the loop continues
}        % Finally (execute after last iteration, but still within the loop)
  x      %   Delete last piece of paper
  @      %   Push current loop counter. This is the result
         % End (implicit)
         % Display (implicit)

Haskell, 71 70 65 63 62 61 58 56 bytes
Thanks to @xnor for a some ingenious improvements!
(n#m)e|e>n*m*1e3=0|n<m=m#n$e|d<-n-m=(d#m)e+1
n!m=n#m$n*m

Try it online!

It think the m==n at the end can be 1>0 because it's the only possibility remaining. Or, maybe the cases could be rearranged to allow a bind here.

Actually, is the equality case needed? If n>m is expanded to n>=m and  the first check is written e>m*n*1000, that should give 1 for equality.

@xnor Good idea, thank you!

Moving around guards for 56: (n#m)e|e>n*m*1e3=0|n<m=m#n$e|d<-n-m=(d#m)e+1;n!m=n#m$n*m

Wow, using the d<-n-m as otherwise is really neat!!!

JavaScript (ES6), 59 58 bytes
f=(m,n=!(k=m/1e3,c=0))=>m*n<k?c:(c++,m-=n)<n?f(n,m):f(m,n)

Test

f=(m,n=!(k=m/1e3,c=0))=>m*n<k?c:(c++,m-=n)<n?f(n,m):f(m,n)

console.log(f(1.002))
console.log(f(1.003))
console.log(f(1.004))
console.log(f(1.005))
console.log(f(1.006))
console.log(f(1.007))
console.log(f(1.008))
console.log(f(1.009))

Mathematica, 64 53 bytes
({t=1,#}//.{a_,b_}/;1000a*b>#:>Sort@{++t;a,b-a};t-1)&

An imperative (C-style) solution is exactly the same length:
(For[t=a=1;b=#,1000a*b>#,If[a>b,a-=b,b-=a];++t];t-1)&

C (GCC/Clang), 61 59 bytes
c,k;f(m,n){for(k=m*n;m*n/k;m>n?(m-=n):(n-=m))++c;return c;}

Input is two integers (width & height) without dot, such as f(1999,1000).
I hope someone could save one byte pushing C into the 58-byte club. ;)

Suggest removing the parentheses around m-=n

C, 59 bytes
s,a,n=1e3;C(m){for(a=m;m*n>a;s++)m>n?m-=n:(n-=m);return s;}

Try It online
The input is an integer which is the width / height ratio in thousandths (eg. 1002 for 1.002:1).
Ungolfed version
int C(int m)
{
    int n = 1000;
    int a = m;
    int s = 0;

    while (m * n > a)
    {
        if (m > n)
            m -= n;
        else
            n -= m;

        s++;
    }

    return s;
}

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Linear Regression on a String
This challenge is a little tricky, but rather simple, given a string s:
meta.codegolf.stackexchange.com

Use the position of the character in the string as an x coordinate and the ascii value as a y coordinate. For the above string, the resultant set of coordinates would be:
0, 109
1, 101
2, 116
3, 97
4, 46
5, 99
6, 111
7, 100
8, 101
9, 103
10,111
11,108
12,102
13,46
14,115
15,116
16,97
17,99
18,107
19,101
20,120
21,99
22,104
23,97
24,110
25,103
26,101
27,46
28,99
29,111
30,109

Next, you must calculate both the slope and the y-intercept of the set you've garnered using Linear Regression, here's the set above plotted:

Which results in a best fit line of (0-indexed):
y = 0.014516129032258x + 99.266129032258

Here's the 1-indexed best-fit line:
y = 0.014516129032258x + 99.251612903226

So your program would return:
f("meta.codegolf.stackexchange.com") = [0.014516129032258, 99.266129032258]

Or (Any other sensible format):
f("meta.codegolf.stackexchange.com") = "0.014516129032258x + 99.266129032258"

Or (Any other sensible format):
f("meta.codegolf.stackexchange.com") = "0.014516129032258\n99.266129032258"

Or (Any other sensible format):
f("meta.codegolf.stackexchange.com") = "0.014516129032258 99.266129032258"

Just explain why it is returning in that format if it isn't obvious.

Some clarifying rules:
- Strings are 0-indexed or 1 indexed both are acceptable.
- Output may be on new lines, as a tuple, as an array or any other format.
- Precision of the output is arbitrary but should be enough to verify validity (min 5).

This is code-golf lowest byte-count wins.

Do you have any link / formula to calculate the slope and the y-intercept?

Agreed. You should include the method for computing the line in the question.

Dear Unclear-voters: While I agree that it is nice to have the formula, it is by no means necessary.  Linear regression is a well-defined thing in the mathematical world, and the OP may want to leave finding the equation up to the reader.

https://en.wikipedia.org/wiki/Simple_linear_regression

There are many ways to perform linear regression. Some are estimations/approximations while other methodologies strive to be exact calculations. So, how you go about it is up to you. But you should be able to explain the method you chose.

Is it okay to return the actual equation of the best-fit line, such as 0.014516129032258x + 99.266129032258?

@GregMartin yes. As long as the slope and y-intercept are displayed in a sensible manner I will accept it.

This challenge's title has put this wonderful song in my head for the rest of the day

I joined this community just to up-vote this challenge!

@CraigR8806 have a look around, this is by far not even close to the best challenge out there.

@carusocomputing I have been lurking through here for awhile and there are definitely some novel challenges.  I found this one to be really interesting though.

Obligatory xkcd. (Though the example in this challenge does have something of a pattern, the outliers really skew the line of best fit!)

MATL, 8 bytes
n:G3$1ZQ

1-based string indexing is used.
Try it online!
Explanation
n:     % Input string implicitly. Push [1 2 ... n] where n is string length.
       % These are the x values
G      % Push the input string. A string is an array of chars, which is
       % equivalent to an array of ASCII codes. These are the y values
3$     % The next function will use 3 inputs
1      % Push 1
ZQ     % Fit polynomial of degree 1 to those x, y data. The result is an
       % array with the polynomial coefficients. Implicitly display

Octave, 29 26 24 20 bytes
@(s)s/[!!s;1:nnz(s)]

Try it Online!
We have the model
y= intercept *x^0 + slope * x
 = intercept * 1  + slope * x

Here y is the  ASCII value of string s
To find parameters intercept and slope we can form the following equation:
s = [intercept slope] * [1 X]

so
[intercept slope] = s/[1 x]

!!s converts a string to a vector of ones with the same length as the string.
The vector of ones is used for estimation of the intercept.
1:nnz(s) is range of values from 1 to number of elements of the string used as x.
Previous answer
@(s)ols(s'+0,[!!s;1:nnz(s)]')

For test paste the following code into Octave Online
(@(s)ols(s'+0,[!!s;1:nnz(s)]'))('meta.codegolf.stackexchange.com')

A function that accepts a string as input and applies ordinary least squares estimation of model y = x*b + e
The first argument of ols is y that for it we transpose the string s and add with number 0 to get its ASCII code.

/, great idea!

TI-Basic, 51 (+ 141) bytes
Strings are 1-based in TI-Basic.
Input Str1
seq(I,I,1,length(Str1->L1
32+seq(inString(Str2,sub(Str1,I,1)),I,1,length(Str1->L2
LinReg(ax+b)

Like the other example, this outputs the equation of the best fit line, in terms of X. Also, in Str2 you need to have this string, which is 141 bytes in TI-Basic: !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_abcdefghijklmnopqrstuvwxyz{|}~
The reason this cannot be a part of the program is because two characters in TI-Basic cannot be automatically added to a string. One is the STO-> arrow, but this is not a problem because it is not a part of ASCII. The other is the string literal ("), which can be stringified only by typing into a Y= equation and using Equ>String(.

I was seriously wondering if anyone would bust out their old calculators for this :). I had my old TI-83 in mind when I thought this up.

@carusocomputing Hey, nice! I like the TI-Basic programming language a lot and I use it for many of my code golfs. If only it supported ASCII...

Two comments: 1, you can stringify " by prompting for it as user input in a program as well, which doesn't help you here, but I just wanted to point that fact out. 2, I don't recognize some of those characters as existing on the calculator. I could be wrong, but for example, where do you get @ and ~? As well as #, $, and &.

Thanks for the comment, @PatrickRoberts. Those are two-byte tokens starting with 0xBB. Look in Column D of http://tibasicdev.wikidot.com/miscellaneous-tokens

R, 46 45 bytes
x=1:nchar(y<-scan(,""));lm(utf8ToInt(y)~x)$co

Reads input from stdin and for the given test case returns (one-indexed):
(Intercept)           x
99.25161290  0.01451613

Slightly shorter (but untested, possibly some evaluation problems in parsing the formula): lm(utf8ToInt(y<-scan(,""))~1:nchar(y))$co

@rturnbull I tried this at first but it seems like the x variable has to be pre-defined for lm to work.

@rturnbull I get a variable lengths differ error on that. We are given s so x=1:nchar(s);lm(charToRaw(s)~x)$co saves some bytes. I also don't know if the $co is technically necessary, as you still get the intercept + coefficient without it

@Chris Fairly sure that is not a viable answer. There should be some input from stdin or as a function argument.

Fair enough, just my reading of the question - it gives a more fair comparison to the python + octave answers as well

Python, 82 80 bytes
-2 bytes thanks to @Mego
Using scipy:
import scipy
lambda s:scipy.stats.linregress(range(len(s)),list(map(ord,s)))[:2]

Unnamed lambdas are allowed, so you can drop the f=.

@DigitalTrauma numpy.linalg.lstsq apparently differs in arguments to scipy.stats.linregress and is more complex.

Mathematica, 31 bytes
Fit[ToCharacterCode@#,{1,x},x]&

Unnamed function taking a string as input and returning the actual equation of the best-fit line in question. For example, f=Fit[ToCharacterCode@#,{1,x},x]&; f["meta.codegolf.stackexchange.com"] returns 99.2516 + 0.0145161 x.
ToCharacterCode converts an ASCII string to a list of the corresponding ASCII values; indeed, it defaults to UTF-8 more generally. (Kinda sad, in this context, that one function name comprises over 48% of the code length....) And Fit[...,{1,x},x] is the built-in for computing linear regression.

Thanks for the example of the 1-indexed line, didn't have to calculate it because of you haha.

Node.js, 84 bytes
Using regression:
s=>require('regression')('linear',s.split``.map((c,i)=>[i,c.charCodeAt()])).equation

Demo

// polyfill, since this is clearly not Node.js
function require(module) {
  return window[module];
}
// test
["meta.codegolf.stackexchange.com"].forEach(function test(string) {
  console.log(string);
  console.log(this(string));
},
// submission
s=>require('regression')('linear',s.split``.map((c,i)=>[i,c.charCodeAt()])).equation
);

Sage, 76 bytes
var('m','c')
y(x)=m*x+c
f=lambda x:find_fit(zip(range(len(x)),map(ord,x)),y)

Hardly any golfing, probably longer than a golfed Python answer, but yeah...

J, 11 bytes
3&u:%.1,.#\

This uses one-based indexing.
Try it online!
Explanation
3&u:%.1,.#\  Input: string S
         #\  Get the length of each prefix of S
             Forms the range [1, 2, ..., len(S)]
      1,.    Pair each with 1
3&u:         Get the ASCII value of each char in S
    %.       Matrix divide

JavaScript, 151 148 bytes
s=>([a,b,c,d,e]=[].map.call(s,c=>c.charCodeAt()).reduce(([a,b,c,d,e],y,x)=>[a+1,b+x,c+x*x,d+y,e+x*y],[0,0,0,0,0]),[k=(e*a-b*d)/(c*a-b*b),(d-k*b)/a])

More readable:

function f(s) {
  var [n, sx, sx2, sy, sxy] = [].map.call(s, c => c.charCodeAt(0))
    .reduce(([n, sx, sx2, sy, sxy], y, x) => [
      n + 1,
      sx + x,
      sx2 + x * x,
      sy + y,
      sxy + x * y
    ], [0, 0, 0, 0, 0]);
  var k = (sxy * n - sx * sy) / (sx2 * n - sx * sx);
  return [k, (sy - k * sx) / n];
}

$(() => $('#run').on('click', () => console.log(f($('#input').val()))));

<textarea id="input" style="width: 100%">meta.codegolf.stackexchange.com</textarea>
<button id="run">Run</button>

You can save a byte by removing 0 from c.charCodeAt(0), and another 2 bytes by moving the k=... comma group and putting it directly in first index of the returned array like [k=...,(d-k*b)/a]

Haskell, 154 142 bytes
import Statistics.LinearRegression
import Data.Vector
g x=linearRegression(generate(Prelude.length x)i)$i.fromEnum<$>fromList x
i=fromIntegral

It is far too long for my likings because of the imports and long function names, but well. I couldn't think of any other Golfing method left, although I'm not expert on the area of golfing imports.
Stripped 12 bytes by replacing ord and the import of Data.Char by fromEnum thanks to nimi.

You can replace ord with fromEnum and get rid of import Data.Char.

Javascript (ES6), 112 bytes
s=>[m=(a=b=c=d=0,([...s].map((u,x)=>{a+=n=x,b+=y=u.charCodeAt(),c+=x*x,d+=x*y}),++n)*d-a*b)/(n*c-a*a),b/n-m*a/n]

F=s=>[m=(a=b=c=d=0,([...s].map((u,x)=>{a+=n=x,b+=y=u.charCodeAt(),c+=x*x,d+=x*y}),++n)*d-a*b)/(n*c-a*a),b/n-m*a/n]

const update = () => {
  console.clear();
  console.log(F(input.value));
};
input.oninput = update;
update();
#input {
  width: 100%;
  box-sizing: border-box;
}
<input id="input" type="text" value="meta.codegolf.stackexchange.com" length=99/>

SAS Macro Language, 180 bytes
Uses 1-based indexing.
The solution gets to be pretty wordy when the output is only the slope and intercept.
%macro t(a);data w;%do i=1 %to %length(&a);x=&i;y=%sysfunc(rank(%substr(&a,&i,1)));output;%end;run;proc reg outtest=m;model y=x/noprint;run;proc print data=m;var x intercept;%mend;

Clojure, 160 bytes
No built-ins, uses the iterative algorithm described at Perceptron article. Might not converge on other inputs, in that case lower the learning rate 2e-4 and maybe increase the iteration count 1e5. Not sure if the non-iterative algorithm would have been shorter to implement.
#(nth(iterate(fn[p](let[A apply e(for[x(range(count %))](-(int(get % x))(*(p 1)x)(p 0)))](mapv(fn[p e](+(* e 2e-4)p))p[(A + e)(A +(map *(range)e))])))[0 0])1e5)

Example:
(def f #( ... ))
(f "meta.codegolf.stackexchange.com")

[99.26612903225386 0.014516129032464659]

Maple, 65 bytes
Statistics:-LinearFit(b*x+a,[$(1..length(s))],convert(s,bytes),x)

Usage:
s := "meta.codegolf.stackexchange.com";
Statistics:-LinearFit(b*x+a,[$(1..length(s))],convert(s,bytes),x);

Returns:
99.2516129032259+0.0145161290322573*x

Notes: This uses the Fit command to fit a polynomial of the form a*x + b to the data. The ASCII values for the string are found by converting to bytes.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/