Creating & Editing Arrays — Create and edit arrays...

SECTION 1

Historical Context & Motivation

Repetitive geometric patterns — bolt-hole circles on a flange, rows of windows on a façade, evenly spaced stanchions along a curved highway ramp — are ubiquitous in engineering and architectural drawings. Before computer-aided design, drafters used dividers, protractors, and tedious manual measurement to place each copy of a repeated element. The earliest releases of AutoCAD (1982) shipped with a rudimentary ARRAY command that could duplicate objects in a rectangular grid or around a center point, but the parameters were entered in a modal dialog box, and the result was immediately exploded into independent copies — no associativity, no parametric editing. Over subsequent decades Autodesk steadily improved the command, eventually introducing a fully associative array paradigm in AutoCAD 2012 that preserves the parent-child relationship between source objects and their copies, enabling live, grip-editable adjustment of row count, column spacing, angular fill, and path curvature long after the array is created.

1982

AutoCAD Release 1

The first commercial release includes a basic ARRAY command with rectangular and polar modes. Output is non-associative — each copy is an independent entity.

2000

Dialog-Box Era

AutoCAD 2000 refines the ARRAY dialog, adding preview capabilities and improved polar-array angle controls, but the results remain static copies.

2012

Associative Arrays Introduced

AutoCAD 2012 replaces the legacy dialog with ribbon-based ARRAYRECT, ARRAYPOLAR, and ARRAYPATH commands. Arrays become associative: changes to the source object propagate to every instance, and parameters are editable via grips.

2019

Enhanced Path Arrays

Improved tangent-direction controls and divide/measure modes let path arrays distribute items evenly along complex splines and polylines, crucial for civil-engineering alignments.

2024

Modern Productivity

Current releases add contextual tabs, dynamic input refinements, and count-field support, integrating arrays into data-extraction and annotation workflows.

The central question the array feature addresses is deceptively simple: how can a designer replicate geometry parametrically — maintaining a single source of truth — while supporting the three most common distribution patterns encountered in practice: rows-and-columns (rectangular), radial symmetry (polar), and alignment along an arbitrary curve (path)? Answering this question with the modern associative array framework is the focus of this lesson.

SECTION 2

Core Principles & Definitions

All three array types share a common conceptual architecture. A source object (or set of objects) is designated as the template, and AutoCAD generates instances — lightweight references — at computed positions. Because the array is associative, modifying the source object automatically updates every instance, and the distribution parameters (counts, spacings, angles) remain editable through grips or the Properties palette. Understanding the five foundational ideas below will give you a mental model that transfers cleanly across rectangular, polar, and path arrays.

Associativity

The array maintains a live link between the source object and all instances. Editing the source geometry propagates changes to every copy. This can be broken with EXPLODE if independent copies are needed.

Base Point

Each array uses a base point to anchor placement calculations. For rectangular arrays this is the lower-left corner of the bounding box by default; for polar arrays it is the center of rotation; for path arrays it is the start of the path curve.

Count & Spacing

Arrays are driven by either explicit counts (number of rows, columns, or items) or total extents (overall distance or angle), from which spacing is derived. These two parameters are interdependent — changing one recalculates the other.

Levels (3D Extension)

All array types support an optional Z-direction level count, enabling three-dimensional distributions (e.g., a grid of bolts repeated at multiple floor elevations). Levels add a third parametric axis to the distribution.

Grip Editing

After creation, selecting an associative array reveals specialized grips — triangles for spacing, arrows for direction, and squares for count. These grips provide in-canvas, real-time parametric adjustment without reopening a dialog.

✦ KEY TAKEAWAY

Think of an associative array like a class definition in object-oriented programming. The source object is the class, each instance is an object instantiated from it, and the array parameters (count, spacing, angle) are constructor arguments. Changing the class definition updates every object; changing a constructor argument restructures the layout without touching the class itself.

SECTION 3

Visual Explanation — The Three Array Types

The three array types side by side. Rectangular (left) distributes objects along rows and columns. Polar (center) distributes objects around a center point through a specified fill angle. Path (right) distributes objects along an arbitrary curve, optionally aligning each item tangent to the path. The dashed gold outlines indicate the source object in each array.

