# 1: Vector Basics

1: Vector Basics

## Data Science for Psychologists

Vectors are the most common and most important data shape in R. For our purposes, a vector is an ordered sequence of objects of the same type. 17 Any vector has three common properties:

1. its type of elements (tested by typeof() )
2. its length (tested by length() )
3. optional attributes or meta-data (tested by attributes() ).

The most common attribute of a vector v are the names of its elements, which can be set or retrieved by names(v) .

### 1.4.1 Basics

Think of a vector as a freight train that contains a sequence of waggons that are of the same type: Each waggon can contain different cargo (objects), but all of these objects must be of the same type (e.g., logical values, numbers, or characters). As the waggons are indistinguishable from the outside, the contents of any particular waggon can be determined by addressing the waggon by its name (an optional attribute) or its number (or position) in the sequence. For instance, suppose there is a vector named train . Even when we do not know how this vector was defined (as this is not shown here), the following functions provide some basic information about it:

To obtain information about the train vector, we applied some basic functions to it. Let’s explain each of these functions in turn:

Evaluating train prints the entire vector in our Console. Actually, it is merely a shorthand for print(train) . If the vector is short enough to be printed in its entirety, we can obtain comprehensive information about it (i.e., its type, length, names, and all its elements). But even if the vector is too long to be printed, we can still learn its type, whether its elements are named, and what its first elements are.

We learned that all elements of a vector are of the same type. The function typeof(v) explicitly determines the type of a vector v .

As vectors are one-dimensional sequences, they have a length. The function length(v) determines the length of a vector v .

Vectors can have names, but do not need to have them. The function names(v) determines the names of a vector v and returns NULL if its elements are not named.

The contents of particular vector elements can be accessed by their number or their name (if v contains names). To access vector elements, R uses square brackets [] . The command v[n] returns the n -th element of a vector v , and the command v["abc"] returns the element named “abc” of a vector v (if v contains an element with this name).

#### Practice

The following objects v1 and v2 are both vectors (i.e., an ordered sequence of elements) that have a length of 4 elements, but are of different types:

Of what type are the elements of v1 and v2 ?

What is their i-th (e.g., 2nd) element?

Applying basic vector functions:

What is the reverse sequence of v2 ?

Do v1 or v2 contain some element "A" ?

Where does an element “A” (first) occur in some vector v2 ?

Which element of v2 has a particular value (e.g., "B" or "Z" )?

Note that some of these questions ask for a vector of elements, whereas others are answered by a simple binary (e.g., TRUE or FALSE ) value, or a vector of numbers (positions). To solve these tasks, we can apply slightly more advanced functions to vectors:

• The function %in% (used as a binary operator between its two arguments) checks whether the left (first) argument is an element of the right (second) one:
• The %in% operator is based on the match() function that returns the positions of (first) matches of its first argument in its second argument:
• The which() function returns the position(s) (i.e., numbers) for which a test on a vector evaluates to TRUE :

Thus, which() allows us to probe a vector with some test and returns a (numeric) vector of the positions for which the test is TRUE .

We will learn more about these and many other vector-based functions later. For now, just try to understand these basic functions and remember that there are many ways to probe and manipulate vectors.

### 1.4.2 Creating vectors

To create a new vector, we can combine several objects of the same type with the c() function (think chain, combine, or concatenate), separating vector elements by commas:

The same function can be used to combine scalars and vectors:

but note that the resulting vector is still a vector, rather than a vector containing other vectors (i.e., c() flattens vectors).

The c() function can also be used to combine objects of type character or logical values into vectors:

When combining different data types, they are coerced into a single data type. The result is either a numeric vector (when mixing truth values and numberic objects) or a character vector (when mixing anything with characters):

In R, we are almost always dealing with vectors. These vectors are either created by us (by using functions that create or return vectors) or read in as data. As we will see below (in Section 1.5), data files in the form of tables are really columns of vectors.

### 1.4.3 Applying functions to vectors

Most functions in R can be applied to vectors. When applying a function to a vector, we typically either obtain some information about the vector (as a scalar object) or a transformed version of the vector:

When combining data of different types (e.g., numbers and characters) in a vector, R coerces them into a common type (e.g., truth values into numbers, or all into objects of type “character,” as this is always possible):

