On 20 million rows already in memory, the aggregation by category takes about 500 milliseconds in pandas 3.1.1 and about 50 in Polars 2.1.0; reading a 735 MB CSV, on the other hand, is almost a tie. Polars' advantage is not uniform: it depends on the operation, on the file format, on how much work the engine manages to skip and on how many cores it has available. Here you find the measurements, the program to repeat them and the points where the migration costs more than it returns.
Prerequisites. Python and a bit of pandas; DuckDB appears in only one example and you do not need to know it beforehand.
What is measured, and how
A performance comparison is only as good as the method behind it, so I state it in full. The figures in this article are mine and come from the listing that follows; no number is taken from articles, vendor sites or third-party benchmarks. They change if you change machine, versions or data, which is why the program prints an interval and not a single value. The conditions are these:
- machine: AMD Ryzen 5 5600H with 12 logical threads, 30 GB of RAM, local disk, files already in the operating system cache;
- software: Python 3.14.4, pandas 3.1.1, Polars 2.1.0, PyArrow 26.0.1, all current versions as of 2026-11-13;
- data: 20 million synthetic rows with a fixed seed (numpy
default_rng(42)), a 735 MB CSV and the same content as a 248 MB Parquet file; - stopwatch: 5 repetitions per task in a new Python process, reported as minimum, median and maximum;
- memory: the peak resident memory (
ru_maxrss) of the process, which includes the loaded data and not only the cost of the operation.
Two limits must be stated right away. The first repetition includes startup effects (loading of libraries and caches) that the others do not have, and you see it in the maximum, often far from the median. Moreover the data are synthetic and uniform: on real data with long strings, many columns or unbalanced keys the proportions change. Before deciding, repeat the measurements on your own files.
The test dataset
The generator writes an orders file with four columns (a text category with eight values, a decimal amount, an integer quantity, an integer key) and a table of 1 million discounts for the join. The fixed seed makes the data identical on every run, checked by comparing the output of two launches. The DataFrame is created directly in Polars and saved in two formats, because the difference between CSV and Parquet is one of the most important results. The column names and the category values are in Italian, as in the original run: categoria is the category, valore the amount, quantita the quantity and chiave the key, and the categories are groceries, home, electronics, books, sports, garden, fashion and games.
import numpy as np, polars as pl, pathlib
pathlib.Path("dati").mkdir(exist_ok=True)
rng = np.random.default_rng(42) # fixed seed: same data on every run
n = 20_000_000
categorie = np.array(["alimentari", "casa", "elettronica", "libri", "sport", "giardino", "moda", "giochi"])
df = pl.DataFrame({
"categoria": categorie[rng.integers(0, len(categorie), n)],
"valore": rng.normal(100.0, 15.0, n),
"quantita": rng.integers(1, 1000, n),
"chiave": rng.integers(0, 1_000_000, n),
})
df.write_csv("dati/ordini.csv")
df.write_parquet("dati/ordini.parquet")
# small table for the join: 1 million keys, each with a discount band
rng2 = np.random.default_rng(7)
dim = pl.DataFrame({"chiave": np.arange(1_000_000), "sconto": rng2.integers(0, 30, 1_000_000)})
dim.write_parquet("dati/sconti.parquet")
for f in ("ordini.csv", "ordini.parquet", "sconti.parquet"):
print(f"{f}: {pathlib.Path('dati', f).stat().st_size / 1e6:.0f} MB")
print(df.head(3))
# Output:
# ordini.csv: 735 MB
# ordini.parquet: 248 MB
# sconti.parquet: 2 MB
# shape: (3, 4)
# ┌────────────┬────────────┬──────────┬────────┐
# │ categoria ┆ valore ┆ quantita ┆ chiave │
# │ --- ┆ --- ┆ --- ┆ --- │
# │ str ┆ f64 ┆ i64 ┆ i64 │
# ╞════════════╪════════════╪══════════╪════════╡
# │ alimentari ┆ 116.222483 ┆ 698 ┆ 958520 │
# │ moda ┆ 114.125745 ┆ 756 ┆ 689173 │
# │ giardino ┆ 86.871773 ┆ 423 ┆ 834971 │
# └────────────┴────────────┴──────────┴────────┘
The Parquet file weighs a third of the CSV (248 MB against 735 MB) because it stores the columns with a type and compresses them; it also carries the type of every column with it, while the CSV forces the reader to guess it. If you have the choice, a file that passes from one pipeline to another is better in Parquet; the CSV remains the exchange format with whoever cannot read anything else.
The four tasks
The file compiti.py ("tasks") runs one task with one engine and prints time and memory. Aggregation and join start from data already in memory, to measure only the operation; reading the CSV and reading the Parquet with a filter instead measure the whole path from disk to result. For Parquet I added a third contender, pandas_filters: pandas can pass the filter to the Parquet reader with the filters parameter, and ignoring it would make the comparison unfair to pandas.
"""One task at a time, in a new process: python compiti.py <task> <engine>"""
import resource, sys, time
compito, motore = sys.argv[1], sys.argv[2]
REPS = 5
def prepara():
"""Loads the data OUTSIDE the stopwatch, for the tasks that measure only the operation."""
if motore == "pandas":
import pandas as pd
return pd.read_parquet("dati/ordini.parquet"), pd.read_parquet("dati/sconti.parquet")
import polars as pl
return pl.read_parquet("dati/ordini.parquet"), pl.read_parquet("dati/sconti.parquet")
def gruppi(d):
ordini, _ = d
if motore == "pandas":
return ordini.groupby("categoria").agg(valore=("valore", "mean"), quantita=("quantita", "sum"))
import polars as pl
return ordini.group_by("categoria").agg(pl.col("valore").mean(), pl.col("quantita").sum())
def join(d):
ordini, sconti = d
if motore == "pandas":
return ordini.merge(sconti, on="chiave", how="inner")
return ordini.join(sconti, on="chiave", how="inner")
def csv(_):
if motore == "pandas":
import pandas as pd
return pd.read_csv("dati/ordini.csv")
import polars as pl
return pl.read_csv("dati/ordini.csv")
def parquet_filtro(_):
# reads the file AND applies filter and aggregation: the whole path counts
if motore == "pandas":
import pandas as pd
df = pd.read_parquet("dati/ordini.parquet")
return df[df["quantita"] > 990].groupby("categoria")["valore"].mean()
if motore == "pandas_filters":
import pandas as pd
df = pd.read_parquet("dati/ordini.parquet", filters=[("quantita", ">", 990)])
return df.groupby("categoria")["valore"].mean()
import polars as pl
return (pl.scan_parquet("dati/ordini.parquet").filter(pl.col("quantita") > 990)
.group_by("categoria").agg(pl.col("valore").mean()).collect())
FUNZ = {"gruppi": gruppi, "join": join, "csv": csv, "parquet_filtro": parquet_filtro}
dati = prepara() if compito in ("gruppi", "join") else None
tempi = []
for _ in range(REPS):
t0 = time.perf_counter()
FUNZ[compito](dati)
tempi.append(time.perf_counter() - t0)
tempi.sort()
mediana = tempi[len(tempi) // 2]
rss_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024
print(f"{tempi[0]*1000:.0f} {mediana*1000:.0f} {tempi[-1]*1000:.0f} {rss_mb:.0f}")
Each task runs in its own process, so the memory of one does not pollute that of another. The Polars engine uses pl.scan_parquet for the case with a filter: it is the lazy read, which builds a plan and reads only the columns and rows that are needed. The driver below launches the processes and collects the results; on every run the intervals change by a few percentage points. Since it prints timings, it keeps the labels of the original run: gruppi is the aggregation, parquet_filtro the Parquet read with a filter, mediana the median and picco the peak.
import subprocess, sys
def esegui(compito, motore):
r = subprocess.run([sys.executable, "compiti.py", compito, motore], capture_output=True, text=True)
if r.returncode:
return f"ERRORE: {r.stderr.strip().splitlines()[-1]}"
lo, med, hi, rss = r.stdout.split()
return f"min {lo:>5} mediana {med:>5} max {hi:>5} ms picco {rss:>5} MB"
PROVE = [("gruppi", ["pandas", "polars"]), ("join", ["pandas", "polars"]),
("csv", ["pandas", "polars"]), ("parquet_filtro", ["pandas", "pandas_filters", "polars"])]
for compito, motori in PROVE:
print(compito)
for m in motori:
print(f" {m:<15} {esegui(compito, m)}")
# Output:
# gruppi
# pandas min 514 mediana 529 max 584 ms picco 2254 MB
# polars min 47 mediana 48 max 49 ms picco 907 MB
# join
# pandas min 690 mediana 742 max 964 ms picco 2401 MB
# polars min 367 mediana 530 max 651 ms picco 2210 MB
# csv
# pandas min 515 mediana 569 max 857 ms picco 2047 MB
# polars min 407 mediana 444 max 820 ms picco 1609 MB
# parquet_filtro
# pandas min 236 mediana 290 max 630 ms picco 2469 MB
# pandas_filters min 189 mediana 225 max 532 ms picco 781 MB
# polars min 39 mediana 40 max 171 ms picco 122 MB
How to read the table
Aggregation is where Polars pulls ahead the most: the pandas median is about ten times that of Polars, in all the series I ran. Behind it there is mainly parallelism, measured in the next section, and in part a columnar in-memory representation following the Arrow format. The join has a more modest advantage, around 1.4-2.4 times in my series: the discount table has 1 million keys and the work is dominated by random memory access, which no engine eliminates.
Reading the CSV is almost a tie, and here the classic story "pandas reads on one core" does not hold: the pandas 3.1.1 documentation says the C engine reads sufficiently large files in parallel, and the measurements confirm it (medians between 0.5 and 0.6 seconds for both, the two intervals overlap). The clearest case is Parquet with a filter: Polars reads only three columns out of four, discards the rows already in the scan and never materializes the whole table, so it ends up around 40-50 milliseconds with a peak of about 125 MB. Pandas without filters loads everything: over 2 GB of peak.
The most useful figure for whoever decides is the one on the right: pandas with filters cuts the memory peak from about 2.4 GB to about 0.8 GB and the time by a third or more (in my series from 1.6 to 3 times), without changing library. A substantial part of the "Polars advantage" on Parquet is therefore an advantage of how you read the file, and it can partly be obtained while staying in pandas. The rest (aggregation, join, memory in scans) is a real advantage of the engine.
How much parallelism is worth
The question the comparison alone does not settle is: does the advantage on aggregation come from the algorithm or from the cores? You see it by measuring two things together, real time and CPU time, while limiting the number of Polars threads with the POLARS_MAX_THREADS environment variable, which the documentation indicates as the way to set the pool size before the process starts. Each measurement runs in a new process, because after startup the pool cannot be changed. This listing too prints timings, so its labels stay as in the original run: ms reali is real milliseconds, ms di CPU CPU milliseconds and thread usati the threads used.
import os, subprocess, sys
CODICE = """
import time, polars as pl
df = pl.read_parquet("dati/ordini.parquet")
q = lambda: df.group_by("categoria").agg(pl.col("valore").mean(), pl.col("quantita").sum())
q() # warm-up
t, c = [], []
for _ in range(5):
w, p = time.perf_counter(), time.process_time()
q()
t.append(time.perf_counter() - w); c.append(time.process_time() - p)
print(f"{min(t)*1000:.0f} ms reali, {min(c)*1000:.0f} ms di CPU, thread usati: {pl.thread_pool_size()}")
"""
for n in (1, 2, 4, 12):
env = dict(os.environ, POLARS_MAX_THREADS=str(n))
r = subprocess.run([sys.executable, "-c", CODICE], env=env, capture_output=True, text=True)
print(f"POLARS_MAX_THREADS={n:>2}: {r.stdout.strip() or r.stderr.strip().splitlines()[-1]}")
# Output:
# POLARS_MAX_THREADS= 1: 221 ms reali, 221 ms di CPU, thread usati: 1
# POLARS_MAX_THREADS= 2: 112 ms reali, 222 ms di CPU, thread usati: 2
# POLARS_MAX_THREADS= 4: 61 ms reali, 237 ms di CPU, thread usati: 4
# POLARS_MAX_THREADS=12: 45 ms reali, 446 ms di CPU, thread usati: 12
With one thread Polars takes about 210-220 ms, against about 500 ms for pandas: a factor of 2.3 that comes from the implementation. Then real time drops almost linearly at 2 and 4 threads (about 115 ms and 58-68 ms) while CPU time stays the same: the work is the same, divided among more cores. At 12 threads the gain flattens (about 42-47 ms) and CPU time doubles, a sign of extra work to coordinate the threads. On a 2 vCPU machine, like many cheap virtual machines, the aggregation would therefore be closer to 4 times than to 10.
The lazy plan and what it hides
The Parquet example was fast because Polars does not execute the rows as you write them: it builds a plan and optimizes it at the moment of collect(). The following block shows the plan of the same query: the filter on quantity was pushed inside the scan (SELECTION) and only 3 columns out of 4 are read (PROJECT 3/4 COLUMNS).
import polars as pl
lf = pl.scan_parquet("dati/ordini.parquet").filter(pl.col("quantita") > 990) \
.group_by("categoria").agg(pl.col("valore").mean().alias("average"))
print(type(lf).__name__) # no computation has started yet
print(lf.explain()) # the optimized plan
result = lf.collect()
print(type(result).__name__, result.shape)
# Output:
# LazyFrame
# AGGREGATE[maintain_order: false]
# [col("valore").mean().alias("average")] BY [col("categoria")]
# FROM
# simple π 2/2 ["categoria", "valore"]
# Parquet SCAN [dati/ordini.parquet]
# PROJECT 3/4 COLUMNS
# SELECTION: col("quantita") > 990
# ESTIMATED ROWS: 20000000
# DataFrame (8, 2)
The classic mistake is forgetting collect() and ending up with a LazyFrame instead of the data. Since 2.0 there is also a novelty that can change results without warning you: the upgrade page of the documentation explains that with collect() the engine="auto" option now uses the streaming engine for lazy queries, and that this engine does not guarantee row order in group_by, in joins and in other operations. If your code depends on an order that nobody ever requested, sort explicitly or use the order-preserving options where they exist.
Migrating without changing the results
The first guarantee of a migration is that the same data give the same numbers. The following test runs four operations in pandas and in Polars on the same million rows and compares the results with assert_frame_equal, sorting the rows before the comparison because, as seen, the order is not guaranteed. I ignore the data type (check_dtype=False), because pandas and Polars do not represent integers and strings in the same way.
import pandas as pd
import polars as pl
pdf = pd.read_parquet("dati/ordini.parquet").head(1_000_000)
plf = pl.read_parquet("dati/ordini.parquet").head(1_000_000)
def ordina(df): # comparison independent of row order
return df.sort_values(list(df.columns)).reset_index(drop=True)
coppie = {
"filter": (pdf[pdf["quantita"] > 990],
plf.filter(pl.col("quantita") > 990).to_pandas()),
"selection": (pdf[["categoria", "valore"]],
plf.select("categoria", "valore").to_pandas()),
"aggregation": (pdf.groupby("categoria", as_index=False)["quantita"].sum(),
plf.group_by("categoria").agg(pl.col("quantita").sum()).to_pandas()),
"new column": (pdf.assign(total=pdf["valore"] * pdf["quantita"]),
plf.with_columns((pl.col("valore") * pl.col("quantita")).alias("total")).to_pandas()),
}
for nome, (a, b) in coppie.items():
pd.testing.assert_frame_equal(ordina(a), ordina(b), check_dtype=False)
print(f"{nome:<14} identical ({len(a)} rows)")
# Output:
# filter identical (9154 rows)
# selection identical (1000000 rows)
# aggregation identical (8 rows)
# new column identical (1000000 rows)
The table collects the correspondences that the test verified, plus the lazy read that has no direct equivalent in pandas:
| Operation | pandas | Polars |
|---|---|---|
| Filter | df[df["x"] > 5] | df.filter(pl.col("x") > 5) |
| Selection | df[["a", "b"]] | df.select("a", "b") |
| Aggregation | df.groupby("c")["q"].sum() | df.group_by("c").agg(pl.col("q").sum()) |
| New column | df.assign(t=df["v"] * df["q"]) | df.with_columns((pl.col("v") * pl.col("q")).alias("t")) |
| Join | a.merge(b, on="k") | a.join(b, on="k") |
| Lazy read | read_parquet(..., filters=...) | pl.scan_parquet(...).filter(...).collect() |
The biggest conceptual difference is not in the syntax but in the index: Polars has no row indexes and no MultiIndex, and every row is identified by its position, as the migration guide in the official documentation says. If your pandas code uses set_index, loc with labels or unstack, the rewrite is not mechanical. Another trap: the name groupby used by many old tutorials no longer exists, and is now group_by.
import polars as pl
df = pl.DataFrame({"categoria": ["a", "b", "a"], "valore": [1, 2, 3]})
try:
df.groupby("categoria").agg(pl.col("valore").sum()) # name used by the old tutorials
except AttributeError as e:
print("AttributeError:", e)
print(df.group_by("categoria").agg(pl.col("valore").sum()).sort("categoria").to_dict(as_series=False))
# Output:
# AttributeError: 'DataFrame' object has no attribute 'groupby'
# {'categoria': ['a', 'b'], 'valore': [4, 2]}
NaN and null: where results diverge
Missing values are the most concrete cause of different results after the migration. Pandas uses NaN (and sometimes None) and, in the default types, turns an integer column containing a hole into a decimal one. In Polars the missing value is always null, the integer column stays integer, and NaN is a decimal value like any other, which does not count as missing. The listing compares the two.
import numpy as np
import pandas as pd
import polars as pl
pdf = pd.DataFrame({"x": [1.0, np.nan, 3.0], "n": [1, None, 3]})
print(pdf.dtypes.to_dict()) # pandas: the integer with a hole becomes float
print("pandas, mean of x:", pdf["x"].mean())
native = pl.DataFrame({"x": [1.0, float("nan"), None], "n": [1, None, 3]})
print(native.schema) # Polars: the integer stays integer
print("Polars, nan and null are two different things:")
print(native.select(
nan=pl.col("x").is_nan(), null=pl.col("x").is_null()).to_dict(as_series=False))
print("Polars, mean of x:", native["x"].mean())
# the conversion from pandas turns NaN into null (parameter nan_to_null)
print("from pandas:", pl.from_pandas(pdf)["x"].null_count(), "null out of", len(pdf))
# Output:
# {'x': dtype('float64'), 'n': dtype('float64')}
# pandas, mean of x: 2.0
# Schema({'x': Float64, 'n': Int64})
# Polars, nan and null are two different things:
# {'nan': [False, True, None], 'null': [False, False, True]}
# Polars, mean of x: nan
# from pandas: 1 null out of 3
The pandas mean ignores the NaN (2.0), while in Polars the column with NaN and null gives nan: the NaN contaminates the computation and the null is ignored. The pl.from_pandas conversion turns NaN into null, so data passed that way behaves as in pandas, while data read from a file that already contains NaN does not. Always add a test on your dirtiest data.
Polars and DuckDB in the same program
You do not have to choose a single tool. DuckDB can read a Polars DataFrame present in the program as if it were a table, citing it by variable name, and return the result as a Polars DataFrame with the .pl() method. It is handy when a transformation is better written in SQL, and the data handover is columnar, through Arrow. The complete composition of a pipeline is in the article DuckDB and Polars: a lean pipeline in Python, while the choice between DuckDB and Spark is in DuckDB in production.
import duckdb
import polars as pl
df = pl.read_parquet("dati/ordini.parquet")
# DuckDB reads the Python variable `df` directly (replacement scan) and returns a Polars DataFrame
top = duckdb.sql("""
SELECT categoria, count(*) AS row_count, round(avg(valore), 2) AS average
FROM df GROUP BY categoria ORDER BY row_count DESC LIMIT 3
""").pl()
print(type(top).__module__.split(".")[0], top.shape)
print(top)
# Output:
# polars (3, 3)
# shape: (3, 3)
# ┌───────────┬───────────┬─────────┐
# │ categoria ┆ row_count ┆ average │
# │ --- ┆ --- ┆ --- │
# │ str ┆ i64 ┆ f64 │
# ╞═══════════╪═══════════╪═════════╡
# │ libri ┆ 2501822 ┆ 99.99 │
# │ casa ┆ 2501488 ┆ 100.0 │
# │ sport ┆ 2501032 ┆ 100.02 │
# └───────────┴───────────┴─────────┘
Here duckdb.sql(...) finds the variable df in the Python scope (the so-called replacement scan). The DuckDB documentation specifies that a DataFrame is converted in full and filtered afterwards, while a LazyFrame receives the column selection and the translatable filters: with large data, pass a LazyFrame. If you rename the variable, the query stops working with a nonexistent-table error. For production use, prefer to register the DataFrame explicitly with the name you want.
When migrating pays off, with the numbers
A migration costs days of development and testing; the benefit is machine time, memory and, sometimes, the possibility of using a smaller machine. The listing computes how long it takes to recover the cost with the compute savings alone. The values are my own examples and are declared as such in the code: replace them with yours, and above all with the times measured on your job.
# EXAMPLE values: replace them with yours. None is a measurement.
seconds_pandas = 300 # duration of the job today, per run
seconds_polars = 60 # duration after the migration (to be measured on YOUR code)
runs_per_day = 24
machine_cost_per_hour = 0.50 # euro/hour of the machine the job runs on
dev_days = 6
dev_day_cost = 400 # euro
savings_per_day = (seconds_pandas - seconds_polars) * runs_per_day / 3600 * machine_cost_per_hour
migration_cost = dev_days * dev_day_cost
print(f"compute savings per day: {savings_per_day:.2f} euro")
print(f"migration cost: {migration_cost} euro")
print(f"break-even on compute alone after: {migration_cost / savings_per_day:.0f} days")
# Output:
# compute savings per day: 0.80 euro
# migration cost: 2400 euro
# break-even on compute alone after: 3000 days
The result is unpleasant and instructive: even bringing a job from 300 to 60 seconds, 24 times a day, the compute saving is less than one euro a day, and break-even comes after years. If the only reason for the migration is the cost of the machine, it often does not pay off. It pays off when the job no longer fits in the machine's memory, when it exceeds the nightly window available or when the analysts' waiting time is the real cost.
The practical rule I draw from it has two halves. Stay on pandas if the data are small, if the code depends on indexes or on libraries that expect a pandas DataFrame, or if the team has no time for the switch; move to Polars when a measurement on your workload shows a time or a memory use you can no longer accept. The two coexist well: to_pandas() and pl.from_pandas() are designed for this.
What you can do now
You can set up an honest comparison between pandas and Polars: data with a fixed seed, one process per trial, minimum-median-maximum and memory peak. You can recognize where the advantage is real (aggregation, Parquet scans) and where it is modest or nil (reading large CSVs), check that a migration does not change the results, and do the math before rewriting. For the formats to put these files in, move on to Iceberg, Delta Lake and Hudi; to version the results, to lakeFS, where you will also find the license change to know about.
Frequently asked questions
Is Polars always faster than pandas?
No. In my measurements on 20 million rows it wins clearly on aggregation and on Parquet reads with a filter, wins slightly on the join and ties on reading a large CSV. With small data the difference is negligible compared with Python's startup time.
Can I use Polars and pandas in the same project?
Yes. DataFrame.to_pandas() and pl.from_pandas() convert in both directions, and this article's equivalence test uses them. Watch out for missing values: the conversion from pandas turns NaN into null.
Why does the same query return rows in a different order?
Since version 2.0 the streaming engine is the default for lazy queries and does not guarantee row order in group_by and in joins. If you need an order, add an explicit sort to the result.
Do the licenses allow commercial use?
Polars is distributed under the MIT license, as the project declares on its site; pandas under the BSD-3-Clause license according to the metadata on PyPI. The Polars team also sells a separate managed platform, which you do not need in order to use the library.
Sources
- Polars user guide: Upgrade guide to version 2 - default streaming engine for lazy queries and row order not guaranteed, consulted on 2026-11-13
- Polars: LazyFrame.collect - meaning of
engine="auto","in-memory"and"streaming", consulted on 2026-11-13 - Polars user guide: Coming from pandas - absence of the index, Arrow representation, missing values and
NaN, consulted on 2026-11-13 - Polars: project website - MIT license and separate commercial platform, consulted on 2026-11-13
- pandas: read_csv - the C engine reads large files in parallel, consulted on 2026-11-13
- Polars: thread_pool_size - the
POLARS_MAX_THREADSvariable and the pool size, consulted on 2026-11-13 - PyPI: polars - version 2.1.0 of 2026-10-25, consulted on 2026-11-13
- PyPI: pandas - version 3.1.1 of 2026-11-04 and BSD-3-Clause license, consulted on 2026-11-13
All the listings were run with Python 3.14.4, pandas 3.1.1 and Polars 2.1.0. Those with a fixed output were launched twice with identical results; the timing table comes from a single run and changes from one to the next, while the cost calculation uses example values. The listings that print timings keep the labels of the original run, in Italian, and were not rerun for the English edition.

Commenti
Caricamento commenti...
Sign in to comment