The diagram above illustrates the fundamental spatial logic behind each array type. In the rectangular array, two independent spacing vectors (row and column) define a Cartesian grid; the product of row count and column count yields the total instance count. In the polar array, a center point and a fill angle replace the Cartesian grid; each item is placed at an angular increment computed as the fill angle divided by the item count (or item count minus one, depending on whether the last position coincides with the first). The path array is the most flexible: instances are distributed along a spline, polyline, arc, or any drawable curve, with the option to rotate each instance so that its local X-axis aligns tangent to the path at that point. Notice how the source object (dashed gold) anchors each array — moving or editing it will propagate throughout the associative array.

SECTION 4

Mathematical Framework

Although AutoCAD handles the computations internally, understanding the underlying mathematics helps you predict results and debug unexpected layouts. Each array type reduces to a simple transformation model rooted in linear algebra — translations for rectangular arrays, rotation matrices for polar arrays, and arc-length parameterization for path arrays.

RECTANGULAR ARRAY POSITION

P(i, j) = P₀ + i × Δcol + j × Δrow

Where P₀ is the base point, i is the column index (0 to cols − 1), j is the row index (0 to rows − 1), Δcol is the column-spacing vector, and Δrow is the row-spacing vector. Total instances = rows × columns.

POLAR ARRAY POSITION

θₖ = θ₀ + k × (fillAngle / (n − 1)) for k = 0, 1, …, n − 1

Where θ₀ is the starting angle of the source object measured from the center, n is the total item count, and fillAngle is the total angular sweep. The position of instance k is (Cx + r·cos θₖ, Cy + r·sin θₖ) where (Cx, Cy) is the center and r is the radius.

PATH ARRAY — DIVIDE METHOD

sₖ = (k / (n − 1)) × L for k = 0, 1, …, n − 1

Where L is the total arc length of the path curve, n is the item count, and sₖ is the arc-length parameter at which instance k is placed. If 'Align Items' is enabled, each instance is rotated so its local X-axis equals the unit tangent vector T(sₖ) of the path at that point.

PATH ARRAY — MEASURE METHOD

sₖ = k × d where n = ⌊L / d⌋ + 1

In the Measure method, a fixed spacing distance d is specified rather than a total item count. The number of items is computed as ⌊L / d⌋ + 1 (floor division plus the starting item), and any remainder at the end of the path is left empty.

💡 Divide vs. Measure

The Divide method guarantees that items appear at both endpoints of the path, adjusting spacing to fit. The Measure method guarantees a fixed spacing but may leave a gap at the far end. This distinction mirrors the difference between the DIVIDE and MEASURE point-placement commands in AutoCAD.

SECTION 5

Detailed Breakdown of Each Array Type

Rectangular Arrays (ARRAYRECT)

Invoked via the ARRAYRECT command (or by selecting Rectangular from the ARRAY ribbon panel), this type distributes objects along orthogonal rows and columns. After selecting the source objects and pressing Enter, the contextual Array Creation tab appears on the ribbon. Here you can set column count and column spacing (the X-direction), row count and row spacing (the Y-direction), and optionally levels and level spacing (the Z-direction). The total extents are always count × spacing; adjusting one parameter while holding total constant recalculates the other. An incremental elevation field allows each successive row to step upward in Z, useful for staircase or ramp geometry.

Polar Arrays (ARRAYPOLAR)

The ARRAYPOLAR command arranges instances in a circular pattern around a user-specified center of rotation. Key parameters include item count, fill angle (default 360° for a full circle), and angle between items. The 'Rotate Items' toggle determines whether each instance is rotated to maintain its orientation relative to the center, which is critical for elements like gear teeth or turbine blades that must point radially. A row offset parameter can distribute items across multiple concentric rings, each with an incrementally different radius.

Path Arrays (ARRAYPATH)

The ARRAYPATH command distributes objects along a selected path object — a line, arc, polyline, spline, helix, or circle. The distribution method is either Divide (specify item count; spacing is computed) or Measure (specify spacing; item count is computed). The Align Items option rotates each instance so that its X-axis aligns with the tangent of the path, and the Z Direction option maintains or varies the vertical orientation when the path curves in 3D space. Row offsets and levels can also be applied, creating multi-track distributions parallel to the original path.