A common operation that changes an existing vector consists in sorting vectors, which is achieved by the sort() function. An argument decreasing is set to FALSE by default, but can be set to TRUE if sorting in decreasing order is desired:

#### Calculating with logical values

When combining truth values and numeric objects in a vector, a numeric vector is returned. Any value of TRUE is interpreted as the number 1 and any value of FALSE is interpreted as the number 0:

The same interpretation of truth values is made when applying arithmetic functions to truth values:

Calculating with logical values may seem a bit strange at first, but provides a useful bridge between logical and numeric data types.

#### Practice

Here are some practice exercises for applying functions to various types of vectors:

Answer: The truth values are coerced into numeric values: FALSE becomes 0 and TRUE becomes 1.

Assuming a vector band <- c("A", "B", "B", "A") .

Answer: Both vectors are sorted, just as we have seen for numeric vectors above. Vectors with character objects are sorted alphabetically. In logical vectors, FALSE values (corresponding to values of 0) are sorted before TRUE values (corresponding to values of 1).

Look up the documentation of the order() function and contrast it with the sort() function.

Computing with numbers vs. logical values:

Assume the following vector definitions:

### 1.4.4 Scalar objects are vectors

R is often described as a vector-based language. This means that R uses vectors when other languages would use other data structures. Actually, we were cheating a bit when distinguishing between “scalars” and “vectors” above. Although this makes sense when introducing the notion of objects, R actually has no dedicated data structure for scalar objects. Instead, even individual numbers (i.e., objects of type “integer” or “double”) and names or text labels (i.e., objects of type “character”) are actually vectors of length 1. We can verify this by applying the is.vector() and length() functions to the scalar objects defined above:

### 1.4.5 Vector creation functions

The c() function is used for combining existing vectors. However, for creating vectors that contain more than just a few elements (i.e., vectors with larger length() values), using the c() function and then typing all vector elements becomes impractical. Useful functions and shortcuts to generate continuous or regular sequences are the colon operator : , and the functions seq() and rep() :

• seq() generates numeric sequences from an initial number from to a final number to and allows either setting the step-width by or the length of the sequence length.out :
• rep() replicates the values provided in its first argument x either times times or each element each times:

Whereas : and seq() create numeric vectors, rep() can be used with other data types:

### 1.4.6 Indexing vectors

We now have learned how inspect vectors and how to determine their type, length, names, and particular elements (see Section 1.4.1 above). But when data is primarily saved in vectors, an important question is:

The tasks of accessing, testing, or replacing vector elements (and other data structures) in R are known as indexing or subsetting. Depending on how we specify the element(s) that we wish to access, test or modify, this process comes in two main varieties (numeric vs. logical): 18

1. A numeric index simply is a number that denotes the position of an element in a sequence. Actually, we already used numeric indices above to access particular elements of vectors, for instance:

Importantly, selecting particular vector elements by an index requires enclosing their numeric position in square brackets [] . By contrast, functions always enclose their arguments in round parentheses () .

1. A logical index is a test that evaluates to one or more “logical” values (i.e., either TRUE or FALSE ). In R, we often store a large number of values in vectors (e.g., the age values of 5,000 participants), but only need some of them for answering specific questions (e.g., what is the average age of all male participants?). To select only a subset of elements from a vector v we can specify the condition or criterion for our selection in (square) brackets v[. ] .

Supplying a numeric or logical index (in square brackets) is a very flexible and powerful way for selecting elements of a vector v (or of other data structures). The following sections provide examples of these two types of indexing or subsetting. Again,
(A) Numeric indexing uses (vectors of) numbers to select (access or change) vector elements, and (B) logical indexing uses (vectors of) logical values to select (access or change) vector elements.

#### A. Numeric indexing

In numeric indexing (or numeric subsetting), we provide a numeric vector as an index to a vector. Instead of only asking for a single element, we can use a numeric vector of indices to obtain a new vector that contains the elements at the specified positions:

Actually, numeric indexing also works when elements are selected repeatedly:

Using negative indices selects all elements except the negated ones:

Importantly, the index used to select element can be the result of a function call. For instance,

