## Operator

### Standard Operations

#### Arithmetic Multiplication

The "*" operator is defined as arithmetic multiplication for all numeric types.

```.mw-parser-output .ada-kw{background:none;border:none;padding:0;margin:0;color:DodgerBlue;font-weight:bold}.mw-parser-output .ada-kw a,.mw-parser-output .ada-kw a:visited{color:inherit}`function` "*" (Left, Right : T) `return` T;
```
##### Usage
```A : `constant` Float   := 5.0 * 2.0;  -- A is now 10.0
B : `constant` Integer := 5 * 2;      -- B is also 10
```
##### Working Example
````with` Ada.Text_IO;

`procedure` Operator_Multiply `is`
A : `constant` Float   := 5.0 * 2.0;  -- A is now 10.0
B : `constant` Integer := 5 * 2;      -- B is also 10

`package` T_IO `renames` Ada.Text_IO;
`package` F_IO `is` `new`  Ada.Text_IO.Float_IO (Float);
`package` I_IO `is` `new`  Ada.Text_IO.Integer_IO (Integer);

`begin`
T_IO.Put ("A = ");
F_IO.Put (
Item => A,
Fore => 3,
Aft  => 1,
Exp  => 0);
T_IO.New_Line;
T_IO.Put ("B = ");
I_IO.Put (
Item  => B,
Width => 3,
Base  => 10);
T_IO.New_Line;
`end` Operator_Multiply;
```

### Common Non-Standard Operations

#### Character replication

A String is created where a single character is replicated n-times.

````function` "*" (Left : Natural; Right : Character) `return` String;
```

In addition to standard Strings this operator is also defined for Bounded_String and Unbounded_String.

##### Usage
```A : `constant` String := 10 * 'X';  -- A is filled with 10 X
```
##### Working Example

The character replication operator is part of the Ada.Strings.Fixed package. You need to `with` and `use` the package to make the operator visible.

````with` Ada.Text_IO;
`with` Ada.Strings.Fixed;

`procedure` Operator_Multiply_2 `is`
`use` Ada.Strings.Fixed;

A : `constant` String := 10 * 'X';  -- A is filled with 10 X

`package` T_IO `renames` Ada.Text_IO;

`begin`
T_IO.Put_Line ("A = " & A);
`end` Operator_Multiply_2;
```

#### String replication

A String is created where a source string is replicated n-times.

````function` "*" (Left : Natural; Right : String) `return` String;
```

In addition to standard fixed strings this operator is also defined for Bounded_String and Unbounded_String.

##### Usage
```A : `constant` String := 3 * "Hello ";  -- A is filled with 3 Hello
```
##### Working Example

The string replication operator is part of the Ada.Strings.Fixed package. You need to `with` and `use` the package to make the operator visible.

````with` Ada.Text_IO;
`with` Ada.Strings.Fixed;

`procedure` Operator_Multiply_3 `is`
`use` Ada.Strings.Fixed;

A : `constant` String := 3 * "Hello ";  -- A is filled with 3 Hello.

`package` T_IO `renames` Ada.Text_IO;

`begin`
T_IO.Put_Line ("A = " & A);
`end` Operator_Multiply_3;
```