A side-by-side reference card for the key parameters of each array type. Notice how rectangular arrays use row/column semantics, polar arrays use angular semantics, and path arrays introduce the path object and method (Divide vs. Measure) as first-class parameters.

SECTION 6

Worked Example — Bolt-Hole Pattern on a Flange

A mechanical flange drawing requires 12 equally spaced bolt holes on a circle of radius 150 mm centered at (0, 0). Each bolt hole is a circle of diameter 20 mm. We need a polar array that distributes the source circle through a full 360° and rotates each instance appropriately.

Creating a 12-Hole Polar Array

Step 1 — Draw the Source ObjectUse the CIRCLE command to draw a circle of radius 10 mm (diameter 20 mm) at point (150, 0). This places the first bolt hole at the 3-o'clock position on the bolt circle.

Source circle created at (150, 0) with r = 10 mm.

Step 2 — Invoke ARRAYPOLARType ARRAYPOLAR and press Enter (or navigate to Home → Modify → Array → Polar Array on the ribbon). Select the source circle and press Enter to confirm the selection set.

Array creation mode entered; contextual tab appears.

Step 3 — Specify Center of RotationWhen prompted for the center point, type 0,0 and press Enter. This is the center of the flange. The preview should immediately show a default array — typically 6 items over 360° — which we will modify next.

Center point set to (0, 0).

Step 4 — Set Item Count and Fill AngleOn the contextual Array Creation tab, set Items to 12 and Fill Angle to 360°. The angle between items will automatically calculate to 360° / 12 = 30°. Verify in the preview that the 12 circles are evenly distributed. Note that 'Rotate Items' should be set to Yes, though for circles this has no visual effect — it matters for non-symmetric source objects.

12 items at 30° increments over full 360°.

Step 5 — Close the Array and VerifyClick Close Array on the ribbon (or press Enter). Select the array to confirm it is a single associative entity. Open the Properties palette (Ctrl+1) to verify: Type = Polar, Items = 12, Fill Angle = 360, Radius = 150. To modify later, double-click the array to re-enter the Array Editing state and adjust parameters through grips or the Properties palette.

Associative polar array with 12 bolt holes at r = 150 mm, fully editable.

⚡ Pro Tip: Editing After Creation

After closing the array, you can double-click any instance to enter the source-editing state. Changes made here — such as resizing the bolt-hole diameter — propagate to all 12 instances automatically. You can also select an individual item and use the ARRAYEDIT command to replace, reset, or delete specific instances while keeping the rest of the array intact.

SECTION 7

Strengths, Limitations & When to Use Each

Comparison of the three array types across key criteria

Criterion	Rectangular	Polar	Path
Best For	Grids, tile patterns, structural column layouts, parking spaces	Bolt circles, clock faces, gear teeth, radial fan blades	Fencing along roads, guardrails on curves, light fixtures along corridors
Geometry Constraint	Orthogonal rows & columns (can rotate the entire array post-creation)	Circular distribution around a single center	Any 2D/3D curve (line, arc, polyline, spline, helix)
Spacing Control	Independent X and Y spacing	Angular increment or total fill angle	Divide (equal) or Measure (fixed distance)
Rotation of Items	Not applicable (all items maintain orientation)	Optional — each item can rotate to face center	Optional — each item can align tangent to path
Limitation	Cannot follow curves; restricted to linear grid	Single radius unless row offset is used; cannot follow non-circular curves	More complex setup; path object must exist before array creation
Typical Instance Count	Tens to hundreds (rows × columns)	6 to 72 (angular symmetry)	Varies widely with path length

✦ KEY TAKEAWAY

Choosing the right array type is analogous to choosing a data structure in software engineering: an array list (rectangular) is ideal when you need indexed access by row and column; a circular buffer (polar) excels for cyclic, rotationally symmetric patterns; and a linked list threaded along an iterator (path) is the natural choice when the distribution follows an arbitrary traversal order. Selecting the wrong type creates unnecessary complexity, just as forcing a linked list where a hash map belongs leads to O(n) lookups.

SECTION 8

Connection to Advanced Workflows