Sometimes, we either know that or wonder whether a particular vector contains particular elements. The which() function uses a logical test to determine the positions for which some test is TRUE and returns the corresponding positions as a numeric vector:

If we wanted to obtain the corresponding elements, we could use these numeric vectors to index or subset the same vectors:

These last examples first used which() to obtain numeric indices of train and then applied these indices to train . This works, but seems a bit complicated. A more direct way of obtaining the same elements is provided by logical indexing.

#### B. Logical indexing

In logical indexing (or logical subsetting), we select elements of a vector v by providing a test (i.e., a vector of “logical” objects that are either TRUE or FALSE ) in square brackets. Typically, the length of the logical index corresponds to the length of the vector v .
For example, the following statement selects the 1st and 2nd elements of v1 :

As with numeric indices, we can use functions to determine the logical indices. To select elements of a vector v , we define the selection criterion as a logical test (i.e., an expression of v that returns a logical vector of the same length) and use the result to index vector v . This is called “subsetting” as it only returns the elements of v for which the criterion is TRUE .

For instance, detecting and getting all elements of v1 that are numbers below 3 could use the following criterion and indexing step:

Logical indexing allows us to repeat the selections from above (without the detour of numerical indexing by which() ):

Note that each of these selections uses a vector twice: Once to conduct a test that yields logical indices (i.e., a vector of truth values that has the same length as the original vector) and a second time to select the elements for which the test is TRUE .

A nifty way of creating vectors is to randomly draw objects from a population (see Section 1.6.4 on Random sampling).

#### Practice

As indexing/subsetting vectors is an important topic in R, we should practice it more extensively:

1. Indexing numeric vectors:
• Evaluate and explain the following code (in terms of numeric or logical indexing):
1. Indexing character vectors:
• Predict, evaluate, and explain the results of the following commands:

Assume the following definition of spices :

and then use a combination of functions and numeric or logical indexing for obtaining:

all spices, except the first two

all spices in spices with exactly 4 letters

all spices with 8 or more letters

all spices with the letter "i" at their 2nd position

#### Solution

Note: More sophisticated ways of searching text objects are covered in Appendix E on using regular expressions.

The R object LETTERS stores the 26 upper-case letters of the Roman alphabet (and letters the same letters in lower-case). Thus, the vector c("A", "B", "C") can be obtained by numerical subsetting to get the first three letters of LETTERS : LETTERS[1:3] .

Solve the following tasks by using functions and numeric or logical indexing:

How many letters are in LETTERS ?

Create a vector of all LETTERS up to N

Create a vector of the final 6 LETTERS

Create a vector of all LETTERS not contained in the LETTERS up to N

What are the positions of the vowels in LETTERS ?

Create a vector of all non-vowels in LETTERS

Hint: The letters “A,” “E,” “I,” “O,” and “U,” are vowels.

#### Solution

Having achieved some basic familiarity with vectors, we can now extend our knowledge about data structures by adding a second dimension, which will yield tables of data. A good question to ask at this point is:

Strictly speaking, only in atomic vectors are all elements of the same type, and lists are also vectors, but can have elements of different types. (See Wickham, 2014a for details.) ↩︎

MSc AI Student @ DTU. This is my Machine Learning journey ɿrom Scratch'. Conveying what I learned, in an easy-to-understand fashion is my priority.

#### Casper Hansen

What is a vector?
What are scalars?

This is the first in a series of fundamentals of Linear Algebra. The above questions is what I will focus on illustrating to you. At the end of the series, there will be a recap of how the Linear Algebra concepts you learned here, relates to Machine Learning. And after, a smaller project which uses some of the most important concepts from here.

Well firstly, how could we define a vector? In mathematics, we can think of a vector as some arrow in a coordinate system. Such a vector has vector coordinates, where the first vertical number is corresponding to x and the second corresponding to y. The notation for the below vector would be $vec=egin21end$.

We could also read it as "vector v goes 2 along the x-axis and 1 along the y-axis". It is almost always assumed that you draw from the origin, which is (0,0).

Basic vector drawn from origin $(0,0)$ to the point $(2,1)$, that forms the vector $vec=egin21end$

