Vector: Difference between revisions

The four operations to be implemented are:

* Vector <big><b> + </b></big> Vector addition

* Vector <big><b> * </b></big> scalar multiplication

* Vector <big><b> / </b></big> scalar division

<br><br>

 

=={{header|ALGOL 68}}==

MODE VECTOR = COMPLEX;

# the operations required for the task plus many others are provided as standard for COMPLEX and REAL items #

print( ( "a*11: ", TOSTRING ( a * 11 ), newline ) );

print( ( "a/2 : ", TOSTRING ( a / 2 ), newline ) )

{{out}}

<pre>

a/2 : [2.5000, 3.5000]

</pre>

 

=={{header|C}}==

j cap or hat j is not part of the ASCII set, thus û ( 150 ) is used in it's place.

#include<stdio.h>

#include<math.h>

return 0;

}

Output:

<pre>

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre>[7,10]

 

=={{header|C++}}==

#include <cmath>

#include <cassert>

return 0;

}

{{out}}

<pre>

X: 1 Y: 1

</pre>

 

=={{header|D}}==

 

void main() {

sink.formattedWrite!"(%s, %s)"(x, y);

}

 

{{out}}

=={{header|Delphi}}==

 

program Vector;

 

 

.

 

{{out}}

(55,0 + i77,0)

(2,5 + i3,5)

</pre>

 