Associative arrays are not isolated features — they integrate into broader AutoCAD and CAD-ecosystem workflows. Understanding how arrays connect to advanced topics prepares you for production-level project work and certifications.

Mapping introductory array concepts to their advanced counterparts

Introductory Concept	Advanced Extension
Associative arrays with grip editing	Dynamic blocks with array actions, where the array parameters are exposed as block properties and can be constrained by geometric and dimensional constraints
Single source object propagation	ARRAYEDIT's 'Replace Items' option allows per-instance overrides; combined with data extraction, this supports BOM (Bill of Materials) generation with variant tracking
2D rectangular arrays for floor plans	3D arrays using levels to generate multi-story building frameworks; integration with BIM workflows through IFC export
Path arrays along polylines	Civil 3D alignment-based distribution where items are arrayed along horizontal and vertical alignments with superelevation-aware rotation
Manual ARRAYPOLAR for bolt patterns	AutoLISP / .NET API scripting (e.g., using the ObjectARX AcDbAssocArrayParameters class) to programmatically generate arrays with computed parameters from spreadsheet data

For computer science students, the API angle is particularly relevant. AutoCAD's .NET API exposes the AcDbAssocArrayActionBody class hierarchy, which mirrors the three array types discussed here. You can programmatically create an AcDbAssocArrayRectangularParameters object, set its row count, column count, and spacing properties, and attach it to a selection set — the same workflow you perform interactively, but scriptable and suitable for batch processing. This bridges the gap between interactive CAD operation and computational design automation, a rapidly growing field where parametric geometry generation is driven by algorithms rather than manual input.

SECTION 9

Practice Problems

PROBLEM 1 — CONCEPTUAL

Explain the difference between an associative array and a non-associative (exploded) array. Under what circumstances would a designer intentionally explode an array, and what capability is lost by doing so?

PROBLEM 2 — BASIC CALCULATION

A rectangular array has 5 columns with a column spacing of 3.0 units and 4 rows with a row spacing of 2.5 units. Calculate (a) the total number of instances, (b) the total X-extent of the array, and (c) the total Y-extent of the array.

PROBLEM 3 — INTERMEDIATE

You need to create a polar array of 8 equally spaced items over a fill angle of 270° (not a full circle). What is the angular increment between consecutive items? If the first item is at 0°, at what angle does the last item appear? Now suppose you change the fill angle to 360° while keeping 8 items — how does the angular increment change, and does the last item overlap the first?

PROBLEM 4 — APPLIED

A civil engineer needs to place guardrail posts every 2.0 meters along a highway curve modeled as a spline with a total arc length of 53.7 meters. Using the Measure method for a path array, how many posts will be placed? Where along the path will the last post appear, and how much of the path remains unoccupied beyond it? If the Divide method were used instead with the same number of posts, what would the spacing become?

PROBLEM 5 — CRITICAL THINKING

Consider an architectural design where a decorative column must be arrayed along a spline-shaped balcony edge, but the column's cross-section is asymmetric (wider on one side). The designer wants each column to lean outward from the building. Discuss how the 'Align Items' and 'Z Direction' settings of a path array interact with this requirement, and propose a strategy — including potential use of base-point repositioning — to achieve the desired orientation without exploding the array.

SUMMARY

Lesson Summary

AutoCAD's array system provides three parametric distribution modes — rectangular (ARRAYRECT) for Cartesian grids defined by row count, column count, and independent X/Y spacings; polar (ARRAYPOLAR) for circular patterns defined by a center point, item count, and fill angle; and path (ARRAYPATH) for distribution along any curve using the Divide or Measure method. All three types produce associative arrays — single entities whose source geometry and layout parameters remain editable through grip editing and the Properties palette long after creation.

The mathematical models underlying each type reduce to straightforward transformations: translation vectors for rectangular, rotation about a center with angular increments for polar, and arc-length parameterization with tangent alignment for path. These concepts connect directly to advanced workflows including dynamic blocks, API-driven automation via ObjectARX/.NET, and 3D multi-level distributions. Selecting the correct array type for a given design pattern — much like choosing the right data structure for an algorithm — is the key skill that transforms a manual, error-prone copy-paste workflow into a robust, parametrically editable solution.