We can transfer the above directly to Computer Science, where you could use the data type List, which contains n amount of countable values, and these values are indexed from $to n. If we had a list of vector coordinates, but in this notation and order,$(2,4)$,$(2, -4)$and$(4,0)$, we could use the list to plot vectors on a coordinate system. Notice that the first number indicates x and the second indicates y. This could continue as we add dimensions. In this Python code, we cheated a fair bit, as we are not directly using the mathematical syntax. Quick explanation: We create an outer array with three inner arrays, we and fill the inner arrays with corresponding values to [startX, startY, endX, endY]. startX and startY is the first point, and endX and endY is the second point. We specify to the method .quiver that we use X,Y,U,V and then it gets plotted, which yields the below result: The outcome of the Python script The next incredibly important thing is called Vector Addition. Suppose we have two vectors$vec=egin21end$and$vec=egin2-2end$. How would we add these two vectors? It's quite simple. Both vectors have an x and y value, corresponding to the first and second number in the vector. We would add them like this: Or more generally we could have a near infinite number of vectors going way further than just 2-dimensional: Theoretically, we could present vector addition in an$m imes n$matrix. In such a matrix, we could perform the vector addition operation or any other operation in linear algebra: It would certainly be impossible to plot a 1000-dimensional vector, but it would be possible to use data sets that ressembles that many dimensions. If we were to stay in this 2-dimensional space, we could just continue to plot points and draw vectors from one point to another. Here is an illustrative example with the two vectors$vec=egin21end$and$vec=egin2-2end$. Notice how we have placed the two vectors now. We have a tail and head, where tail is the start of the vector and head the end of the vector. So we have taken$vec

## 1: Vector Basics

Let’s start this section off with a quick discussion on what vectors are used for. Vectors are used to represent quantities that have both a magnitude and a direction. Good examples of quantities that can be represented by vectors are force and velocity. Both of these have a direction and a magnitude.

Let’s consider force for a second. A force of say 5 Newtons that is applied in a particular direction can be applied at any point in space. In other words, the point where we apply the force does not change the force itself. Forces are independent of the point of application. To define a force all we need to know is the magnitude of the force and the direction that the force is applied in.

The same idea holds more generally with vectors. Vectors only impart magnitude and direction. They don’t impart any information about where the quantity is applied. This is an important idea to always remember in the study of vectors.

In a graphical sense vectors are represented by directed line segments. The length of the line segment is the magnitude of the vector and the direction of the line segment is the direction of the vector. However, because vectors don’t impart any information about where the quantity is applied any directed line segment with the same length and direction will represent the same vector.

Consider the sketch below.

Each of the directed line segments in the sketch represents the same vector. In each case the vector starts at a specific point then moves 2 units to the left and 5 units up. The notation that we’ll use for this vector is,

[vec v = leftlangle < - 2,5> ight angle ]

and each of the directed line segments in the sketch are called representations of the vector.

Be careful to distinguish vector notation, (leftlangle < - 2,5> ight angle ), from the notation we use to represent coordinates of points, (left( < - 2,5> ight)). The vector denotes a magnitude and a direction of a quantity while the point denotes a location in space. So don’t mix the notations up!

A representation of the vector (vec v = leftlangle <,> ight angle ) in two dimensional space is any directed line segment, (overrightarrow ), from the point (A = left( ight)) to the point (B = left( ,y + > ight)). Likewise a representation of the vector (vec v = leftlangle <,,> ight angle ) in three dimensional space is any directed line segment, (overrightarrow ), from the point (A = left( ight)) to the point (B = left( ,y + ,z + > ight)).

Note that there is very little difference between the two dimensional and three dimensional formulas above. To get from the three dimensional formula to the two dimensional formula all we did is take out the third component/coordinate. Because of this most of the formulas here are given only in their three dimensional version. If we need them in their two dimensional form we can easily modify the three dimensional form.

There is one representation of a vector that is special in some way. The representation of the vector (vec v = leftlangle <,,> ight angle ) that starts at the point (A = left( <0,0,0> ight)) and ends at the point (B = left( <,,> ight)) is called the position vector of the point (left( <,,> ight)). So, when we talk about position vectors we are specifying the initial and final point of the vector.

