Vector: Difference between revisions

{{trans|D}}

 

Float x, y

 

print(Vector(5, 7) - Vector(2, 3))

print(Vector(5, 7) * 11)

 

{{out}}

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

DEFINE X_="+0"

PrintVec(v1) Print(" / ") PrintR(s)

Print(" = ") PrintVec(res)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Vector.png Screenshot from Atari 8-bit computer]

 

=={{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>

=={{header|BASIC256}}==

{{trans|Ring}}

dim vect1(2)

vect1[1] = 5 : vect1[2] = 7

print "[" & vect1[1] & ", " & vect1[2] & "] / " & 2 & " = ";

call showarray(vect3)

{{out}}

<pre>[5, 7] + [2, 3] = [7, 10]

BQN's arrays are treated like vectors by default, and all arithmetic operations vectorize when given appropriate length arguments. This means that vector functionality is a builtin-in feature of BQN.

 

⟨7 10⟩

5‿7 - 2‿3

⟨55 77⟩

5‿7 ÷ 2

 

=={{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>

 

=={{header|CLU}}==

vector = cluster [T: type] is make, add, sub, mul, div,

get_x, get_y, to_string

stream$putl(po, "a * 11 = " || vr$to_string(a_times_11, format_real))

stream$putl(po, " a / 2 = " || vr$to_string(a_div_2, format_real))

{{out}}

<pre> a = (5.0000, 7.0000)

 

=={{header|D}}==

 

void main() {

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

}

 

{{out}}

=={{header|Delphi}}==

 

program Vector;

 

 

.

 

{{out}}

 

=={{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>

{{works with|gforth|0.7.3}}

This is integer only implementation. A vector is two numbers on the stack. "pretty print" is just printing the two numbers in the desired order.

: v* swap over * >r * r> ;

: v/ swap over / >r / r> ;

: v+ >r swap >r + r> r> + ;

 

{{out}}

 

=={{header|Fortran}}==

IMPLICIT NONE

 

WRITE(*,*) "VECTOR_1 / 2.0 = ", PRETTY_PRINT(VECTOR_1/SCALAR)

WRITE(*,*) "VECTOR_1 * 2.0 = ", PRETTY_PRINT(VECTOR_1*SCALAR)

{{out}}

<pre> VECTOR_1 (X: 2.0, Y: 3.0) : [2.00000, 3.00000]

 

=={{header|FreeBASIC}}==

 

Type Vector

Print

Print "Press any key to quit"

 

{{out}}

 

=={{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}}

 

=={{header|Lua}}==

 

function vector.new (x, y)

vector.print(a - b)

vector.print(a * 11)

{{out}}

<pre>(7, 10)

 

=={{header|Maple}}==

option object;

local value := Vector();

 

 

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

 

a - b;

a * 5;

{{out}}

<pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

vector[{r_,\[Theta]_}]:=vector@@AngleVector[{r,\[Theta]}]

vector[x_,y_]+vector[w_,z_]^:=vector[x+w,y+z]

12vector[1,2]

vector[1,2]/3

{{out}}

<pre>vector[4, 6]

 

=={{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]

 

=={{header|Nim}}==

 

type Vec2[T: SomeNumber] = tuple[x, y: T]

echo &"{v4} * 2 = {v4 * 2}"

echo &"{v3} / 2 = {v3 / 2}" # Int division.

 

{{out}}

 

=={{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)

(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;

use feature 'say';

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

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

{{out}}

<pre>

{{libheader|Phix/basics}}

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

<span style="color: #008080;">constant</span> <span style="color: #000000;">a</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">},</span> <span style="color: #000000;">b</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">}</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">sq_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">sq_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">11</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">sq_div</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>

{{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>

 

=={{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|Swift}}==

{{trans|Rust}}

 

#if canImport(Numerics)

import Numerics

print((Vector(x: 3.0, y: 4.2) * 2.3).prettyPrinted())

print((Vector(x: 3.0, y: 4.2) / 2.3).prettyPrinted())

 

{{out}}

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}}

 

=={{header|Wren}}==

construct new(x, y) {

_x = x

System.print("v1 * 11 = %(v1 * 11)")

System.print("11 * v2 = %(times.call(11, v2))")

 

{{out}}

 

=={{header|XPL0}}==

real A, B, C; \A:= B + C

[A(0):= B(0) + C(0); \VAdd(A, A, C) => A:= A + C

Text(0, "11 * V2 = "); VOut(0, VMul(V0, V2, 11.)); CrLf(0);

Text(0, "V1 / 2 = "); VOut(0, VDiv(V0, V1, 2. )); CrLf(0);

 

{{out}}

=={{header|Yabasic}}==

{{trans|Ring}}

vect1(1) = 5 : vect1(2) = 7

dim vect2(2)

print svect$;

print "]"

{{out}}

<pre>[5, 7] + [2, 3] = [7, 10]

=={{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>