=={{header|F#|F sharp}}==

 

let add (ax, ay) (bx, by) =

printfn "%A" (mul a 11.0)

printfn "%A" (div a 2.0)

 

=={{header|Factor}}==

It should be noted the <code>math.vectors</code> vocabulary has words for treating any sequence like a vector. For instance:

(scratchpad) { 1 2 } { 3 4 } v+

 

--- Data stack:

However, in the spirit of the task, we will implement our own vector data structure. In addition to arithmetic and prettyprinting, we define a convenient literal syntax for making new vectors.

prettyprint.custom sequences ;

IN: rosetta-code.vector

M: vec pprint-delims drop \ VEC{ \ } ;

M: vec >pprint-sequence parts 2array ;

We demonstrate the use of vectors in a new file, since parsing words can't be used in the same file where they're defined.

sequences ;

IN: rosetta-code.vector

! course.

 

{{out}}

<pre>

VEC{ 5 7 } 2 v/ = VEC{ 2+1/2 3+1/2 }

VEC{ 5 2 } 1.3 v* = VEC{ 6.5 2.6 }

</pre>

 

=={{header|FreeBASIC}}==

 

Type Vector

Print

Print "Press any key to quit"

 

{{out}}

[5, 7] / 2 = [2.5, 3.5]

</pre>

 

=={{header|Go}}==

 

import "fmt"

fmt.Println(v1.scalarMul(11))

fmt.Println(v1.scalarDiv(2))

{{out}}

<pre>

Solution:

 

 

@EqualsAndHashCode

static Vector minus (Number a, Vector b) { -b + a }

static Vector multiply (Number a, Vector b) { b * a }

 

 

Test:

 

 

def a = [1, 5] as Vector

println "x * a == $x * $a == ${x*a}"

assert b / x == [3/4, -1/4] as Vector

 

Output:

 

=={{header|Haskell}}==

add (u,v) (x,y) = (u+x,v+y)

minus (u,v) (x,y) = (u-x,v-y)

putStrLn $ "2 * vecB = " ++ (show.multByScalar 2 $ vecB)

putStrLn $ "vecA / 3 = " ++ (show.divByScalar vecA $ 3)

{{out}}

<pre>

These are primitive (built in) operations in J:

 

7 10

5 7-2 3

55 77

5 7%2

 

A few things here might be worth noting:

It's perhaps also worth noting that J allows you to specify complex numbers using polar coordinates, and complex numbers can be converted to vectors using the special token (+.) - for example:

 

1.41421j1.41421

+. 2ad45

1.41421j1.41421

+. 2ar0.785398

 

In the construction of these numeric constants, <code>ad</code> is followed by an '''a'''ngle in '''d'''egrees while <code>ar</code> is followed by an '''a'''ngle in '''r'''adians. This practice of embedding letters in a numeric constant is analogous to the use of '''e'''xponential notation when describing some floating point numbers.

 

=={{header|Java}}==

 

public class Test {

return String.format(Locale.US, "[%s, %s]", x, y);

}

 

<pre>[7.0, 10.0]

will work with conformal arrays of any dimension, and

sum/0 accepts any number of same-dimensional vectors.

[ r*(angle|cos), r*(angle|sin) ];

 

def angle: atan2;

 

 

'''Examples'''

def pi: 1 | atan * 4;

 

"z2|topolar|polar is \($z2|topolar|polar2vector)" ;

 

{{out}}

v is [1,1]

w is [3,4]

z2 = polar(-2; pi/4) is [-1.4142135623730951,-1.414213562373095]

z2|topolar is [2,-2.356194490192345]

 

=={{header|Julia}}==

 

'''The module''':

 

export SpatialVector

end

 

 

=={{header|Kotlin}}==

 

class Vector2D(val x: Double, val y: Double) {

println("11 * v2 = ${11.0 * v2}")

println("v1 / 2 = ${v1 / 2.0}")

 

{{out}}

11 * v2 = (22.0, 33.0)

v1 / 2 = (2.5, 3.5)

</pre>

 

=={{header|Lua}}==

 

function vector.new (x, y)

vector.print(a - b)

vector.print(a * 11)

{{out}}

<pre>(7, 10)

(55, 77)

(2.5, 3.5)</pre>

 

=={{header|Maple}}==

option object;

local value := Vector();

 

 

b := MyVector(<5|4>):

 

a - b;

a * 5;

{{out}}

<pre>

</pre>

 

 

 

=={{header|MiniScript}}==

return [v1[0]+v2[0],v1[1]+v2[1]]

end function

print vminus(vector2, vector1)

print vmult(vector1, 3)

{{out}}

<pre>

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM RealStr IMPORT RealToStr;

 

ReadChar

 

=={{header|Nanoquery}}==

{{trans|Java}}

declare x

declare y

println new(Vector, 5, 7) - new(Vector, 2, 3)

println new(Vector, 5, 7) * 11

{{out}}

<pre>[7.0, 10.0]

[55.0, 77.0]

[2.5, 3.5]</pre>

 

=={{header|Objeck}}==

function : Main(args : String[]) ~ Nil {

Vec2->New(5, 7)->Add(Vec2->New(2, 3))->ToString()->PrintLine();

return "[{$@x}, {$@y}]";

}

 

<pre>

=={{header|OCaml}}==

{{trans|Perl}}

struct

type t = { x : float; y : float }

printf "a-b: %s\n" Vector.(a - b |> to_string);

printf "a*11: %s\n" Vector.(a * 11. |> to_string);

 

{{out}}

Ol has builtin vector type, but does not have built-in vector math.

The vectors can be created directly using function (vector 1 2 3) or from list using function (make-vector '(1 2 3)). Additionally, exists short forms of vector creation: #(1 2 3) and [1 2 3].

(define :+ +)

(define (+ a b)

(error "error:" "not applicable (+ vector non-vector)"))

(if (vector? b)

 

(define :- -)

(error "error:" "not applicable (+ vector non-vector)"))

(if (vector? b)

 

(define :* *)

(error "error:" "not applicable (* vector vector)"))

(if (vector? b)

 

(define :/ /)

(error "error:" "not applicable (/ vector vector)"))

(if (vector? b)

 

(define x [1 2 3 4 5])

(print x " * " 7 " = " (* x 7))

(print x " / " 7 " = " (/ x 7))

{{Out}}

<pre>

 

=={{header|ooRexx}}==

v~ab(1,1,6,4); Say "v~ab(1,1,6,4) =>" v~print

v~al(45,2); Say "v~al(45,2) =>" v~print

return '['self~x','self~y']'

 

{{out}}

<pre>v=.vector~new(12,-3) => [12,-3]

=={{header|Perl}}==

Typically we would use a module, such as [https://metacpan.org/pod/Math::Vector::Real Math::Vector::Real] or [https://metacpan.org/pod/Math::Complex Math::Complex]. Here is a very basic Moose class.

use Moose;

'""' => \&stringify;

 

has 'y' => (is =>'rw', isa => 'Num', required => 1);

 

 

package main;

say "a-b: ",$a-$b;

say "a*11: ",$a*11;

{{out}}

<pre>

 

=={{header|Phix}}==

Simply hold vectors in sequences, and there are builtin sequence operation routines:

{{Out}}

<pre>

 

=={{header|Phixmonti}}==

 

def add + enddef

drop 2

getid mul opVect ?

{{out}}

<pre>[7, 10]

 

=={{header|PicoLisp}}==

(mapcar + A B) )

(de sub (A B)

(println (sub X Y))

(println (mul X 11))

{{out}}

<pre>

=={{header|PL/I}}==

{{trans|REXX}}

vectors: Proc Options(main);

Dcl (v,w,x,y,z) Dec Float(9) Complex;

Return(res);

End;

{{out}}

<pre>[ 12.00000, -3.00000]

{{works with|PowerShell|2}}<br/>

A vector class is built in.

$V2 = New-Object System.Windows.Vector ( -6, 2 )

$V1

$V1 - $V2

$V1 * 3

{{out}}

<pre> X Y Length LengthSquared

A vector class, PVector, is a Processing built-in. It expresses an x,y or x,y,z vector from the origin. A vector may return its components, magnitude, and heading, and also includes .add(), .sub(), .mult(), and .div() -- among other methods. Methods each have both a static form which returns a new PVector and an object method form which alters the original.

 

PVector v2 = new PVector(2, 3);

 

println(v1.add(v2));

println(v1.mult(10));

 

{{out}}

Python mode adds math operator overloading for Processing's PVector static methods.

 

v2 = PVector(2, 3)

 

println(v1.add(v2)) # v1 += v2; println(v2)

println(v1.mult(10)) # v1 *= 10; println(v1)

 

=={{header|Python}}==

Implements a Vector Class that is initialized with origin, angular coefficient and value.

 

def __init__(self,m,value):

self.m = m

self.value.__round__(2),

self.x.__round__(2),

 

Or Python 3.7 version using namedtuple and property caching:

import math

from functools import lru_cache

 

print("Division:")

{{Out}}

<pre>Pretty print:

 

We use <code>fl*</code> and <code>fl/</code> to try to get the most sensible result for vertical vectors.

 

(require racket/flonum)

(define (vec/e v l)

(vec (/ (vec-x v) l)

'''Tests

 

(vec/slope-norm 0 10)

(vec+ (vec/slope-norm 1 10) (vec/slope-norm 1 2))

 

 

{{out}}

(formerly Perl 6)

 

has Real $.x;

has Real $.y;

say -$u; #: vec[-3, -4]

say $u * 10; #: vec[30, 40]

 

=={{header|Red}}==

Source: https://github.com/vazub/rosetta-red

Tabs: 4

prin pad "v1 * 11" 10 print (copy v1) * 11

prin pad "v1 / 2" 10 print (copy v1) / 2

{{out}}

<pre>

 

The angular part of the vector (when defining) is assumed to be in degrees for this program.

s1 = 11 /*define the s1 scalar: eleven */

s2 = 2 /*define the s2 scalar: two */

/*──────────────────────────────────────────────────────────────────────────────────────*/

.sinCos: parse arg z 1 _,i; q=x*x

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

# Project : Vector

 

see svect

see "]" + nl

Output:

<pre>

</pre>

 

=={{header|Ruby}}==

def self.polar(r, angle=0)

new(r*Math.cos(angle), r*Math.sin(angle))

p z.polar #=> [1.0, 1.5707963267948966]

p z = Vector.polar(-2, Math::PI/4) #=> Vector[-1.4142135623730951, -1.414213562373095]

 

=={{header|Rust}}==

use std::ops::{Add, Div, Mul, Sub};

 

println!("{:.4}", Vector::new(3.0, 4.2) / 2.3);

println!("{}", Vector::new(3, 4) / 2);

 

{{out}}

 

=={{header|Scala}}==

 

case class Vector2D(x: Double, y: Double) {

 

println(s"\nSuccessfully completed without errors. [total ${scala.compat.Platform.currentTime - executionStart} ms]")

 

=={{header|Sidef}}==

{{trans|Raku}}

 

has Number x

say -u #: vec[-3, -4]

say u*10 #: vec[30, 40]

 

=={{header|Tcl}}==

Good artists steal .. code .. from the great RS on [http://wiki.tcl.tk/14022|the Tcl'ers wiki]. Seriously, this is a neat little procedure:

 

proc vec {op a b} {

if {[llength $a] == 1 && [llength $b] == 1} {

check {vec * {5 7} 11} {55 77}

check {vec / {5 7} 2.0} {2.5 3.5}

 

The tests are taken from J's example:

 

=={{header|VBA}}==

x As Double

y As Double

Debug.Print "scalar division : ";: display a: Debug.Print " /";: Debug.Print d;

Debug.Print "=";: display scalar_division(a, d)

<pre>addition : ( 2,500; 4,330)+( 1,000; -2,000)=( 3,500; 2,330)

subtraction : ( 2,500; 4,330)-( 1,000; -2,000)=( 1,500; 6,330)

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Class Vector

End Sub

 

{{out}}

<pre>[7,10]

 

=={{header|WDTE}}==

let s => import 'stream';

 

 

let s* => smath *;

 

'''Example Usage:'''

 

 

{{out}}

<pre>[3; 7; 5]

[3; 15; 30]</pre>

 

=={{header|zkl}}==

This uses polar coordinates for everything (radians for storage, degrees for i/o), converting to (x,y) on demand. Math is done in place rather than generating a new vector. Using the builtin polar/rectangular conversions keeps the vectors normalized.

var length,angle; // polar coordinates, radians

fcn init(length,angle){ // angle in degrees

}

fcn toString{ "Vector(%f,%f\Ub0;)".fmt(length,angle.toDeg()) }

Vector(2,45).print(" create");

(Vector(2,45) * 2).print(" *");

(Vector(4,90) / 2).print(" /");

(Vector(2,45) + Vector(2,45)).print(" +");

{{out}}

<pre>