Position vectors are useful if we ever need to represent a point as a vector. As we’ll see there are times in which we definitely are going to want to represent points as vectors. In fact, we’re going to run into topics that can only be done if we represent points as vectors.

Next, we need to discuss briefly how to generate a vector given the initial and final points of the representation. Given the two points (A = left( <,,> ight)) and (B = left( <,,> ight)) the vector with the representation (overrightarrow ) is,

Note that we have to be very careful with direction here. The vector above is the vector that starts at (A) and ends at (B). The vector that starts at (B) and ends at (A), i.e. with representation (overrightarrow ) is,

These two vectors are different and so we do need to always pay attention to what point is the starting point and what point is the ending point. When determining the vector between two points we always subtract the initial point from the terminal point.

1. The vector from (left( <2, - 7,0> ight)) to (left( <1, - 3, - 5> ight)).
2. The vector from (left( <1, - 3, - 5> ight)) to(left( <2, - 7,0> ight)).
3. The position vector for (left( < - 90,4> ight))

Remember that to construct this vector we subtract coordinates of the starting point from the ending point.

[leftlangle <1 - 2, - 3 - left( < - 7> ight), - 5 - 0> ight angle = leftlangle < - 1,4, - 5> ight angle ]

[leftlangle <2 - 1, - 7 - left( < - 3> ight),0 - left( < - 5> ight)> ight angle = leftlangle <1, - 4,5> ight angle ]

Notice that the only difference between the first two is the signs are all opposite. This difference is important as it is this difference that tells us that the two vectors point in opposite directions.

Not much to this one other than acknowledging that the position vector of a point is nothing more than a vector with the point’s coordinates as its components.

We now need to start discussing some of the basic concepts that we will run into on occasion.

#### Magnitude

The magnitude, or length, of the vector (vec v = leftlangle <,,> ight angle ) is given by,

1. (vec a = leftlangle <3, - 5,10> ight angle )
2. (displaystyle vec u = leftlangle <>, - frac<2><>> ight angle )
3. (vec w = leftlangle <0,0> ight angle )
4. (vec i = leftlangle <1,0,0> ight angle )

There isn’t too much to these other than plug into the formula.

b (displaystyle left| ight| = sqrt <5>+ frac<4><5>> = sqrt 1 = 1)

We also have the following fact about the magnitude.

This should make sense. Because we square all the components the only way we can get zero out of the formula was for the components to be zero in the first place.

#### Unit Vector

Any vector with magnitude of 1, i.e. (left| ight| = 1), is called a unit vector.

Both the second and fourth vectors had a length of 1 and so they are the only unit vectors from the first example.

#### Zero Vector

The vector (vec w = leftlangle <0,0> ight angle ) that we saw in the first example is called a zero vector since its components are all zero. Zero vectors are often denoted by (vec 0). Be careful to distinguish 0 (the number) from (vec 0) (the vector). The number 0 denotes the origin in space, while the vector (vec 0) denotes a vector that has no magnitude or direction.

#### Standard Basis Vectors

The fourth vector from the second example, (vec i = leftlangle <1,0,0> ight angle ), is called a standard basis vector. In three dimensional space there are three standard basis vectors,

[vec i = leftlangle <1,0,0> ight angle hspace<0.25in>vec j = leftlangle <0,1,0> ight angle hspace<0.25in>vec k = leftlangle <0,0,1> ight angle ]

In two dimensional space there are two standard basis vectors,

[vec i = leftlangle <1,0> ight angle hspace<0.25in>vec j = leftlangle <0,1> ight angle ]

Note that standard basis vectors are also unit vectors.

We are pretty much done with this section however, before proceeding to the next section we should point out that vectors are not restricted to two dimensional or three dimensional space. Vectors can exist in general n-dimensional space. The general notation for a n-dimensional vector is,

[vec v = leftlangle <,,, ldots ,> ight angle ]

and each of the ()’s are called components of the vector.

Because we will be working almost exclusively with two and three dimensional vectors in this course most of the formulas will be given for the two and/or three dimensional cases. However, most of the concepts/formulas will work with general vectors and the formulas are easily (and naturally) modified for general n-dimensional vectors. Also, because it is easier to visualize things in two dimensions most of the figures related to vectors will be two dimensional figures.

So, we need to be careful to not get too locked into the two or three dimensional cases from our discussions in this chapter. We will be working in these dimensions either because it’s easier to visualize the situation or because physical restrictions of the problems will enforce a dimension upon us.

We may know a vector's magnitude and direction, but want its x and y lengths (or vice versa):

 <=> Vector a in Polar Coordinates Vector a in Cartesian Coordinates

You can read how to convert them at Polar and Cartesian Coordinates, but here is a quick summary:

• x = r × cos( &theta )
• y = r × sin( &theta )
• r = &radic ( x 2 + y 2 )
• &theta = tan -1 ( y / x )

## Direction of a line (3 dimensions)

This 1997 question hopes for a way to indicate the direction of a 3-dimensional vector similar to the angle or slope in the previous type of problem:

The two standard forms he mentions for a plane are, in effect, $a’x + b’y + c’z = d’$ where the vector (a‘, b‘, c‘) is a unit vector called the unit normal vector (this is something we will see later in this series or a subsequent series), and $frac + frac + frac = 1$ where A, B, and C are the intercepts on the three axes. The normal vector represents the direction of the plane.

But the question was about a line, and the “direction cosines” just mentioned for the unit normal vector show up here, too:

We could say, however, that the triple ratio a : b : c is a reasonable analogue of the slope of a line, even though it is not a number the direction cosines, as we’ll see below, are just the components of the unit vector in the direction of the line.

## Scalar Multiplication

We can increase or decrease the magnitude of a vector by multiplying the vector by a scalar.

### Example 3 - Scalar Multiplication

In the examples we saw earlier, vector B (2 units) is half the size of vector A (which is 4 units) . We can write:

B = 0.5 A

This is an example of a scalar multiple. We have multiplied the vector A by the scalar 0.5.

### Example 4 - Scalar Multiplication

We have 3 weights tied to a beam.

The first weight is W1 = 5 N, the second is W2 = 2 N and the third is W3 = 4 N.

We can represent these weights using a vector diagram (where the length of the vector represents the magnitude) as follows:

They are vectors because they all have a direction (down) and a magnitude.

Each of the following scalar multiples is true for this situation:

Since 5 = 2.5 × 2, we can write:

Since 2 = 0.5 × 4, we can write:

Since 4 = 0.8 × 5, we can write:

Each of these statements is a scalar multiplication.

Following member types can be used as parameters or return type by member functions.

Sr.No. Member types Definition
1 value_type T (First parameter of the template)
2 allocator_type Alloc (Second parameter of the template)
3 reference value_type&
4 const_reference const value_type&
5 pointer value_type*
6 const_pointer const value_type*
7 iterator a random access iterator to value_type
8 const_iterator a random access iterator to const value_type
9 reverse_iterator std::reverse_iterator <iterator>
10 const_reverse_iterator std::reverse_iterator <const_iterator>
11 size_type size_t
12 difference_type ptrdiff_t

## Why Use Vectors in C++

Vectors C++ are preferable when managing ever-changing data elements.

It is handy if you don’t know how big the data is beforehand since you don’t need to set the maximum size of the container. Since it’s possible to resize C++ vectors, it offers better flexibility to handle dynamic elements.

C++ vectors offer excellent efficiency. It is a template class, which means no more typing in the same code to handle different data.

If you use vectors, you can copy and assign other vectors with ease. There are different ways to do that: using the iterative method, assignment operator = , an in-built function, or passing vector as a constructor.

In C++ vectors, automatic reallocation happens whenever the total amount of memory is used. This reallocation relates to how size and capacity function works.

Adenoviruses were among the first viruses investigated as potential gene therapy vectors. Wild-type Adenoviruses are known to cause respiratory tract infections, .i.e., “the common cold”, in humans, and they can also infect other organs such as the brain and bladder. More than 50 distinct Adenoviral serotypes have been found that infect humans, and serotypes 2 and 5 are the most extensively characterized ones. There are also over 30 non-human primate Adenoviruses that have been isolated and characterized, e.g. from chimpanzees.

### Adenovirus vectors in gene therapy

Adenovirus vectors are commonly engineered by removing the E1 region, responsible for replication, and other “early phase” genes, and replacing them with the transgene. The packaging capacity of ordinary Adenovirus vectors is

8 kb. Adenovirus vectors are produced in HEK293 cell lines with stably express E1 proteins allowing for replication and packaging. Nowadays it is also possible to engineer Adenovirus vectors by removing almost all viral genes. These so-called “high-capacity”, “gutless”, or “helper-dependent” Adenovirus vectors can accommodate inserts as large as

36 kb. They are attractive not only because of significantly larger capacity, but also because of stable expression and reduced immunogenicity [15,16]. Production of such Adenovirus vectors requires modified helper viruses and modified HEK293 producer cell lines. Helper virus contaminants need to be effectively removed from the final preparation, making the production of high-capacity Adenovirus vectors more challenging.

Adenoviruses are attractive vehicles for gene therapy mainly because of their high packaging capacity. Adenovirus vectors can also transfect both dividing and non-dividing cells in a broad range of cell and tissue types. The Adenovirus DNA does not integrate into the host genome but remains episomal. Thus Adenovirus vectors are suitable for therapeutics that need high, but temporary, gene expression. Some vaccines and oncolytic therapies benefit from the immunogenicity and cellular toxicity of the Adenovirus vectors, but constitute a major obstacle for most gene therapies.

The most significant limitation of Adenovirus vectors is pre-existing immunity in patients and the substantial immune response they may trigger. Most adults have been exposed to Adenoviruses, as they are common pathogens in humans, andthus the immune system will also attack the Adenovirus-based therapeutic vector. If this is the case, the body will recognize the proteins on the Adenovirus vector shells and destroy them before the therapeutic gene is delivered. Several strategies are being employed to circumvent pre-existing immunity against Adenovirus vectors, such as the use of rare human serotypes or non-human Adenovirus vectors, e.g., chimpanzee-derived, shielding the surface of Adenoviruses with polyethylene glycol, or encapsulating the vectors into alginate microspheres [17]. Despite the developments in Adenovirus vector engineering, they can still trigger host immunogenicity and cellular toxicity [18].

### Examples of commercially available adenovirus vector-based products

#### References

[3] Erika Check. Regulators split on gene therapy as patient shows signs of cancer. Nature 2002 419: 545–546. https://www.nature.com/articles/419545a#rightslink

[4] David RM, Doherty AT. Viral Vectors: The Road to Reducing Genotoxicity. Toxicol Sci. 2017155(2):315-325.

[5] Nayak S, Herzog RW. Progress and prospects: immune responses to viral vectors. Gene Ther. 201017 :295-304. https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3044498/

[6] Atchison, R. W., Casto, B. C. & Hammon, W. M. Adenovirus-associated defective virus particles. Science 149, 754–756 (1965). 124. Matsushita, T. et al.

[7] Vandenberghe, L., Wilson, J. & Gao, G. Tailoring the AAV vector capsid for gene therapy. Gene Ther 2009 16: 311–319 https://www.nature.com/articles/gt2008170

[8] Claire Domenger, Dirk Grimm. Next-generation AAV vectors—do not judge a virus (only) by its cover. Human Molecular Genetics 2019 28: R3–R14. https://academic.oup.com/hmg/article/28/R1/R3/5526799?login=true

[9] McClements ME, MacLaren RE. Adeno-associated Virus (AAV) Dual Vector Strategies for Gene Therapy Encoding Large Transgenes. Yale J Biol Med. 2017 1990(4):611-623. https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5733846/

[15] Liu J, Seol DW. Helper virus-free gutless adenovirus (HF-GLAd): a new platform for gene therapy. BMB Rep. 202053(11):565-575. https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7704218/#ref7

[16] Ricobaraza A., et al. High-Capacity Adenoviral Vectors: Expanding the Scope of Gene Therapy. Int J Mol Sci. 2020 2121(10):36. https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7279171/

[17] Vemula SV, Mittal SK. Production of adenovirus vectors and their use as a delivery system for influenza vaccines. Expert Opin Biol Ther. 201010(10):1469-87https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2951029/

[18] Wang, Q. & Finer, M. H. Second-generation adenovirus vectors. Nat. Med. 2, 714–716 (1996).